// 出錯(cuò)中斷協(xié)程，打印日志，退出

func TestSimpleExit(t *testing.T) {
	wg := sync.WaitGroup{}

	wg.Add(1)
	go func() {
		defer wg.Done()

		//do something
		if err := doSomething(); err != nil {
			t.Logf("Error when call doSomething:%v\n", err)
			return
		}
	}()

	wg.Wait()
}

	// 數(shù)據(jù)處理流程
	dataFunc := func(ctx context.Context, dataChan chan int, errChan chan error) {
		defer wg.Done()

		for {
			select {
			case v, ok := <-dataChan:
				if !ok {
					log.Println("Receive data channel close msg!")
					return
				}

				if err := doSomething2(v); err != nil {
					errChan <- err
					continue
				}

				// do ...

			case <-ctx.Done():
				log.Println("Receive exit msg!")
				return
			}
		}
	}

	wg.Add(1)
	go dataFunc(ctx, dataChan, errChan)

	wg.Add(1)
	go dataFunc(ctx, dataChan, errChan)

	// 錯(cuò)誤處理流程，error處理通道異步等待
	wg.Add(1)
	go func(errChan chan error) {
		defer wg.Done()

		for {
			select {
			case v, ok := <-errChan:
				if !ok {
					log.Println("Receice err channel close msg!")
					return
				}

				// 收到錯(cuò)誤時(shí)，可選擇記錄日志或退出
				if v != nil {
					t.Logf("Error when call doSomething:%v\n", v)
					cancel() // 通知全部退出
					return
				}

			case <-ctx.Done():
				log.Println("Receive exit msg!")
				return
			}
		}

	}(errChan)

	dataChan <- 1
	wg.Wait()

	// 錯(cuò)誤處理流程，error處理通道同步等待
	for {
		select {
		case v, ok := <-errChan:
			if !ok {
				log.Println("Receice err channel close msg!")
				goto EXIT
			}

			// 收到錯(cuò)誤時(shí)，可選擇記錄日志或退出
			if v != nil {
				t.Logf("Error when call doSomething:%v\n", v)
				cancel()
				goto EXIT
			}

		case <-ctx.Done():
			log.Println("Receive exit msg!")
			goto EXIT
		}
	}

EXIT:
	wg.Wait()

func TestSimpleChannel5(t *testing.T) {
	eg, ctx := errgroup.WithContext(context.Background())

	dataChan := make(chan int)
	defer close(dataChan)

	// 數(shù)據(jù)處理流程
	dataFunc := func() error {
		for {
			select {
			case v, ok := <-dataChan:
				if !ok {
					log.Println("Receive data channel close msg!")
					return nil
				}

				if err := doSomething2(v); err != nil {
					return err
				}

				// do ...

			// 增加ctx通知完成
			case <-ctx.Done():
				log.Println("Receive exit msg!")
				return nil
			}
		}
	}

	eg.Go(dataFunc)
	eg.Go(dataFunc)
	eg.Go(dataFunc)

	dataChan <- 1

	// 錯(cuò)誤處理流程，任何一個(gè)協(xié)程出現(xiàn)error，則會(huì)調(diào)用ctx對(duì)應(yīng)cancel函數(shù)，所有相關(guān)協(xié)程都會(huì)退出
	if err := eg.Wait(); err != nil {
		fmt.Printf("Something is wrong->%v\n", err)
	}
}

// 多路協(xié)程error合并，用于多路check場(chǎng)景
func TestSimpleChannel3(t *testing.T) {

	// 同步執(zhí)行多個(gè)任務(wù)，返回error合并
	var err = func() error {
		var result error

		if err := doSomething(); err != nil {
			result = multierror.Append(result, err)
		}

		if err := doSomething2(nil); err != nil {
			result = multierror.Append(result, err)
		}

		return result
	}()

	// 打印輸出
	if err != nil {
		fmt.Printf("%v\n", err)
	}

	// 獲取錯(cuò)誤列表
	if err != nil {
		if merr, ok := err.(*multierror.Error); ok {
			fmt.Printf("%v\n", merr.Errors)
		}
	}

	// 判斷是否為某種類型
	if err != nil && errors.Is(err, Error1) {
		fmt.Println("Errors contain error 1")
	}

	// 判斷是否其中一個(gè)error能夠轉(zhuǎn)換成指定error
	var e MyError
	if err != nil && errors.As(err, &e) {
		fmt.Println("One Error can be convert to nyerror")
	}
}

func TestSimpleChannel4(t *testing.T) {
	wg := sync.WaitGroup{}

	taskNum := 10
	errChan := make(chan error, taskNum)

	// 異步執(zhí)行多個(gè)任務(wù)
	step := func(stepNum int, errChan chan error) {
		defer wg.Done()
		errChan <- fmt.Errorf("step %d error", stepNum)
	}

	for i := 0; i < taskNum; i++ {
		wg.Add(1)
		go step(i, errChan)
	}

	// 等待任務(wù)完成
	go func() {
		wg.Wait()
		close(errChan)
	}()

	// err通道阻塞等待，可能的所有錯(cuò)誤合并
	var result *multierror.Error
	for err := range errChan {
		result = multierror.Append(result, err)
	}

	// 出現(xiàn)一個(gè)錯(cuò)誤時(shí)，選擇記錄日志或退出
	if len(result.Errors) != 0 {
		log.Println(result.Errors)
	}
}