1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

测试的层次：越往上越慢、越脆、越少

        ▲  数量少
        │
   ┌────┴─────┐
   │ 端到端 E2E │  起真实服务/浏览器 · 分钟级 · 只在关键路径 🔥
   ├──────────┤
   │ 集成测试   │  真 DB/真 HTTP · 秒级 · 用 -tags=integration 隔离
   ├──────────┤
   │ 单元测试   │  表驱动 + 子测试 · 毫秒级 · 【数量最多】✅
   └──────────┘
        │
        ▼  数量多

   配套手段（横切所有层）：
     -race 数据竞争 · fuzz 边界 · bench 性能 · cover 覆盖率

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

子测试树：t.Run 生成的层级结构

  TestDiv                        ← 顶层测试
   ├── TestDiv/normal            ← t.Run("normal")
   ├── TestDiv/negative
   └── TestDiv/by_zero
                                  可单独跑：
                                  go test -run 'TestDiv/by_zero'

  TestSumParallel                ← 并行父测试
   ├── TestSumParallel/case0  ─┐
   ├── TestSumParallel/case1  ─┼─ t.Parallel() → 都 PAUSE 后一起 CONT
   └── TestSumParallel/case2  ─┘

  ⚠️ t.Parallel() 建议放在 t.Run 闭包开头（可读性最好）；硬性限制见下文

1
2
3
4

# 最常用的三条
$ go test ./...                       # 快速全量
$ go test -race -count=1 ./...        # CI 上认真跑
$ go test -run TestUser -v ./user     # 单点排查

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// calc_test.go
package calc

import "testing"

func TestAdd(t *testing.T) {
	if got := Add(1, 2); got != 3 {
		t.Errorf("Add(1,2) = %d, want 3", got)
	}
}

1
2

$ go test ./...
ok  	ch17	0.404s

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

func TestDiv(t *testing.T) {
	tests := []struct {
		name    string
		a, b    int
		want    int
		wantErr error
	}{
		{"normal", 10, 2, 5, nil},
		{"negative", -9, 3, -3, nil},
		{"by zero", 1, 0, 0, ErrDivZero},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			got, err := Div(tc.a, tc.b)
			if !errors.Is(err, tc.wantErr) {
				t.Fatalf("Div(%d,%d) err = %v, want %v", tc.a, tc.b, err, tc.wantErr)
			}
			if got != tc.want {
				t.Errorf("Div(%d,%d) = %d, want %d", tc.a, tc.b, got, tc.want)
			}
		})
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

$ go test -v -run TestDiv ./...
=== RUN   TestDiv
=== RUN   TestDiv/normal
=== RUN   TestDiv/negative
=== RUN   TestDiv/by_zero
--- PASS: TestDiv (0.00s)
    --- PASS: TestDiv/normal (0.00s)
    --- PASS: TestDiv/negative (0.00s)
    --- PASS: TestDiv/by_zero (0.00s)
PASS

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func TestSumParallel(t *testing.T) {
	for i := range 3 {
		t.Run(fmt.Sprint("case", i), func(t *testing.T) {
			t.Parallel()          // 🔥 标记为可并行
			if got := Sum(1, 2, 3); got != 6 {
				t.Errorf("got %d", got)
			}
		})
	}
}

1
2
3
4
5
6
7

=== RUN   TestSumParallel
=== PAUSE TestSumParallel/case0
=== PAUSE TestSumParallel/case1
=== PAUSE TestSumParallel/case2
=== CONT  TestSumParallel/case0
=== CONT  TestSumParallel/case1
=== CONT  TestSumParallel/case2

1
2
3
4
5
6
7
8
9

func newTempFile(t *testing.T) *os.File {
	t.Helper()               // 🔥 失败行号指向调用方，而不是这里
	f, err := os.CreateTemp(t.TempDir(), "test-*")
	if err != nil {
		t.Fatalf("create temp: %v", err)
	}
	t.Cleanup(func() { f.Close() })   // ✅ 测试结束自动清理（LIFO）
	return f
}

1
2
3
4

func ExampleSum() {
	fmt.Println(Sum(1, 2, 3))
	// Output: 6
}

1

--- PASS: ExampleSum (0.00s)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func BenchmarkSum(b *testing.B) {
	for b.Loop() {          // 🆕 1.24 推荐写法 🔥
		Sum(1, 2, 3, 4, 5)
	}
}

func BenchmarkSumOld(b *testing.B) {
	for range b.N {          // 老写法，等价
		Sum(1, 2, 3, 4, 5)
	}
}

1
2
3
4
5
6
7
8
9

$ go test -bench=. -benchmem -run=^$ ./...
goos: darwin
goarch: arm64
pkg: ch17
cpu: Apple M4
BenchmarkSum-10       	601631548	         1.787 ns/op	       0 B/op	       0 allocs/op
BenchmarkSumOld-10    	808863117	         1.474 ns/op	       0 B/op	       0 allocs/op
PASS
ok  	ch17	2.612s

1
2
3
4

--- BENCH: BenchmarkLoopBodyCount-10
    bench_test.go:15: bodyRuns = 1, b.N = 1
--- BENCH: BenchmarkLoopBodyCount-10
    bench_test.go:15: bodyRuns = 2, b.N = 1

1

// 🆕 1.26 起 b.Loop 不再阻止循环体内联，所以老写法可以放心迁移到 b.Loop

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 参数化基准：对比不同输入规模
func BenchmarkParse(b *testing.B) {
	for _, size := range []int{10, 100, 1000} {
		b.Run(fmt.Sprintf("size=%d", size), func(b *testing.B) {
			data := makeInput(size)
			b.ResetTimer()
			for b.Loop() {
				Parse(data)
			}
		})
	}
}

// 并行基准：暴露锁竞争
func BenchmarkParallel(b *testing.B) {
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			work()
		}
	})
}

1
2
3
4

$ go test -bench=. -count=10 ./... > old.txt
$ # 改代码
$ go test -bench=. -count=10 ./... > new.txt
$ benchstat old.txt new.txt

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func FuzzSum(f *testing.F) {
	f.Add(1, 2)        // 种子语料（可选，也可放 testdata/fuzz/）
	f.Add(0, 0)

	f.Fuzz(func(t *testing.T, a, b int) {
		if Sum(a, b) != Sum(b, a) {
			t.Errorf("not commutative: %d %d", a, b)
		}
	})
}

1
2

$ go test -run FuzzSum ./...            # 只跑种子语料（默认，CI 用）
$ go test -fuzz FuzzSum -fuzztime 30s   # 真正开始变异探索

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// 生产代码：依赖接口，不是具体类型
type Store interface {
	Get(ctx context.Context, id string) (*User, error)
}

type Service struct{ store Store }

// 测试替身：手写即可，不需要 mock 框架
type fakeStore struct {
	data map[string]*User
	err  error
	got  []string          // spy：记录调用
}

func (f *fakeStore) Get(_ context.Context, id string) (*User, error) {
	f.got = append(f.got, id)
	if f.err != nil {
		return nil, f.err
	}
	u, ok := f.data[id]
	if !ok {
		return nil, ErrNotFound
	}
	return u, nil
}

func TestService_Get(t *testing.T) {
	fs := &fakeStore{data: map[string]*User{"1": {Name: "a"}}}
	svc := &Service{store: fs}

	u, err := svc.Get(context.Background(), "1")
	if err != nil {
		t.Fatalf("unexpected err: %v", err)
	}
	if u.Name != "a" {
		t.Errorf("Name = %q, want %q", u.Name, "a")
	}
	if len(fs.got) != 1 || fs.got[0] != "1" {
		t.Errorf("store calls = %v, want [1]", fs.got)
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

func TestHandler(t *testing.T) {
	// ① 直接测 handler 函数（最快）
	req := httptest.NewRequest(http.MethodGet, "/users/1", nil)
	rec := httptest.NewRecorder()
	handler(rec, req)

	if rec.Code != http.StatusOK {
		t.Errorf("status = %d, want %d", rec.Code, http.StatusOK)
	}
	var got User
	if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil {
		t.Fatalf("bad body: %v", err)
	}

	// ② 需要真实网络行为时起测试服务器
	srv := httptest.NewServer(http.HandlerFunc(handler))
	defer srv.Close()
	resp, err := srv.Client().Get(srv.URL + "/users/1")
	...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

func TestLoadConfig(t *testing.T) {
	fsys := fstest.MapFS{
		"config.json": &fstest.MapFile{Data: []byte(`{"port":8080}`)},
		"sub/x.txt":   &fstest.MapFile{Data: []byte("hi")},
	}
	cfg, err := LoadConfig(fsys)      // 生产传 os.DirFS，测试传 MapFS ✅
	if err != nil {
		t.Fatal(err)
	}
	if cfg.Port != 8080 {
		t.Errorf("Port = %d", cfg.Port)
	}

	// 校验 FS 实现是否符合 io/fs 契约
	if err := fstest.TestFS(fsys, "config.json"); err != nil {
		t.Fatal(err)
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func TestWithFakeClock(t *testing.T) {
	synctest.Test(t, func(t *testing.T) {
		start := time.Now()
		done := make(chan struct{})
		go func() {
			time.Sleep(time.Hour)      // 虚拟时钟：瞬间跳过 🔥
			close(done)
		}()
		synctest.Wait()                // 等当前 bubble 内所有 goroutine 阻塞
		<-done
		if elapsed := time.Since(start); elapsed != time.Hour {
			t.Fatalf("elapsed = %v, want 1h", elapsed)
		}
	})
}

1
2
3

$ go test -run TestWithFakeClock -v ./...
=== RUN   TestWithFakeClock
--- PASS: TestWithFakeClock (0.00s)     ← 真实耗时 0.00s，逻辑时间 1h ✅

1
2
3
4
5
6

$ go test -cover ./...
ok  	ch17	0.413s	coverage: 100.0% of statements

$ go test -coverprofile=cover.out ./...
$ go tool cover -html=cover.out        # 浏览器里看哪些行没覆盖
$ go tool cover -func=cover.out        # 按函数列出覆盖率