func CheckType(v interface{}) {
	t := reflect.TypeOf(v)
	switch t.Kind() {
	case reflect.Float32, reflect.Float64:
		fmt.Println("Float")
	case reflect.Int, reflect.Int32, reflect.Int64:
		fmt.Println("Integer")
	default:
		fmt.Println("Unknown", t)
	}
}

func TestBasicType(t *testing.T) {
	var f float64 = 12
	CheckType(f)
	/** 运行结果：
	=== RUN   TestBasicType
	Float
	--- PASS: TestBasicType (0.00s)
	*/
}

type Employee struct {
	EmployeeId string
	Name       string `format:"normal"`
	Age        int
}

func (e *Employee) UpdateAge(newVal int) {
	e.Age = newVal
}

func TestInvokeByName(t *testing.T) {
	e := &Employee{"1", "Mike", 30}
	// 按名字获取成员
	t.Logf("Name：value(%[1]v)，Type(%[1]T)", reflect.ValueOf(*e).FieldByName("Name"))
	if nameField, ok := reflect.TypeOf(*e).FieldByName("Name"); !ok {
		t.Error("Failed to get 'Name' field.")
	} else {
		t.Log("Tag:format", nameField.Tag.Get("format"))
	}
	reflect.ValueOf(e).MethodByName("UpdateAge").Call([]reflect.Value{reflect.ValueOf(1)})
	t.Log("Updated Age:", e)
	/** 运行结果：
	=== RUN   TestInvokeByName
	    TestInvokeByName: reflect_test.go:28: Name：value(Mike)，Type(reflect.Value)
	    TestInvokeByName: reflect_test.go:32: Tag:format normal
	    TestInvokeByName: reflect_test.go:35: Updated Age: &{1 Mike 1}
	--- PASS: TestInvokeByName (0.00s)
	*/
}

type BasicInfo struct {
  Name string `json:"name"`
  Age int `json:"age"`
}

if nameField, ok := reflect.TypeOf(*e).FieldByName("Name"); !ok {
t.Error("Failed to get 'Name' field.")
} else {
t.Log("Tag:format", nameField.Tag.Get("format")) }

type Customer struct {
	CookieID string
	Name     string
	Age      int
}

func TestDeepEqual(t *testing.T) {
	a := map[int]string{1: "one", 2: "two", 3: "three"}
	b := map[int]string{1: "one", 2: "two", 4: "three"}
	fmt.Println(reflect.DeepEqual(a, b))

	s1 := []int{1, 2, 3}
	s2 := []int{1, 2, 3}
	s3 := []int{2, 3, 1}
	t.Log("s1 == s2?", reflect.DeepEqual(s1, s2))
	t.Log("s1 == s3?", reflect.DeepEqual(s1, s3))

	c1 := Customer{"1", "Mike", 40}
	c2 := Customer{"1", "Mike", 40}

	fmt.Println(reflect.DeepEqual(c1, c2))
	/** 运行结果：
	=== RUN   TestDeepEqual
	false
	    TestDeepEqual: fiexible_reflect_test.go:23: s1 == s2? true
	    TestDeepEqual: fiexible_reflect_test.go:24: s1 == s3? false
	true
	--- PASS: TestDeepEqual (0.00s)
	*/
}

type Employee struct {
	EmployeeID string
	Name       string `format:"normal"`
	Age        int
}

func (e *Employee) UpdateAge(newVal int) {
	e.Age = newVal
}

type Customer struct {
	CookieID string
	Name     string
	Age      int
}

func fillBySettings(st interface{}, settings map[string]interface{}) error {

	// func (v Value) Elem() Value
	// Elem returns the value that the interface v contains or that the pointer v points to.
	// It panics if v's Kind is not Interface or Ptr.
	// It returns the zero Value if v is nil.

	if reflect.TypeOf(st).Kind() != reflect.Ptr {
		return errors.New("the first param should be a pointer to the struct type.")
	}
	// Elem() 获取指针指向的值
	if reflect.TypeOf(st).Elem().Kind() != reflect.Struct {
		return errors.New("the first param should be a pointer to the struct type.")
	}

	if settings == nil {
		return errors.New("settings is nil.")
	}

	var (
		field reflect.StructField
		ok    bool
	)

	for k, v := range settings {
		if field, ok = (reflect.ValueOf(st)).Elem().Type().FieldByName(k); !ok {
			continue
		}
		if field.Type == reflect.TypeOf(v) {
			vstr := reflect.ValueOf(st)
			vstr = vstr.Elem()
			vstr.FieldByName(k).Set(reflect.ValueOf(v))
		}

	}
	return nil
}

func TestFillNameAndAge(t *testing.T) {
	settings := map[string]interface{}{"Name": "Mike", "Age": 30}
	e := Employee{}
	if err := fillBySettings(&e, settings); err != nil {
		t.Fatal(err)
	}
	t.Log(e)
	c := new(Customer)
	if err := fillBySettings(c, settings); err != nil {
		t.Fatal(err)
	}
	t.Log(*c)
	/** 运行结果：
	=== RUN   TestFillNameAndAge
	    TestFillNameAndAge: fiexible_reflect_test.go:69: { Mike 30}
	    TestFillNameAndAge: fiexible_reflect_test.go:74: { Mike 30}
	--- PASS: TestFillNameAndAge (0.00s)
	*/
}

func TestUnsafe(t *testing.T) {
	i := 10
	f := *(*float64)(unsafe.Pointer(&i))
	t.Log(unsafe.Pointer(&i))
	t.Log(f)
	/** 运行结果：
	=== RUN   TestUnsafe
	    TestUnsafe: unsafe_test.go:11: 0xc000016268
	    TestUnsafe: unsafe_test.go:12: 5e-323
	--- PASS: TestUnsafe (0.00s)
	*/
}

// The cases is suitable for unsafe
type MyInt int

// 合理的类型转换
func TestConvert(t *testing.T) {
	a := []int{1, 2, 3, 4}
	b := *(*[]MyInt)(unsafe.Pointer(&a))
	t.Log(b)
	/** 运行结果：
	=== RUN   TestConvert
	    TestConvert: unsafe_test.go:26: [1 2 3 4]
	--- PASS: TestConvert (0.00s)
	*/
}

// 原子类型操作
func TestAtomic(t *testing.T) {
	var shareBuffer unsafe.Pointer
	writeDataFn := func() {
		data := []int{}
		for i := 0; i < 100; i++ {
			data = append(data, i)
		}
		atomic.StorePointer(&shareBuffer, unsafe.Pointer(&data))
	}
	readDataFn := func() {
		data := atomic.LoadPointer(&shareBuffer)
		fmt.Println(data, *(*[]int)(data))
	}
	var wg sync.WaitGroup
	writeDataFn()
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			for i := 0; i < 10; i++ {
				writeDataFn()
				time.Sleep(time.Microsecond * 100)
			}
			wg.Done()
		}()
		wg.Add(1)
		go func() {
			for i := 0; i < 10; i++ {
				readDataFn()
				time.Sleep(time.Microsecond * 100)
			}
			wg.Done()
		}()
	}
	wg.Wait()
}

func TestErrorInCode(t *testing.T) {
	fmt.Println("Start")
	t.Error("Error")
	fmt.Println("End")
	/** 运行结果：
	=== RUN   TestErrorInCode
	Start
	    TestErrorInCode: functions_test.go:25: Error
	End
	--- FAIL: TestErrorInCode (0.00s)
	*/
}

func TestFatalInCode(t *testing.T) {
	fmt.Println("Start")
	t.Fatal("Error")
	fmt.Println("End")
	/** 运行结果：
	=== RUN   TestFatalInCode
	Start
	    TestFatalInCode: functions_test.go:38: Error
	--- FAIL: TestFatalInCode (0.00s)
	*/
}

func square(op int) int {
	return op * op
}

func TestSquareWithAssert(t *testing.T) {
	inputs := [...]int{1, 2, 3}
	expected := [...]int{1, 4, 9}
	for i := 0; i < len(inputs); i++ {
		ret := square(inputs[i])
		assert.Equal(t, expected[i], ret)
	}
}

// 利用+=连接
func TestConcatStringByAdd(t *testing.T) {
	assert := assert.New(t)
	elems := []string{"1", "2", "3", "4", "5"}
	ret := ""
	for _, elem := range elems {
		ret += elem
	}
	assert.Equal("12345", ret)
}

// 利用buffer连接
func TestConcatStringBytesBuffer(t *testing.T) {
	assert := assert.New(t)
	var buf bytes.Buffer
	elems := []string{"1", "2", "3", "4", "5"}
	for _, elem := range elems {
		buf.WriteString(elem)
	}
	assert.Equal("12345", buf.String())
}

func BenchmarkConcatStringByAdd(b *testing.B) {
	elems := []string{"1", "2", "3", "4", "5"}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ret := ""
		for _, elem := range elems {
			ret += elem
		}
	}
	b.StopTimer()
}

func BenchmarkConcatStringBytesBuffer(b *testing.B) {
	elems := []string{"1", "2", "3", "4", "5"}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		var buf bytes.Buffer
		for _, elem := range elems {
			buf.WriteString(elem)
		}
	}
}

func TestSpec(t *testing.T) {
	convey.Convey("Given 2 even numbers", t, func() {
		a := 2
		b := 4
		convey.Convey("When add the two numbers", func() {
			c := a + b
			convey.Convey("Then the result is still even", func() {
				convey.So(c%2, convey.ShouldEqual, 0)
			})
		})
	})
}

type Singleton struct {
}

var singleInstance *Singleton
var once sync.Once

func GetSingletonObj() *Singleton {
	once.Do(func() {
		fmt.Println("Create Obj")
		singleInstance = new(Singleton)
	})
	return singleInstance
}

func TestGetSingletonObj(t *testing.T) {
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			obj := GetSingletonObj()
			fmt.Printf("%x\n", unsafe.Pointer(obj))
			wg.Done()
		}()
	}
	wg.Wait()
	/** 运行结果：
	=== RUN   TestGetSingletonObj
	Create Obj
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	--- PASS: TestGetSingletonObj (0.00s)
	*/
}

func runTask(id int) string {
	time.Sleep(10 * time.Millisecond)
	return fmt.Sprintf("the result is from %d", id)
}

func FirstResponse() string {
	numOfRunner := 10
	ch := make(chan string) // 非缓冲channel
	for i := 0; i < numOfRunner; i++ {
		go func(i int) {
			ret := runTask(i)
			ch <- ret
		}(i)
	}
	return <-ch
}

func TestFirstResponse(t *testing.T) {
	t.Log(FirstResponse())
	/** 第一次运行结果：
	=== RUN   TestFirstResponse
	    TestFirstResponse: first_response_test.go:27: the result is from 0
	--- PASS: TestFirstResponse (0.01s)
	*/
	/** 第二次运行结果：
	=== RUN   TestFirstResponse
	    TestFirstResponse: first_response_test.go:27: the result is from 3
	--- PASS: TestFirstResponse (0.01s)
	*/
}

func TestFirstResponse(t *testing.T) {
	t.Log("Before:", runtime.NumGoroutine()) // 获取协程数量
	t.Log(FirstResponse())
	time.Sleep(time.Second * 1)
	t.Log("After:", runtime.NumGoroutine()) // 获取协程数量
	/** 运行结果：
	=== RUN   TestFirstResponse
	    TestFirstResponse: first_response_test.go:28: Before: 2
	    TestFirstResponse: first_response_test.go:29: the result is from 6
	    TestFirstResponse: first_response_test.go:30: After: 11
	--- PASS: TestFirstResponse (0.01s)
	*/
}

func runTask(id int) string {
	time.Sleep(10 * time.Millisecond)
	return fmt.Sprintf("the result is from %d", id)
}

func AllResponse() string {
	numOfRunner := 10
	ch := make(chan string) // 非缓冲channel
	for i := 0; i < numOfRunner; i++ {
		go func(i int) {
			ret := runTask(i)
			ch <- ret
		}(i)
	}

	finalRet := ""
	for i := 0; i < numOfRunner; i++ {
		finalRet += <-ch + "\n"
	}

	return finalRet
}

func TestFirstResponse(t *testing.T) {
	t.Log(AllResponse())
	/** 运行结果：
	=== RUN   TestFirstResponse
	    TestFirstResponse: all_done_test.go:33: the result is from 9
	        the result is from 0
	        the result is from 2
	        the result is from 7
	        the result is from 4
	        the result is from 6
	        the result is from 1
	        the result is from 5
	        the result is from 8
	        the result is from 3

	--- PASS: TestFirstResponse (0.01s)
	*/
}

type ReusableObj struct {
}

type ObjPool struct {
	bufChan chan *ReusableObj // 用于缓冲可重用对象
}

func NewObjPool(numOfObj int) *ObjPool {
	objPool := ObjPool{}
	objPool.bufChan = make(chan *ReusableObj, numOfObj)
	// 提前建立好连接
	for i := 0; i < numOfObj; i++ {
		objPool.bufChan <- &ReusableObj{}
	}
	return &objPool
}

// 获取连接
func (p *ObjPool) GetObj(timeout time.Duration) (*ReusableObj, error) {
	select {
	case ret := <-p.bufChan:
		return ret, nil
	case <-time.After(timeout): // 超时控制
		return nil, errors.New("time out")
	}
}

// 放入连接
func (p *ObjPool) ReleaseObj(obj *ReusableObj) error {
	select {
	case p.bufChan <- obj:
		return nil
	default:
		return errors.New("overflow")
	}
}

func TestObjPool(t *testing.T) {
	pool := NewObjPool(10) // 创建对象池

	for i := 0; i < 11; i++ {
		// 从对象池中获取
		if v, err := pool.GetObj(time.Second * 1); err != nil {
			t.Error(err)
		} else {
			fmt.Println(v)
			// 放入对象池
			if err := pool.ReleaseObj(v); err != nil {
				t.Error(err)
			}
		}
	}

	fmt.Println("Done")
}

func TestSyncPool(t *testing.T) {
	pool := &sync.Pool{
		New: func() interface{} {
			fmt.Println("Create a new object.")
			return 100
		},
	}

	v := pool.Get().(int) // 从池中获取并断言类型
	fmt.Println(v)        // 100

	pool.Put(3)
	v1, _ := pool.Get().(int)
	fmt.Println(v1) // 3

	//在放进去个 2
	pool.Put(2)
	//为了验证生命周期 这里GC一下
	runtime.GC()
	v3, _ := pool.Get().(int)
	fmt.Println(v3) // 100 而不是 2
	/** 运行结果：
	=== RUN   TestSyncPool
	Create a new object.
	100
	3
	Create a new object.
	100
	--- PASS: TestSyncPool (0.00s)
	*/
}

func TestSyncPoolMultiGoroutine(t *testing.T) {
	pool := sync.Pool{
		New: func() interface{} {
			fmt.Println("Create a new object.")
			return 10
		},
	}

	pool.Put(100)
	pool.Put(100)
	pool.Put(100)

	var wg sync.WaitGroup

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			t.Log(pool.Get())
			wg.Done()
		}()
	}
	wg.Wait()
	/** 运行结果：
	=== RUN   TestSyncPoolMultiGoroutine
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 100
	Create a new object.
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	Create a new object.
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 100
	Create a new object.
	Create a new object.
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	Create a new object.
	Create a new object.
	Create a new object.
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 100
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	--- PASS: TestSyncPoolMultiGoroutine (0.00s)
	*/
}

func TestGroutine(t *testing.T) {
	for i := 0; i < 10; i++ {
		// int 参数
		go func(i int) {
			fmt.Println(i)
		}(i) // 传入参数
	}
	// 有可能测试程序结束的非常快 加个等待
	time.Sleep(time.Millisecond * 50)
	/** 运行结果
	=== RUN   TestGroutine
	1
	4
	5
	2
	6
	3
	0
	8
	9
	7
	--- PASS: TestGroutine (0.05s)
	*/
}

func TestCounter(t *testing.T) {
	counter := 0
	for i := 0; i < 5000; i++ {
		go func(i int) {
			counter++
		}(i)
	}
	time.Sleep(time.Second * 1)
	t.Logf("counter = %d", counter)
	/** 运行结果：
	=== RUN   TestCounter
	    TestCounter: share_memory_test.go:16: counter = 4627
	--- PASS: TestCounter (1.01s)
	*/
}

func TestCounterThreadSafe(t *testing.T) {
	var mut sync.Mutex
	counter := 0
	for i := 0; i < 5000; i++ {
		go func(i int) {
			// defer 释放锁
			defer func() {
				mut.Unlock()
			}()
			// 加锁
			mut.Lock()
			counter++
		}(i)
	}
	time.Sleep(time.Second * 1)
	t.Logf("counter = %d", counter)
	/** 运行结果：
	=== RUN   TestCounterThreadSafe
	    TestCounterThreadSafe: share_memory_test.go:40: counter = 5000
	--- PASS: TestCounterThreadSafe (1.01s)
	*/
}

func TestCounterWaitGroup(t *testing.T) {
	var mut sync.Mutex
	var wg sync.WaitGroup
	counter := 0
	for i := 0; i < 5000; i++ {
		wg.Add(1) // 增加一个要等待的协程
		go func(i int) {
			// defer 释放锁
			defer func() {
				mut.Unlock()
			}()
			// 加锁
			mut.Lock()
			counter++
			wg.Done() // 一个协程完成了
		}(i)
	}
	wg.Wait() // 等待所有添加的协程完成 才继续向下运行
	t.Logf("counter = %d", counter)
	/** 运行结果：
	=== RUN   TestCounterWaitGroup
	    TestCounterWaitGroup: share_memory_test.go:66: counter = 5000
	--- PASS: TestCounterWaitGroup (0.00s)
	*/
}

func service() string {
	time.Sleep(time.Millisecond * 50) // 模拟阻塞
	return "Done"
}

func otherTask() {
	fmt.Println("working on something else")
	time.Sleep(time.Millisecond * 100) // 模拟阻塞
	fmt.Println("Task is done.")
}

func TestService(t *testing.T) {
	fmt.Println(service())
	otherTask()
	/** 运行结果：
	=== RUN   TestService
	Done
	working on something else
	Task is done.
	--- PASS: TestService (0.16s)
	*/
}

func service() string {
	time.Sleep(time.Millisecond * 50) // 模拟阻塞
	return "Done"
}

func otherTask() {
	fmt.Println("working on something else")
	time.Sleep(time.Millisecond * 100) // 模拟阻塞
	fmt.Println("Task is done.")
}

func AsyncService() chan string {
	retCh := make(chan string) // 创建一个非缓冲string类型的channel
	//retCh := make(chan string, 1) // 创建一个容量为1 string类型的缓冲channel
	go func() {
		ret := service()
		fmt.Println("returned result.")
		retCh <- ret // 放入 channel
		fmt.Println("service exited.")
	}()
	return retCh
}

func TestAsyncService(t *testing.T) {
	retCh := AsyncService()
	otherTask()
	fmt.Println(<-retCh) // 从channel拿出
	/** 运行结果
	=== RUN   TestAsyncService
	working on something else
	returned result.
	Task is done.
	Done
	service exited.
	--- PASS: TestAsyncService (0.10s)
	*/
}

func service() string {
	time.Sleep(time.Millisecond * 500) // 模拟阻塞
	return "Done"
}

func AsyncService() chan string {
	retCh := make(chan string) // 创建一个非缓冲channel
	//retCh := make(chan string, 10) // 创建一个容量为10的缓冲channel
	go func() {
		ret := service()
		fmt.Println("returned result.")
		retCh <- ret // 放入 channel
		fmt.Println("service exited.")
	}()
	return retCh
}

func TestSelect(t *testing.T) {
	// 上面模拟阻塞 500ms
	select {
	case ret := <-AsyncService():
		t.Log(ret)
	case <-time.After(time.Millisecond * 100):
		t.Error("time out")
	}
	/** 运行结果：
	=== RUN   TestSelect
	    TestSelect: select_test.go:31: time out
	--- FAIL: TestSelect (0.10s)
	*/
}

// 生产者
func dataProducer(ch chan int, wg *sync.WaitGroup) {
	go func() {
		for i := 0; i < 10; i++ {
			ch <- i // 放入
		}
		wg.Done()
	}()
}

// 消费者
func dataReceiver(ch chan int, wg *sync.WaitGroup) {
	go func() {
		for i := 0; i < 10; i++ {
			data := <-ch // 取出
			fmt.Println(data)
		}
		wg.Done()
	}()
}

func TestCloseChannel(t *testing.T) {
	var wg sync.WaitGroup
	ch := make(chan int)
	wg.Add(1)
	dataProducer(ch, &wg)
	wg.Add(1)
	dataReceiver(ch, &wg)
	wg.Wait()
	/** 运行结果：
	=== RUN   TestCloseChannel
	0
	1
	2
	3
	4
	5
	6
	7
	8
	9
	--- PASS: TestCloseChannel (0.00s)
	*/
}

func dataReceiver(ch chan int, wg *sync.WaitGroup) {
	go func() {
		for {
			if data, ok := <-ch; ok { // ok 为 true
				fmt.Println(data)
			} else { // 结束循环
				break
			}
		}
		wg.Done()
	}()
}

func TestCloseChannel(t *testing.T) {
	var wg sync.WaitGroup
	ch := make(chan int)
	wg.Add(1)
	dataProducer(ch, &wg)
	wg.Add(1)
	dataReceiver(ch, &wg)
	wg.Add(1)
	dataReceiver(ch, &wg)
	wg.Wait()
	/** 运行结果：
  === RUN   TestCloseChannel
  0
  1
  2
  3
  5
  6
  7
  8
  4
  9
  --- PASS: TestCloseChannel (0.00s)
	*/
}

func dataReceiver(ch chan int, wg *sync.WaitGroup) {
	go func() {
		for i := 0; i < 11; i++ { // 上面 dataProducer 放进去了10个
			data := <-ch
			fmt.Println(data) // 当通道被关闭 会返回一个这个通道定义类型的零值
		}
		wg.Done()
	}()
}

func cancel_1(cancelChan chan struct{}) {
	cancelChan <- struct{}{} // 往 channel 中放入消息
}
func cancel_2(cancelChan chan struct{}) {
	close(cancelChan)
}

func isCancelled(cancelChan chan struct{}) bool {
	select {
	case <-cancelChan: // 从 channel 中收到消息 返回true
		return true
	default:
		return false
	}
}

func TestCancel(t *testing.T) {
	cancelChan := make(chan struct{}, 0)
	for i := 0; i < 5; i++ { // 启动5个协程任务
		go func(i int, cancelChan chan struct{}) {
			for { // 每个任务一直在执行
				if isCancelled(cancelChan) { // 每次检查是否任务是否进行停止 进行停止
					break
				}
				time.Sleep(time.Millisecond * 5)
			}
			fmt.Println(i, "Cancelled")
		}(i, cancelChan)
	}
	cancel_1(cancelChan)
	time.Sleep(time.Second * 1)
	/** 运行结果：
	=== RUN   TestCancel
	4 Cancelled
	--- PASS: TestCancel (1.00s)
	*/
}

func TestCancel(t *testing.T) {
	cancelChan := make(chan struct{}, 0)
	for i := 0; i < 5; i++ { // 启动5个协程任务
		go func(i int, cancelChan chan struct{}) {
			for { // 每个任务一直在执行
				if isCancelled(cancelChan) { // 每次检查是否任务是否进行停止 进行停止
					break
				}
				time.Sleep(time.Millisecond * 5)
			}
			fmt.Println(i, "Cancelled")
		}(i, cancelChan)
	}
	cancel_2(cancelChan)
	time.Sleep(time.Second * 1)
	/** 运行结果：
	=== RUN   TestCancel
	4 Cancelled
	2 Cancelled
	1 Cancelled
	0 Cancelled
	3 Cancelled
	--- PASS: TestCancel (1.00s)
	*/
}

func isCancelled(ctx context.Context) bool {
	select {
	case <-ctx.Done():
		return true
	default:
		return false
	}
}

func TestCancel(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	for i := 0; i < 5; i++ { // 启动5个协程任务
		go func(i int, ctx context.Context) {
			for { // 每个任务一直在执行
				if isCancelled(ctx) {
					break
				}
				time.Sleep(time.Millisecond * 5)
			}
			fmt.Println(i, "Cancelled")
		}(i, ctx)
	}
	cancel()
	time.Sleep(time.Second * 1)
	/** 运行结果：
	=== RUN   TestCancel
	4 Cancelled
	2 Cancelled
	3 Cancelled
	0 Cancelled
	1 Cancelled
	--- PASS: TestCancel (1.00s)
	*/
}

package series

// 首字母必须大写 才可被包外代码访问
func GetFibonacci(n int) ([]int, error) {
	fibList := []int{1, 2}

	for i := 2; i < n; i++ {
		fibList = append(fibList, fibList[i-2]+fibList[i-1])
	}
	return fibList, nil
}

package client

import (
	"fifteen/series"
	"testing"
)

func TestPackage(t *testing.T) {
	t.Log(series.GetFibonacci(5))
	/** 运行结果：
	=== RUN   TestPackage
	    TestPackage: package_test.go:9: [1 2 3 5 8] <nil>
	--- PASS: TestPackage (0.00s)
	*/
}

package series

import "fmt"

func init() {
	fmt.Println("init 1")
}

func init() {
	fmt.Println("init 2")
}

func GetFibonacci(n int) ([]int, error) {
	fibList := []int{1, 2}

	for i := 2; i < n; i++ {
		fibList = append(fibList, fibList[i-2]+fibList[i-1])
	}
	return fibList, nil
}

package client

import (
	"fifteen/series"
	"testing"
)

func TestPackage(t *testing.T) {
	t.Log(series.GetFibonacci(5))
	/** 运行结果：
	init 1
	init 2
	=== RUN   TestPackage
	    TestPackage: package_test.go:10: [1 2 3 5 8] <nil>
	--- PASS: TestPackage (0.00s)
	*/
}

package remote_package

import (
	cm "github.com/easierway/concurrent_map"
	"testing"
)

func TestConcurrentMap(t *testing.T) {
	m := cm.CreateConcurrentMap(99)
	m.Set(cm.StrKey("key"), 10)
	t.Log(m.Get(cm.StrKey("key")))
	/** 运行结果：
	=== RUN   TestConcurrentMap
	    TestConcurrentMap: remote_package_test.go:11: 10 true
	--- PASS: TestConcurrentMap (0.00s)
	*/

}

func GetFibonacci(n int) []int {
	fibList := []int{1, 2}

	for i := 2; i < n; i++ {
		fibList = append(fibList, fibList[i-2]+fibList[i-1])
	}
	return fibList
}

func TestGetFibonacci(t *testing.T) {
	t.Log(GetFibonacci(10))
	t.Log(GetFibonacci(-10))
	/** 运行结果
	=== RUN   TestGetFibonacci
	    TestGetFibonacci: err_test.go:15: [1 2 3 5 8 13 21 34 55 89]
	    TestGetFibonacci: err_test.go:21: [1 2]
	--- PASS: TestGetFibonacci (0.00s)
	*/
}

func GetFibonacci(n int) ([]int, error) {
	if n < 2 || n > 100 {
		return nil, errors.New("n should be in [2,100]")
	}
	fibList := []int{1, 2}

	for i := 2; i < n; i++ {
		fibList = append(fibList, fibList[i-2]+fibList[i-1])
	}
	return fibList, nil
}

func TestGetFibonacci(t *testing.T) {
	// 如果有错误进行错误输出
	if v, err := GetFibonacci(-10); err != nil {
		t.Error(err)
	} else {
		t.Log(v)
	}
	/** 运行结果
	=== RUN   TestGetFibonacci
	    TestGetFibonacci: err_test.go:22: n should be in [2,100]
	--- FAIL: TestGetFibonacci (0.00s)
	*/
}

func GetFibonacci(n int) ([]int, error) {
	if n < 2 {
		return nil, errors.New("n should be not less than 2")
	}

	if n > 100 {
		return nil, errors.New("n should be not larger than 100")
	}

	fibList := []int{1, 2}

	for i := 2; i < n; i++ {
		fibList = append(fibList, fibList[i-2]+fibList[i-1])
	}
	return fibList, nil
}

var LessThanTwoError = errors.New("n should be not less than 2")
var LargerThenHundredError = errors.New("n should be not larger than 100")

func GetFibonacci(n int) ([]int, error) {
	if n < 2 {
		return nil, LessThanTwoError
	}

	if n > 100 {
		return nil, LargerThenHundredError
	}

	fibList := []int{1, 2}

	for i := 2; i < n; i++ {
		fibList = append(fibList, fibList[i-2]+fibList[i-1])
	}
	return fibList, nil
}

func TestGetFibonacci(t *testing.T) {
	// 如果有错误进行错误输出
	if v, err := GetFibonacci(-10); err != nil {
		// 假如调用者需要判断错误的就比较简单了
		if err == LessThanTwoError {
			fmt.Println("It is less.")
		}
		t.Error(err)
	} else {
		t.Log(v)
	}
	/** 运行结果
	=== RUN   TestGetFibonacci
	It is less.
	    TestGetFibonacci: err_test.go:36: n should be not less than 2
	--- FAIL: TestGetFibonacci (0.00s)
	*/
}

func TestExit(t *testing.T) {
	fmt.Println("Start")
	os.Exit(-1)
	/** 运行结果
	=== RUN   TestExit
	Start

	Process finished with exit code 1
	*/
}

func TestPanic(t *testing.T) {
	defer func() {
		fmt.Println("Finally!")
	}()
	fmt.Println("Start")
	panic(errors.New("Something wrong!"))
	/** 运行结果：
	=== RUN   TestPanic
	Start
	Finally!
	--- FAIL: TestPanic (0.00s)
	panic: Something wrong! [recovered]
		panic: Something wrong!

	goroutine 6 [running]:
	testing.tRunner.func1.1(0x1119860, 0xc000046510)
		/usr/local/Cellar/go/1.14.2_1/libexec/src/testing/testing.go:940 +0x2f5
	testing.tRunner.func1(0xc00011a120)
		/usr/local/Cellar/go/1.14.2_1/libexec/src/testing/testing.go:943 +0x3f9
	panic(0x1119860, 0xc000046510)
		/usr/local/Cellar/go/1.14.2_1/libexec/src/runtime/panic.go:969 +0x166
	command-line-arguments.TestPanic(0xc00011a120)
		/Users/gaobinzhan/Documents/Go/learning/src/test/err_test.go:65 +0xd7
	testing.tRunner(0xc00011a120, 0x114afa0)
		/usr/local/Cellar/go/1.14.2_1/libexec/src/testing/testing.go:991 +0xdc
	created by testing.(*T).Run
		/usr/local/Cellar/go/1.14.2_1/libexec/src/testing/testing.go:1042 +0x357

	Process finished with exit code 1
	*/
}

defer func(){
  if err := recover(); err != nil {
    // 恢复错误
  }
}()

func TestRecover(t *testing.T) {
	defer func() {
		if err := recover(); err != nil {
			// 没有写错误恢复 只是打印出来了
			fmt.Println("recovered from", err)
		}
	}()
	fmt.Println("Start")
	panic(errors.New("Something wrong!"))
	/** 运行结果：
	=== RUN   TestRecover
	Start
	recovered from Something wrong!
	--- PASS: TestRecover (0.00s)
	*/
}

defer func() {
  if err := recover(); err != nil {
    log.Error("recovered panic",err)
  }
}()

type Employee struct {
	Id   string
	Name string
	Age  int
}

func TestCreateEmployee(t *testing.T) {
	e := Employee{"0", "Bob", 20}         // 分别把值放进去
	e1 := Employee{Name: "Mike", Age: 30} // 指定某个field的值
	e2 := new(Employee)                   // new关键字 去创建指向实例的指针 这里返回的引用/指针 相当于 e:=Employee{}
	e2.Id = "2"                           // 通过 example.filed 去赋值
	e2.Name = "Rose"
	e2.Age = 22
	t.Log(e)
	t.Log(e1)
	t.Log(e1.Id)
	t.Log(e2)
	t.Logf("e is %T", e)
	t.Logf("e2 is %T", e2)
	/** 运行结果：
	=== RUN   TestCreateEmployee
	    TestCreateEmployee: encap_test.go:18: {0 Bob 20}
	    TestCreateEmployee: encap_test.go:19: { Mike 30}
	    TestCreateEmployee: encap_test.go:20:
	    TestCreateEmployee: encap_test.go:21: &{2 Rose 22}
	    TestCreateEmployee: encap_test.go:22: e is test.Employee
	    TestCreateEmployee: encap_test.go:23: e2 is *test.Employee
	--- PASS: TestCreateEmployee (0.00s)
	 */
}

// 第一种定义方式在实例对应方法被调用时，实例的成员会进行值复制
func (e Employee) String() string {
	return fmt.Sprintf("ID:%s-Name:%s-Age:%d", e.Id, e.Name, e.Age)
}

func TestStructOperations(t *testing.T) {
	e := Employee{"0", "Bob", 20}
	t.Log(e.String())
	/** 运行结果：
	=== RUN   TestStructOperations
	    TestStructOperations: encap_test.go:46: ID:0-Name:Bob-Age:20
	--- PASS: TestStructOperations (0.00s)
	 */
}

// 通常情况下为了避免内存拷贝我们使用第二种定义方式
func (e *Employee) String() string {
	return fmt.Sprintf("ID:%s/Name:%s/Age:%d", e.Id, e.Name, e.Age)
}

func TestStructOperations(t *testing.T) {
	e := Employee{"0", "Bob", 20}
	t.Log(e.String())
	/** 运行结果：
	=== RUN   TestStructOperations
	    TestStructOperations: encap_test.go:51: ID:0/Name:Bob/Age:20
	--- PASS: TestStructOperations (0.00s)
	*/
}

func (e *Employee) String() string {
	fmt.Printf("Address is %x \n", unsafe.Pointer(&e.Name))
	return fmt.Sprintf("ID:%s/Name:%s/Age:%d", e.Id, e.Name, e.Age)
}

func TestStructOperations(t *testing.T) {
	e := Employee{"0", "Bob", 20}
	fmt.Printf("Address is %x \n", unsafe.Pointer(&e.Name))
	t.Log(e.String())
	/** 运行结果：
	=== RUN   TestStructOperations
	Address is c000060370
	Address is c000060370
	    TestStructOperations: encap_test.go:54: ID:0/Name:Bob/Age:20
	--- PASS: TestStructOperations (0.00s)
	*/
}