Go 单元测试

func TestName(t *testing.T){
    // ...
}

func TestAdd(t *testing.T){ ... }
func TestSum(t *testing.T){ ... }
func TestLog(t *testing.T){ ... }

func (c *T) Cleanup(func())
func (c *T) Error(args ...interface{})
func (c *T) Errorf(format string, args ...interface{})
func (c *T) Fail()
func (c *T) FailNow()
func (c *T) Failed() bool
func (c *T) Fatal(args ...interface{})
func (c *T) Fatalf(format string, args ...interface{})
func (c *T) Helper()
func (c *T) Log(args ...interface{})
func (c *T) Logf(format string, args ...interface{})
func (c *T) Name() string
func (c *T) Skip(args ...interface{})
func (c *T) SkipNow()
func (c *T) Skipf(format string, args ...interface{})
func (c *T) Skipped() bool
func (c *T) TempDir() string

// Fact 定义返回的结构体
type Fact struct {
	ret int
	nums []int
}

// Factorial 计算给定数字的阶乘
func Factorial(x int) *Fact {
	var factS = new(Fact)
	return operation(x,factS)
}

// 递归运算
func operation(x int, factS *Fact) *Fact {
	factS.nums = append(factS.nums, x)
	if x == 1 {
		factS.ret = x
		return factS
	}
	factS.ret = x * operation(x-1, factS).ret
	return factS
}

func TestFactorial(t *testing.T) {
	// 程序输出的结果
	got := Factorial(5)

	// 期望的结果
	want := &Fact{
		ret:  120,
		nums: []int{5,4,3,2,1},
	}

	// 因为struct不能比较直接，借助反射包中的方法比较
	if !reflect.DeepEqual(want, got) {
		// 测试失败输出错误提示
		t.Errorf("expected:%v, got:%v", want, got)
	}
}

// 这里给到一个错误的结果，测试错误情况
func TestFactEr(t *testing.T) {
	got := Factorial(3)
	want := &Fact{
		ret:  6,
		nums: []int{3,2,1},
	}
	if !reflect.DeepEqual(want, got) {
		t.Errorf("expected:%v, got:%v", want, got)
	}
}

func TestTimeConsuming(t *testing.T) {
    if testing.Short() {
        t.Skip("short模式下会跳过该测试用例")
    }
    ...
}

func TestXXX(t *testing.T){
  t.Run("case1", func(t *testing.T){...})
  t.Run("case2", func(t *testing.T){...})
  t.Run("case3", func(t *testing.T){...})
}

func TestFactGroup(t *testing.T)  {
	t.Parallel()  // 将 TLog 标记为能够与其他测试并行运行

	// 定义测试表格
	testCases := []struct{
		testName string
		input int
		output *Fact
	}{
		{"case1",5, &Fact{ret:  120, nums: []int{5,4,3,2,1}}},
		{"case2",3, &Fact{ret:  6, nums: []int{3,2,1}}},
	}

	// 运行子测试代码
	for _,tt := range testCases {
		tt := tt
		t.Run(tt.testName, func(t *testing.T) {
			t.Parallel()  // 将每个测试用例标记为能够彼此并行运行
			got := Factorial(tt.input)
			if !reflect.DeepEqual(tt.output, got) {
				t.Errorf("expected:%v, got:%v", tt.output, got)
			}
		})
	}
}

t.Parallel()

func Test_operation(t *testing.T) {
	type args struct {
		x     int
		factS *Fact
	}
	tests := []struct {
		name string
		args args
		want *Fact
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := operation(tt.args.x, tt.args.factS); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("operation() = %v, want %v", got, tt.want)
			}
		})
	}
}

func BenchmarkName(b *testing.B){
    // ...
}

func (c *B) Error(args ...interface{})
func (c *B) Errorf(format string, args ...interface{})
func (c *B) Fail()
func (c *B) FailNow()
func (c *B) Failed() bool
func (c *B) Fatal(args ...interface{})
func (c *B) Fatalf(format string, args ...interface{})
func (c *B) Log(args ...interface{})
func (c *B) Logf(format string, args ...interface{})
func (c *B) Name() string
func (b *B) ReportAllocs()
func (b *B) ResetTimer()
func (b *B) Run(name string, f func(b *B)) bool
func (b *B) RunParallel(body func(*PB))
func (b *B) SetBytes(n int64)
func (b *B) SetParallelism(p int)
func (c *B) Skip(args ...interface{})
func (c *B) SkipNow()
func (c *B) Skipf(format string, args ...interface{})
func (c *B) Skipped() bool
func (b *B) StartTimer()
func (b *B) StopTimer()

func BenchmarkFactorial(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Factorial(10)
	}
}

func benchmark(b *testing.B, size int){/* ... */}
func Benchmark10(b *testing.B){ benchmark(b, 10) }
func Benchmark100(b *testing.B){ benchmark(b, 100) }
func Benchmark1000(b *testing.B){ benchmark(b, 1000) }

func BenchmarkFactorial(b *testing.B) {
	time.Sleep(5 * time.Second) // 假设需要做一些耗时的无关操作
	b.ResetTimer()              // 重置计时器
	for i := 0; i < b.N; i++ {
		Factorial(10)
	}
}

func (b *B) RunParallel(body func(*PB))

shell> go test -bench=. 
goos: darwin
goarch: amd64
pkg: go_study/22.unit_test
cpu: Intel(R) Core(TM) i5-7360U CPU @ 2.30GHz
BenchmarkFactorialParallel-4     9344024               132.3 ns/op
PASS
ok      go_study/22.unit_test   1.658s

func TestMain(m *testing.M) {
	fmt.Println("write setup code here...") // 测试之前的做一些设置
	// 如果 TestMain 使用了 flags，这里应该加上flag.Parse()
	retCode := m.Run()                         // 执行测试
	fmt.Println("write teardown code here...") // 测试之后做一些拆卸工作
	os.Exit(retCode)                           // 退出测试
}

// 测试集的Setup与Teardown
func setupFactsTest(t *testing.T) func(t *testing.T) {
	t.Log("如有需要在此执行:Setup")
	return func(t *testing.T) {
		t.Log("如有需要在此执行:Setup")
	}
}

// 子测试的Setup与Teardown
func downFactsTest(t *testing.T) func(t *testing.T) {
	t.Log("如有需要在此执行:Teardown")
	return func(t *testing.T) {
		t.Log("如有需要在此执行:Teardown")
	}
}

func TestFactsGroup(t *testing.T)  {
	t.Parallel()

	// 定义测试表格
	testCases := []struct{
		testName string
		input int
		output *Fact
	}{
		{"case1",5, &Fact{ret:  120, nums: []int{5,4,3,2,1}}},
		{"case2",3, &Fact{ret:  6, nums: []int{3,2,1}}},
	}

	setupTest := setupFactsTest(t)
	defer setupTest(t)            // 测试之前执行setup操作

	// 运行子测试代码
	for _,tt := range testCases {
		tt := tt
		t.Run(tt.testName, func(t *testing.T) {
			t.Parallel()

			downTest := downFactsTest(t)
			defer downTest(t) // 测试之后执行testdown操作

			got := Factorial(tt.input)
			if !reflect.DeepEqual(tt.output, got) {
				t.Errorf("expected:%v, got:%v", tt.output, got)
			}
		})
	}
}

func ExampleName() {
    // ...
}