testing — Go 测试框架完全指南

// 白盒测试：可以访问未导出成员
package mypackage

// 黑盒测试：只能访问导出成员（推荐用于集成测试）
package mypackage_test

// Error — 记录错误，继续执行（适合多个断言）
t.Error("unexpected value")
t.Errorf("got %v, want %v", got, want)

// Fatal — 记录错误，立即终止（适合初始化失败等不可恢复的错误）
t.Fatal("cannot continue")
t.Fatalf("initialization failed: %v", err)

func assertEqual[T comparable](t *testing.T, got, want T) {
    t.Helper()  // ← 关键：错误报告的行号指向调用者，不是这里
    if got != want {
        t.Errorf("got %v, want %v", got, want)
    }
}

func TestSomething(t *testing.T) {
    result := Add(2, 3)
    assertEqual(t, result, 5)  // 错误会指向这一行
}

func TestAdd(t *testing.T) {
    tests := []struct {
        name    string
        a, b    int
        want    int
        wantErr bool
    }{
        {"positive numbers", 2, 3, 5, false},
        {"negative numbers", -1, -2, -3, false},
        {"zero", 0, 0, 0, false},
        {"overflow", math.MaxInt, 1, 0, true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := Add(tt.a, tt.b)
            if (err != nil) != tt.wantErr {
                t.Errorf("error = %v, wantErr %v", err, tt.wantErr)
                return
            }
            if got != tt.want {
                t.Errorf("got %d, want %d", got, tt.want)
            }
        })
    }
}

func TestParallel(t *testing.T) {
    t.Parallel()  // 声明可与其他 Parallel 测试并发运行

    t.Cleanup(func() {
        os.Remove("temp.db") // 测试结束后自动调用
    })

    tmpDir := t.TempDir() // 自动创建 + 自动删除的临时目录

    t.Setenv("APP_ENV", "test") // 自动恢复环境变量
}

func BenchmarkAdd(b *testing.B) {
    data := prepareData()  // 不计时
    
    b.ResetTimer()         // ← 重置计时器（忽略准备时间）
    
    for i := 0; i < b.N; i++ {
        Add(data[i%len(data)])
    }
    
    b.ReportAllocs()       // 报告内存分配
}

// 运行：
// go test -bench=. -benchmem
// go test -bench=Add -benchtime=5s -count=3

b.ResetTimer()    // 重置计时器
b.StopTimer()     // 暂停计时（用于 b.N 循环外的耗时操作）
b.StartTimer()    // 恢复计时
b.ReportAllocs()  // 报告内存分配统计

func ExampleAdd() {
    fmt.Println(Add(2, 3))
    // Output: 5
}

func ExampleAdd_negative() {
    fmt.Println(Add(-1, -2))
    // Output: -3
}

func FuzzParse(f *testing.F) {
    // 🔬 种子语料：这些是"已知合理的"输入，模糊测试从它们开始
    f.Add("hello")        // 种子 1：普通英文
    f.Add("123")          // 种子 2：纯数字
    f.Add("hello world!") // 种子 3：带空格
    f.Add("")             // 种子 4：空字符串（边界情况）
    f.Add("你好世界")     // 种子 5：Unicode

    f.Fuzz(func(t *testing.T, input string) {
        result, err := Parse(input)
        // 不依赖固定输出，检查属性不变式
        if err == nil && len(result) == 0 && len(input) > 0 {
            t.Errorf("empty result for non-empty input: %q", input)
        }
    })
}

# 模糊测试会在 testdata/fuzz/ 下生成语料文件
# 这些文件应该提交到 git（作为回归测试的种子）
testdata/fuzz/FuzzParse/
├── a1b2c3d4e5f6    # 模糊测试发现的输入
├── 7f8e9d0c1b2a    # 另一个变异输入
└── ...

func FuzzParse(f *testing.F) {
    // 阶段 1：注册种子语料
    f.Add("hello")
    f.Add("123")

    // 阶段 2：定义模糊测试函数
    f.Fuzz(func(t *testing.T, input string) {
        // 模糊测试函数不依赖固定输出
        // 而是检查"不变式"（invariant）
        result, err := Parse(input)
        if err == nil && len(result) == 0 && len(input) > 0 {
            t.Errorf("empty result for non-empty input: %q", input)
        }
    })
}

go test                           # 运行当前包所有测试
go test ./...                     # 递归运行所有测试
go test -v                        # 详细输出
go test -run TestAdd              # 只运行匹配的测试
go test -run TestAdd/positive     # 只运行子测试
go test -count=3                  # 运行 3 遍（检测 flaky test）
go test -race                     # 启用竞态检测
go test -coverprofile=c.out       # 生成覆盖率
go tool cover -html=c.out         # 覆盖率可视化
go test -bench=. -benchmem        # 运行基准测试

go test -coverprofile=coverage.out
go tool cover -func=coverage.out   # 按函数统计
go tool cover -html=coverage.out   # 在浏览器中看