tmpNote

type Slice []int

func NewSlice() Slice {
	return make(Slice, 0)

}

func (s *Slice) Add(elem int) *Slice {

	*s = append(*s, elem)

	fmt.Print(elem)

	return s

}

func TestAdd(t *testing.T) {
	s := NewSlice()
	defer s.Add(1).Add(2)
	s.Add(3)
	const zero = 0.0
	fmt.Println(reflect.TypeOf(zero))
}

func TestClosure(t *testing.T) {
	runtime.GOMAXPROCS(1)
	wg := sync.WaitGroup{}
	wg.Add(20)
	for i := 0; i < 10; i++ {
		go func() {
			fmt.Println("A: ", i)
			wg.Done()
		}()
	}
	for i := 0; i < 10; i++ {
		go func(i int) {
			fmt.Println("B: ", i)
			wg.Done()
		}(i)
	}
	wg.Wait()
}

func TestSelect(t *testing.T) {
	/*select可以在多个chan间等待执行。有三点原则：

	  select 中只要有一个case能return，则立刻执行。
	  当如果同一时间有多个case均能return则伪随机方式抽取任意一个执行。
	  如果没有一个case能return则可以执行”default”块。*/
	runtime.GOMAXPROCS(1)
	int_chan := make(chan int, 1)
	string_chan := make(chan string, 1)
	int_chan <- 1
	string_chan <- "hello"
	select {
	case value := <-int_chan:
		fmt.Println(value)
	case value := <-string_chan:
		panic(value)
	}

}

func TestDefer(t *testing.T) {
	f := func(index string, a, b int) int {
		ret := a + b
		fmt.Println(index, a, b, ret)
		return ret
	}

	a := 1
	b := 2
	defer f("1", a, f("10", a, b))
	a = 0
	defer f("2", a, f("20", a, b))
	b = 1
}

type threadSafeSet struct {
	sync.RWMutex
	s []interface{}
}

func (set *threadSafeSet) Iter() <-chan interface{} {
	ch := make(chan interface{}) // 解除注释看看！
	//ch := make(chan interface{}, len(set.s))
	go func() {
		set.RLock()
		for elem, value := range set.s {
			ch <- elem
			println("Iter:", elem, value)
		}
		close(ch)
		set.RUnlock()
	}()
	return ch
}
func TestBuffChan(t *testing.T) {
	th := threadSafeSet{s: []interface{}{"1", "2"}}
	v := <-th.Iter()
	v = <-th.Iter()
	fmt.Sprintf("%s%v", "ch", v)

}

type People interface {
	Speak(arg string)
}
type Student struct {
}

func (*Student) Speak(arg string) {
	fmt.Println(arg)
}
func TestInterface(t *testing.T) {
	var p = Student{}
	//var p People = Student{}
	arg := "hi"
	p.Speak(arg)
	list := new([]int)
	*list = append(*list, 1)
	fmt.Println(list)
}

func TestIota(t *testing.T) {
	const (
		x = iota
		y
		z = "zz"
		k
		p = iota
	)
	fmt.Println(x, y, z, k, p)
}

func TestConst(t *testing.T) {
	const cl = 100
	var bl = 123

	println(&bl, bl)
	//println(&cl, cl)  // Cannot take the address of 'cl'
}

func main1() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		} else {
			fmt.Println("fatal")
		}
	}()
	defer func() {
		panic("deferpanic")
	}()
	panic("panic")
}
func main2() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("++++")
			f := err.(func() string)
			fmt.Println(err, f(), reflect.TypeOf(err).Kind().String())
		} else {
			fmt.Println("fatal")
		}
	}()
	defer func() {
		panic(func() string {
			return "defer panic"
		})
	}()
	panic("panic")
}
func TestRecover(t *testing.T) {
	main1()
	main2()

}