Go 测试框架入门：testing 包基础、Test 函数编写、表驱动测试、子测试与子基准测试

Go 语言内置的 testing 包为开发者提供了从单元测试到性能基准测试的完整支持。本章将系统讲解测试框架的核心概念、标准写法以及进阶技巧，帮助你建立扎实的测试基础，为后续的性能压测与诊断铺平道路。

1. testing 包基础与 Test 函数编写

Go 中的测试文件以 _test.go 结尾，测试函数必须导入 testing 包，并遵循以下签名规则：

• 函数名：以 Test 开头，后跟大写字母开头的单词（如 TestAdd）。
• 参数：唯一参数为 *testing.T。
• 错误报告：使用 t.Error() 或 t.Errorf() 报告失败但不停止执行；使用 t.Fatal() 或 t.Fatalf() 立即终止当前测试。

// math.go
package math

func Add(a, b int) int {
    return a + b
}

// math_test.go
package math

import "testing"

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

运行测试：

go test ./...          # 运行当前包及子包所有测试
go test -v             # 显示详细输出
go test -run TestAdd   # 只运行匹配的测试函数

2. 表驱动测试：结构化测试用例

表驱动测试是 Go 社区广泛推崇的测试模式，它将测试输入与期望输出组织为结构体切片，通过循环逐一执行。这种方式极大提升了测试的可维护性和覆盖率。

func TestDivide(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        want     int
        wantErr  bool
    }{
        {"positive", 10, 2, 5, false},
        {"negative", -6, 3, -2, false},
        {"zero divisor", 5, 0, 0, true},
        {"large numbers", 1000000, 500, 2000, false},
    }

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

3. 子测试与子基准测试

Go 1.7 引入的 t.Run 和 b.Run 方法允许在测试内部创建嵌套的子测试和子基准测试。这一机制带来了三大优势：

• 精细控制：通过 -run 和 -bench 正则表达式筛选特定子测试。
• 并行执行：子测试内部可调用 t.Parallel() 实现并发测试。
• 共享设置/清理：父测试可统一执行初始化与资源释放。

func TestDatabase(t *testing.T) {
    db := setupDatabase(t)  // 共享初始化
    defer db.Close()

    t.Run("insert", func(t *testing.T) {
        if err := db.Insert("key1", "value1"); err != nil {
            t.Fatal(err)
        }
    })

    t.Run("query", func(t *testing.T) {
        val, err := db.Query("key1")
        if err != nil || val != "value1" {
            t.Errorf("got %s, want value1", val)
        }
    })

    t.Run("delete", func(t *testing.T) {
        if err := db.Delete("key1"); err != nil {
            t.Error(err)
        }
    })
}

子基准测试的写法与子测试类似，但使用 *testing.B 和 b.Run：

func BenchmarkSort(b *testing.B) {
    data := generateLargeSlice(10000)
    b.ResetTimer()

    b.Run("bubble", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            bubbleSort(copySlice(data))
        }
    })

    b.Run("quick", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            quickSort(copySlice(data))
        }
    })
}

4. 测试框架核心流程

下图展示了 Go 测试框架从启动到报告的整体执行流程，涵盖普通测试与基准测试的路径差异：

5. 常用测试命令与参数

6. 表驱动测试与子测试的协同模式

将表驱动测试与子测试结合，是 Go 测试中最强大的模式之一。下图展示了这种协同架构：

7. 常见陷阱与避坑指南

• 循环变量捕获：在 for range 中直接使用 tt 变量启动 goroutine 或延迟执行时，必须重新声明：tt := tt 或使用 t.Run（其回调会复制变量）。
• 测试顺序依赖：不要假设测试函数的执行顺序，Go 测试框架不保证顺序。若需共享状态，应在 TestMain 中统一初始化。
• 忽略错误返回值：测试中调用被测函数时，务必检查所有返回值，尤其是 error。使用 t.Fatal 而非 t.Error 处理致命错误，避免后续断言基于无效数据。
• 基准测试中修改全局状态：基准测试会多次重复执行，若被测函数修改全局变量或文件系统，会导致结果失真。应在 b.ResetTimer 前完成初始化。