单元测试与基准测试

0. 学习目标

本篇文档依据 Bloom 分类法,从认知、理解、应用、分析、评价、创造六个层次构建学习路径。完成本篇学习后,读者应能够:

0.1 Remember(记忆)

• 列举 testing 包的核心类型:T、B、TB、M、PB、F。
• 描述 go test 命令的常用标志:-run、-bench、-benchmem、-cover、-race、-v、-count、-parallel、-timeout、-fuzz。
• 复述表驱动测试(table-driven test)的结构与 t.Run 子测试机制。
• 背诵 Go 1.18 引入原生 fuzzing 测试的 API 形态(F.Add、F.Fuzz、f.Failing、seed corpus)。

0.2 Understand(理解)

• 解释 testing.T 的 Helper()、Cleanup()、Parallel()、Deadline()、Logf() 等方法在测试生命周期中的作用。
• 阐述 Benchmark 中 b.N 自适应循环的工作原理与 b.ResetTimer()、b.ReportAllocs()、b.RunParallel()、b.SetBytes() 的语义。
• 理解 go test -cover 输出的 coverage: 78.3% of statements 背后的插桩机制:编译器在每个基本块插入计数器。
• 说明 TestMain(*testing.M) 的执行时机:在所有 Test*、Benchmark*、Example*、FuzzXxx 之前调用一次。

0.3 Apply(应用)

• 为任意 Go 函数编写表驱动测试,使用 t.Run 为每个用例命名并启用 t.Parallel()。
• 使用 go test -bench=. -benchmem -count=10 | benchstat old.txt new.txt 完成统计意义上的性能对比。
• 编写 BenchmarkMemory 风格的内存分配基准,通过 b.ReportAllocs() 验证零分配路径。
• 利用 testing/quick 实现基于随机输入的属性测试(property-based testing)。

0.4 Analyze(分析)

• 分析一个测试套件中 goroutine 泄漏、data race、flaky test 的根因,给出 t.Parallel 与共享状态交互的诊断思路。
• 解读 go tool cover -html=coverage.out 生成的 HTML 报告,定位未覆盖分支与边界条件。
• 对比 testify/assert、testify/require、gomock、mockery、bufmock、counterfeiter 等工具在 mock 与断言场景的取舍。
• 解构一个生产级 Go 项目的 CI 流水线,识别测试金字塔(test pyramid)各层比例失衡的风险。

0.5 Evaluate(评价)

• 评价 100% 覆盖率的工程价值:覆盖率是必要条件而非充分条件,高覆盖率可能掩盖分支语义错误。
• 评价 mock 与 stub 在微服务测试中的副作用:过度 mock 会导致测试与实现强耦合,失去重构保护能力。
• 评价 fuzzing 与表驱动测试的互补关系:前者发现未知边界,后者固化已知行为。
• 评价 testify 与原生 testing 的工程权衡:可读性 vs 依赖膨胀。

0.6 Create(创造)

• 设计一个支持测试夹具(fixture)、测试钩子(setup/teardown)、测试并行度控制的内部测试框架。
• 构建基于 go test -json 输出的 CI 测试报告聚合系统,支持历史趋势、失败聚类、flaky 检测。
• 实现一个针对 HTTP/gRPC 服务的契约测试框架,集成 Pact 思想与 Go testing 生态。
• 创造一个基于 LLM 的测试用例生成工具,辅助开发者从函数签名推导表驱动用例。

1. 历史动机与发展脉络

1.1 Go 测试文化的设计动机

Go 在 2009 年由 Google 的 Robert Griesemer、Rob Pike、Ken Thompson 设计时,就将测试作为语言一等公民对待。这与同时代的 Java(JUnit 1997 年由 Kent Beck、Erich Gamma 创建,独立于语言)、Python(pytest 2000 年,unittest 2001 年)、C++(Google Test 2008 年)形成鲜明对比。Go 团队的核心理念是:

“Testing is not an afterthought. It is part of the language.”——Rob Pike, Go at Google: Language Design in the Service of Software Engineering, 2012

这一理念直接催生了 go test 命令与 testing 包。开发者无需选择测试框架、无需配置构建脚本、无需引入第三方依赖,即可运行测试。这一决策深刻影响了 Go 社区的工程文化。

1.2 关键版本演进时间线

1.3 Go 1.22 循环变量语义变更的测试影响

Go 1.22 之前,for i := range slice 中 i 在整个循环中是同一个变量,导致大量测试在使用 goroutine 时踩坑:

// Go 1.21 及之前版本 - 危险
for _, tc := range testCases {
    t.Run(tc.name, func(t *testing.T) {
        t.Parallel()  // 所有并行子测试共享 tc,最终都执行最后一个用例
        assert.Equal(t, tc.expected, fn(tc.input))
    })
}

Go 1.22 起,每次迭代创建新变量,上述代码变为安全。但生产环境多数项目仍需兼容 Go 1.21 及以下,因此推荐显式参数传递:

// 兼容所有 Go 版本 - 推荐
for _, tc := range testCases {
    tc := tc  // 显式 shadow,兼容 Go 1.0+
    t.Run(tc.name, func(t *testing.T) {
        t.Parallel()
        assert.Equal(t, tc.expected, fn(tc.input))
    })
}

1.4 与其他语言测试生态的对比

Go 测试生态的演进与 Rust、Java、Python 存在显著差异:

2. 形式化定义

2.1 testing 包的核心类型与接口

依据 Go 官方文档(go/src/testing/testing.go)与 Go Language Spec,testing 包提供以下核心类型:

// TB 接口:Test 与 Benchmark 共享的通用接口
type TB interface {
    Cleanup(func())
    Error(args ...any)
    Errorf(format string, args ...any)
    Fail()
    FailNow()
    Failed() bool
    Fatal(args ...any)
    Fatalf(format string, args ...any)
    Helper()
    Log(args ...any)
    Logf(format string, args ...any)
    Name() string
    Setenv(key, value string)
    Skip(args ...any)
    SkipNow()
    Skipf(format string, args ...any)
    Skipped() bool
    TempDir() string
    // Go 1.20+
    Cleanup(func())
    // Go 1.15+
    Parallel()
    // Go 1.16+
    Deadline() (time.Time, bool)
    private()  // 防止外部实现
}

// T 类型:单元测试上下文
type T struct {
    common
    signal chan bool  // 用于通知测试完成
    barrier chan bool // 并行测试同步
    // ...
}

// B 类型:基准测试上下文
type B struct {
    common
    N int           // 自适应循环次数
    benchmark BenchFunc
    // ...
}

// M 类型:整个测试程序入口
type M struct {
    deps testDeps
    beforeFns []func()
    afterFns []func()
    // ...
}

// F 类型:Fuzzing 测试上下文(Go 1.18+)
type F struct {
    common
    fuzzInputs [][]any
    fuzzCalled bool
    // ...
}

2.2 测试函数签名规范

Go 编译器通过函数命名约定识别测试函数,这一约定在 go/build 包中实现:

// 单元测试 - 函数名以 Test 开头,参数为 *testing.T
func TestXxx(t *testing.T) { /* ... */ }

// 基准测试 - 函数名以 Benchmark 开头,参数为 *testing.B
func BenchmarkXxx(b *testing.B) { /* ... */ }

// 示例测试 - 函数名以 Example 开头,无参数,通过 Output 注释验证输出
func ExampleXxx() {
    fmt.Println("hello")
    // Output: hello
}

// Fuzzing 测试 - 函数名以 Fuzz 开头,参数为 *testing.F(Go 1.18+)
func FuzzXxx(f *testing.F) {
    f.Add(seedInput)
    f.Fuzz(func(t *testing.T, input string) { /* ... */ })
}

// 测试主函数 - 整个测试程序只调用一次
func TestMain(m *testing.M) int {
    setup()
    code := m.Run()
    teardown()
    return code
}

2.3 b.N 自适应循环的形式化语义

基准测试的核心是 b.N 自适应算法。其形式化定义为:

设 $T_{target}$ 为目标测量时间(默认 1 秒),$T_i$ 为第 $i$ 轮单次执行时间估计,$N_i$ 为第 $i$ 轮循环次数。算法迭代:

当 $T_i \cdot N_i \geq T_{target}$ 或迭代次数达到上限时,输出最终 ns/op 测量值:

-benchtime=Nx 可强制固定循环次数,-benchtime=10s 可调整目标时间。

2.4 覆盖率插桩的形式化模型

Go 覆盖率工具基于基本块(basic block)插桩。设函数 $f$ 的控制流图(CFG)由基本块 $B_1, B_2, \ldots, B_n$ 组成。编译器在每个基本块入口插入计数器 $c_i$:

覆盖率定义为已执行基本块占总基本块的比例:

注意:Go 覆盖率是语句覆盖率(statement coverage),而非分支覆盖率(branch coverage)或路径覆盖率(path coverage)。语句覆盖是最弱的覆盖率指标,只保证每条语句被执行过,不保证所有分支组合被测试。

3. 理论推导与原理解析

3.1 测试金字塔的统计基础

测试金字塔(Test Pyramid)由 Mike Cohn 在 Succeeding with Agile(2009)中提出。其形态可由故障检测成本与故障发现概率的权衡推导:

设单元测试的执行成本为 $C_u$、故障检测率为 $P_u$;集成测试为 $C_i$、$P_i$;端到端测试为 $C_e$、$P_e$。一般满足:

期望总成本 $C_{\text{total}} = N_u C_u + N_i C_i + N_e C_e$,目标是在 $P_{\text{total}}$ 达标的前提下最小化 $C_{\text{total}}$。最优解满足:

实践中,Go 项目的典型比例为 $N_u : N_i : N_e \approx 70 : 20 : 10$。

3.2 并行测试的正确性条件

设测试集合 $T = \{t_1, t_2, \ldots, t_n\}$,其中 $t_i$ 的共享状态集合为 $S_i$。t.Parallel() 的安全性条件为:

违反该条件的典型表现:

1. 共享全局变量:多个并行测试同时修改包级变量,引发 data race。
2. 共享文件系统:并行测试读写同一临时文件,需使用 t.TempDir() 隔离。
3. 共享网络端口:并行测试绑定同一端口,需动态分配端口。
4. 共享数据库:并行测试操作同一表,需事务隔离或独立 schema。

3.3 Fuzzing 的覆盖率引导理论

Go 1.18 的原生 fuzzing 基于 libFuzzer 的覆盖率引导思想。其核心算法为:

1. 维护语料库(corpus)$C = \{c_1, c_2, \ldots, c_k\}$。
2. 从 $C$ 中随机选取 $c_i$,施加变异算子 $M$(如字节翻转、整数增减、字典替换)。
3. 执行 $f(M(c_i))$,收集覆盖率增量 $\Delta \text{cov}$。
4. 若 $\Delta \text{cov} > 0$,将 $M(c_i)$ 加入 $C$。
5. 若 $f$ panic 或失败,记录为崩溃输入(crash)。

变异算子 $M$ 的设计影响探索效率。Go 内置的变异算子包括:

• 字节翻转:随机选择字节,翻转部分比特。
• 算术变异:对整数类型增减小常数。
• 字典替换:插入已知的关键字(如 "SELECT"、"true"、"0x" 等)。
• 块重组:交换输入的局部块。

形式化地,期望发现新分支的概率:

随着语料库增长,发现新分支的概率衰减,需要结合字典与结构感知变异提升效率。

3.4 基准测量的统计噪声模型

基准测试结果受系统噪声影响,包括:

• 操作系统调度抖动:上下文切换引入 $\sigma_{\text{sched}} \approx 10\text{-}100\mu s$。
• 缓存效应:L1/L2/L3 缓存命中率影响 $\sigma_{\text{cache}}$。
• GC 暂停:Go GC 的 STW 阶段引入 $\sigma_{\text{gc}} \approx 100\mu s\text{-}1ms$。
• 热迁移:云环境中虚拟机迁移引入秒级抖动。

总噪声的标准差:

单次测量的 95% 置信区间为 $\bar{x} \pm 1.96 \sigma_{\text{total}} / \sqrt{n}$。要使两次测量差异 $\Delta$ 在 95% 置信度下显著,需:

实践中,推荐 -count=10 并使用 benchstat 进行配对 t 检验。

4. 代码示例

4.1 项目结构

user_service/
├── go.mod
├── go.sum
├── user.go
├── user_test.go
├── bench_test.go
├── fuzz_test.go
├── example_test.go
└── testdata/
    └── golden.json

go.mod:

module github.com/fandex/user_service

go 1.22

require (
    github.com/stretchr/testify v1.9.0
    go.uber.org/mock v0.4.0
    golang.org/x/tools v0.20.0
)

4.2 被测代码

// user.go
package user

import (
    "errors"
    "regexp"
    "strings"
    "time"
    "unicode/utf8"
)

var (
    ErrInvalidName  = errors.New("invalid name")
    ErrInvalidAge   = errors.New("invalid age")
    ErrInvalidEmail = errors.New("invalid email")
)

var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)

// User 表示业务用户实体
type User struct {
    ID        string
    Name      string
    Age       int
    Email     string
    CreatedAt time.Time
}

// NewUser 构造函数,执行参数校验
func NewUser(name, email string, age int) (*User, error) {
    name = strings.TrimSpace(name)
    if utf8.RuneCountInString(name) < 2 || utf8.RuneCountInString(name) > 64 {
        return nil, ErrInvalidName
    }
    if age < 0 || age > 150 {
        return nil, ErrInvalidAge
    }
    if !emailRegex.MatchString(email) {
        return nil, ErrInvalidEmail
    }
    return &User{
        Name:      name,
        Age:       age,
        Email:     email,
        CreatedAt: time.Now().UTC(),
    }, nil
}

// FullName 返回完整显示名
func (u *User) FullName() string {
    return u.Name
}

// IsAdult 判断是否成年
func (u *User) IsAdult() bool {
    return u.Age >= 18
}

// AgeGroup 返回年龄段
func (u *User) AgeGroup() string {
    switch {
    case u.Age < 12:
        return "child"
    case u.Age < 18:
        return "teen"
    case u.Age < 60:
        return "adult"
    default:
        return "senior"
    }
}

// ParseUsers 批量解析
func ParseUsers(raw []string) ([]*User, error) {
    users := make([]*User, 0, len(raw))
    for i, line := range raw {
        parts := strings.Split(line, ",")
        if len(parts) != 3 {
            return nil, errors.New("invalid format at line " + string(rune('0'+i)))
        }
        var age int
        _, err := fmt.Sscanf(parts[2], "%d", &age)
        if err != nil {
            return nil, err
        }
        u, err := NewUser(parts[0], parts[1], age)
        if err != nil {
            return nil, err
        }
        users = append(users, u)
    }
    return users, nil
}

// Need import fmt
import "fmt"

上述代码末尾的 import "fmt" 仅为说明用途,实际项目中应合并到顶部 import 块。

4.3 表驱动单元测试

// user_test.go
package user

import (
    "errors"
    "strings"
    "testing"
    "time"

    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

// TestNewUser_Validate 测试 NewUser 的参数校验逻辑
func TestNewUser_Validate(t *testing.T) {
    // 表驱动测试用例
    tests := []struct {
        name    string
        input   string  // 输入名
        email   string
        age     int
        wantErr error
    }{
        {
            name:    "valid adult user",
            input:   "Alice",
            email:   "alice@example.com",
            age:     30,
            wantErr: nil,
        },
        {
            name:    "valid teen user",
            input:   "Bob",
            email:   "bob@example.com",
            age:     15,
            wantErr: nil,
        },
        {
            name:    "name too short",
            input:   "A",
            email:   "a@example.com",
            age:     20,
            wantErr: ErrInvalidName,
        },
        {
            name:    "name too long",
            input:   strings.Repeat("X", 65),
            email:   "long@example.com",
            age:     20,
            wantErr: ErrInvalidName,
        },
        {
            name:    "age negative",
            input:   "Charlie",
            email:   "c@example.com",
            age:     -1,
            wantErr: ErrInvalidAge,
        },
        {
            name:    "age too large",
            input:   "Dave",
            email:   "d@example.com",
            age:     200,
            wantErr: ErrInvalidAge,
        },
        {
            name:    "email missing @",
            input:   "Eve",
            email:   "invalid-email",
            age:     25,
            wantErr: ErrInvalidEmail,
        },
        {
            name:    "email invalid TLD",
            input:   "Frank",
            email:   "frank@example.c",
            age:     25,
            wantErr: ErrInvalidEmail,
        },
        {
            name:    "name with leading/trailing spaces",
            input:   "  Grace  ",
            email:   "grace@example.com",
            age:     28,
            wantErr: nil,
        },
        {
            name:    "unicode name (Chinese)",
            input:   "小明",
            email:   "xm@example.com",
            age:     20,
            wantErr: nil,
        },
    }

    for _, tc := range tests {
        tc := tc  // 兼容 Go 1.21 及以下
        t.Run(tc.name, func(t *testing.T) {
            t.Parallel()
            u, err := NewUser(tc.input, tc.email, tc.age)

            if tc.wantErr != nil {
                require.Error(t, err)
                assert.True(t, errors.Is(err, tc.wantErr),
                    "expected %v, got %v", tc.wantErr, err)
                assert.Nil(t, u)
                return
            }

            require.NoError(t, err)
            require.NotNil(t, u)
            assert.Equal(t, strings.TrimSpace(tc.input), u.Name)
            assert.Equal(t, tc.age, u.Age)
            assert.Equal(t, tc.email, u.Email)
            assert.False(t, u.CreatedAt.IsZero())
            assert.True(t, u.CreatedAt.Before(time.Now().Add(time.Second)))
        })
    }
}

// TestUser_AgeGroup 测试 AgeGroup 分类逻辑
func TestUser_AgeGroup(t *testing.T) {
    tests := []struct {
        age      int
        expected string
    }{
        {0, "child"},
        {5, "child"},
        {11, "child"},
        {12, "teen"},
        {17, "teen"},
        {18, "adult"},
        {59, "adult"},
        {60, "senior"},
        {100, "senior"},
    }

    for _, tc := range tests {
        tc := tc
        t.Run(tc.expected, func(t *testing.T) {
            t.Parallel()
            u, err := NewUser("Test", "test@example.com", tc.age)
            require.NoError(t, err)
            assert.Equal(t, tc.expected, u.AgeGroup())
        })
    }
}

// TestUser_IsAdult 测试 IsAdult 边界
func TestUser_IsAdult(t *testing.T) {
    t.Run("age 17 is not adult", func(t *testing.T) {
        t.Parallel()
        u, _ := NewUser("Test", "test@example.com", 17)
        assert.False(t, u.IsAdult())
    })
    t.Run("age 18 is adult", func(t *testing.T) {
        t.Parallel()
        u, _ := NewUser("Test", "test@example.com", 18)
        assert.True(t, u.IsAdult())
    })
}

// TestParseUsers_Batch 测试批量解析
func TestParseUsers_Batch(t *testing.T) {
    t.Run("valid batch", func(t *testing.T) {
        t.Parallel()
        raw := []string{
            "Alice,alice@example.com,30",
            "Bob,bob@example.com,25",
            "Charlie,charlie@example.com,40",
        }
        users, err := ParseUsers(raw)
        require.NoError(t, err)
        assert.Len(t, users, 3)
        assert.Equal(t, "Alice", users[0].Name)
    })

    t.Run("invalid line format", func(t *testing.T) {
        t.Parallel()
        raw := []string{"Alice,alice@example.com"}  // 缺少 age
        _, err := ParseUsers(raw)
        assert.Error(t, err)
    })

    t.Run("invalid age value", func(t *testing.T) {
        t.Parallel()
        raw := []string{"Alice,alice@example.com,abc"}
        _, err := ParseUsers(raw)
        assert.Error(t, err)
    })

    t.Run("empty input", func(t *testing.T) {
        t.Parallel()
        users, err := ParseUsers(nil)
        require.NoError(t, err)
        assert.Empty(t, users)
    })
}

// TestParseUsers_GoldenFile 使用 golden file 测试
func TestParseUsers_GoldenFile(t *testing.T) {
    // testdata/golden.json 中预存输入与期望输出
    // 加载并对比,详见后续 4.7 节
    t.Skip("golden file 测试见 4.7 节")
}

4.4 子测试与并行控制

// parallel_test.go
package user

import (
    "sync"
    "sync/atomic"
    "testing"
)

// TestParallel_SharedState 危险示例:并行测试共享状态导致 data race
// 使用 -race 标志运行可检测:go test -race -run TestParallel_SharedState
func TestParallel_SharedState(t *testing.T) {
    // 危险:counter 是包级变量,多并行测试共享
    var counter int32

    for i := 0; i < 10; i++ {
        t.Run("concurrent", func(t *testing.T) {
            t.Parallel()
            // data race: 多个 goroutine 同时读写 counter
            counter++  // 触发 -race
            _ = counter
        })
    }

    // 修复方案 1:使用 atomic
    var safeCounter atomic.Int32
    for i := 0; i < 10; i++ {
        t.Run("atomic", func(t *testing.T) {
            t.Parallel()
            safeCounter.Add(1)
        })
    }
}

// TestParallel_Isolation 推荐实践:每个测试用独立状态
func TestParallel_Isolation(t *testing.T) {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        i := i
        t.Run("isolated", func(t *testing.T) {
            t.Parallel()
            localCounter := 0  // 每个子测试独有
            localCounter += i
            wg.Add(1)
            go func() {
                defer wg.Done()
                _ = localCounter
            }()
        })
    }
    wg.Wait()
}

// TestMain 演示测试主函数
func TestMain(m *testing.M) int {
    // 全局 setup
    // 例如:初始化数据库连接池、加载配置、启动 testcontainers
    code := m.Run()
    // 全局 teardown
    return code
}

4.5 基准测试

// bench_test.go
package user

import (
    "fmt"
    "math/rand"
    "strings"
    "testing"
)

// BenchmarkNewUser 测量 NewUser 构造函数性能
func BenchmarkNewUser(b *testing.B) {
    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, _ = NewUser("AliceBenchmark", "alice.bench@example.com", 30)
    }
}

// BenchmarkNewUser_Parallel 并发基准测试
func BenchmarkNewUser_Parallel(b *testing.B) {
    b.ReportAllocs()
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            _, _ = NewUser("AliceParallel", "alice.par@example.com", 30)
        }
    })
}

// BenchmarkParseUsers_Scalable 测量批量解析的扩展性
func BenchmarkParseUsers_Scalable(b *testing.B) {
    sizes := []int{10, 100, 1000, 10000}
    for _, size := range sizes {
        b.Run(fmt.Sprintf("size_%d", size), func(b *testing.B) {
            raw := make([]string, size)
            for i := range raw {
                raw[i] = fmt.Sprintf("User%d,user%d@example.com,%d", i, i, 20+i%50)
            }
            b.ReportAllocs()
            b.ResetTimer()
            for i := 0; i < b.N; i++ {
                _, _ = ParseUsers(raw)
            }
        })
    }
}

// BenchmarkAgeGroup 测量 AgeGroup 分支性能
func BenchmarkAgeGroup(b *testing.B) {
    u, _ := NewUser("Bench", "bench@example.com", 35)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = u.AgeGroup()
    }
}

// BenchmarkEmailRegex 测量正则匹配性能
func BenchmarkEmailRegex(b *testing.B) {
    emails := []string{
        "valid@example.com",
        "invalid-email",
        "very.long.email.address@subdomain.example.org",
        "short@x.io",
    }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = emailRegex.MatchString(emails[i%len(emails)])
    }
}

// BenchmarkStringOperations 字符串操作对比
func BenchmarkStringOperations(b *testing.B) {
    b.Run("strings.TrimSpace", func(b *testing.B) {
        s := "   hello world   "
        for i := 0; i < b.N; i++ {
            _ = strings.TrimSpace(s)
        }
    })
    b.Run("manual trim", func(b *testing.B) {
        s := "   hello world   "
        for i := 0; i < b.N; i++ {
            start, end := 0, len(s)
            for start < end && (s[start] == ' ') {
                start++
            }
            for end > start && (s[end-1] == ' ') {
                end--
            }
            _ = s[start:end]
        }
    })
}

// BenchmarkMemoryAllocs 测量内存分配
func BenchmarkMemoryAllocs(b *testing.B) {
    b.Run("slice with make", func(b *testing.B) {
        b.ReportAllocs()
        for i := 0; i < b.N; i++ {
            _ = make([]int, 0, 100)
        }
    })
    b.Run("slice literal", func(b *testing.B) {
        b.ReportAllocs()
        for i := 0; i < b.N; i++ {
            _ = []int{}
        }
    })
    b.Run("string concatenation", func(b *testing.B) {
        parts := []string{"a", "b", "c", "d"}
        b.ReportAllocs()
        for i := 0; i < b.N; i++ {
            _ = strings.Join(parts, ",")
        }
    })
}

// BenchmarkRandomGeneration 随机数生成性能对比
func BenchmarkRandomGeneration(b *testing.B) {
    b.Run("math/rand", func(b *testing.B) {
        b.ResetTimer()
        for i := 0; i < b.N; i++ {
            _ = rand.Intn(100)
        }
    })
    // Go 1.22+ math/rand/v2
    b.Run("math/rand/v2", func(b *testing.B) {
        b.ResetTimer()
        for i := 0; i < b.N; i++ {
            _ = randv2.IntN(100)
        }
    })
}

// 通过 alias 引入,实际应 import "math/rand/v2" as randv2
var randv2 = struct{ IntN func(int) int }{IntN: func(n int) int { return rand.Intn(n) }}

4.6 内存基准与 b.ReportAllocs

// memory_bench_test.go
package user

import "testing"

// BenchmarkMemory_StringAllocation 测量不同字符串构造的内存分配
func BenchmarkMemory_StringAllocation(b *testing.B) {
    b.Run("string literal", func(b *testing.B) {
        b.ReportAllocs()
        for i := 0; i < b.N; i++ {
            _ = "hello world"
        }
    })

    b.Run("fmt.Sprintf", func(b *testing.B) {
        b.ReportAllocs()
        for i := 0; i < b.N; i++ {
            _ = fmt.Sprintf("%s %s", "hello", "world")
        }
    })

    b.Run("strings.Builder", func(b *testing.B) {
        b.ReportAllocs()
        for i := 0; i < b.N; i++ {
            var sb strings.Builder
            sb.WriteString("hello")
            sb.WriteString(" ")
            sb.WriteString("world")
            _ = sb.String()
        }
    })

    b.Run("string concat", func(b *testing.B) {
        b.ReportAllocs()
        for i := 0; i < b.N; i++ {
            s := "hello" + " " + "world"
            _ = s
        }
    })
}

// BenchmarkZeroAlloc 验证零分配路径
func BenchmarkZeroAlloc(b *testing.B) {
    b.ReportAllocs()
    var sink int
    for i := 0; i < b.N; i++ {
        // 简单计算,预期零分配
        sink += i * 2
    }
    _ = sink
}

// BenchmarkSetBytes 测量吞吐量
func BenchmarkSetBytes(b *testing.B) {
    data := make([]byte, 1024*1024)  // 1MB
    b.SetBytes(int64(len(data)))
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        // 模拟处理 1MB 数据
        for j := range data {
            data[j] = byte(j)
        }
    }
}

// BenchmarkReportMetric 自定义指标报告
func BenchmarkReportMetric(b *testing.B) {
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        // 模拟一个有自定义指标的操作
        ops := 1000
        b.ReportMetric(float64(ops), "ops")
    }
}

4.7 Golden File 测试

// golden_test.go
package user

import (
    "encoding/json"
    "os"
    "path/filepath"
    "testing"
)

// GoldenFile 模式:输入与期望输出存放在 testdata/ 目录
// 优势:复杂期望值与测试代码解耦,易于维护

type goldenParseCase struct {
    Input    string   `json:"input"`
    Expected []string `json:"expected_names"`
}

func loadGolden(t *testing.T, name string) []goldenParseCase {
    t.Helper()
    path := filepath.Join("testdata", name)
    data, err := os.ReadFile(path)
    if err != nil {
        t.Fatalf("failed to read golden file %s: %v", path, err)
    }
    var cases []goldenParseCase
    if err := json.Unmarshal(data, &cases); err != nil {
        t.Fatalf("failed to parse golden file: %v", err)
    }
    return cases
}

// TestParseUsers_GoldenFile 使用 golden file 测试
func TestParseUsers_GoldenFile(t *testing.T) {
    if testing.Short() {
        t.Skip("skipping golden file test in short mode")
    }
    cases := loadGolden(t, "golden.json")
    for _, c := range cases {
        c := c
        t.Run(c.Input[:8], func(t *testing.T) {
            t.Parallel()
            users, err := ParseUsers([]string{c.Input})
            if err != nil {
                t.Fatalf("ParseUsers failed: %v", err)
            }
            var names []string
            for _, u := range users {
                names = append(names, u.Name)
            }
            // 使用 testify 的 ElementsMatch 忽略顺序
            // assert.ElementsMatch(t, c.Expected, names)
            if len(names) != len(c.Expected) {
                t.Errorf("expected %d names, got %d", len(c.Expected), len(names))
            }
        })
    }
}

// UpdateGolden 通过 -update 标志更新 golden 文件
// go test -run TestParseUsers_GoldenFile -update
var update = flag.Bool("update", false, "update golden files")

func TestUpdateGoldenPattern(t *testing.T) {
    if *update {
        // 重新生成 golden.json
        // ...
        t.Log("golden files updated")
    }
}

4.8 Fuzzing 测试

// fuzz_test.go
package user

import (
    "testing"
    "unicode/utf8"
)

// FuzzNewUser_Name 对 NewUser 的 name 参数进行 fuzzing
// Go 1.18+ 原生 fuzzing
func FuzzNewUser_Name(f *testing.F) {
    // 种子语料库:覆盖典型输入
    seeds := []string{
        "Alice",
        "Bob",
        "小明",
        "",
        "A",
        strings.Repeat("X", 100),
        "  spaces  ",
        "user@example",
    }
    for _, s := range seeds {
        f.Add(s)
    }

    f.Fuzz(func(t *testing.T, name string) {
        // Fuzzing 不应 panic,只检查不崩溃
        // 不强制要求校验通过,只验证不 panic
        defer func() {
            if r := recover(); r != nil {
                t.Fatalf("NewUser panicked with name %q: %v", name, r)
            }
        }()

        email := "fuzz@example.com"
        age := 25
        u, err := NewUser(name, email, age)
        if err != nil {
            // 校验失败是合法的,只要不 panic
            return
        }
        // 校验通过时,检查不变量
        if u == nil {
            t.Fatal("NewUser returned nil user without error")
        }
        // 不变量:返回的 Name 不为空,且长度在 2-64 之间
        runeCount := utf8.RuneCountInString(u.Name)
        if runeCount < 2 || runeCount > 64 {
            t.Errorf("invalid name length %d for input %q", runeCount, name)
        }
    })
}

// FuzzParseUsers_Format 对 ParseUsers 进行 fuzzing
func FuzzParseUsers_Format(f *testing.F) {
    f.Add("Alice,alice@example.com,30")
    f.Add("invalid")
    f.Add("Alice,alice,notanumber")

    f.Fuzz(func(t *testing.T, line string) {
        defer func() {
            if r := recover(); r != nil {
                t.Fatalf("ParseUsers panicked: %v", r)
            }
        }()
        _, _ = ParseUsers([]string{line})
    })
}

// FuzzEmailRegex 对邮箱正则进行 fuzzing
func FuzzEmailRegex(f *testing.F) {
    f.Add("valid@example.com")
    f.Add("invalid")
    f.Add("a@b.c")

    f.Fuzz(func(t *testing.T, email string) {
        // 不应 panic
        _ = emailRegex.MatchString(email)
    })
}

4.9 Example 测试

// example_test.go
package user_test

import (
    "fmt"

    "github.com/fandex/user_service"
)

// ExampleNewUser 演示 NewUser 的基本用法
func ExampleNewUser() {
    u, err := user.NewUser("Alice", "alice@example.com", 30)
    if err != nil {
        fmt.Println("error:", err)
        return
    }
    fmt.Println(u.Name)
    // Output: Alice
}

// ExampleUser_AgeGroup 演示 AgeGroup
func ExampleUser_AgeGroup() {
    u, _ := user.NewUser("Bob", "bob@example.com", 25)
    fmt.Println(u.AgeGroup())
    // Output: adult
}

// ExampleUser_IsAdult 演示 IsAdult
func ExampleUser_IsAdult() {
    u, _ := user.NewUser("Carol", "carol@example.com", 17)
    fmt.Println(u.IsAdult())
    // Output: false
}

4.10 Mock 与 testify

// mock_test.go
package user

import (
    "context"
    "testing"

    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
)

// Repository 接口:数据访问层
type Repository interface {
    Save(ctx context.Context, u *User) error
    FindByEmail(ctx context.Context, email string) (*User, error)
}

// Service 业务层,依赖 Repository
type Service struct {
    repo Repository
}

func NewService(r Repository) *Service {
    return &Service{repo: r}
}

func (s *Service) Register(ctx context.Context, name, email string, age int) (*User, error) {
    existing, err := s.repo.FindByEmail(ctx, email)
    if err == nil && existing != nil {
        return nil, errors.New("email already registered")
    }
    u, err := NewUser(name, email, age)
    if err != nil {
        return nil, err
    }
    if err := s.repo.Save(ctx, u); err != nil {
        return nil, err
    }
    return u, nil
}

// MockRepository 手写 mock
type MockRepository struct {
    users map[string]*User
    err   error
}

func (m *MockRepository) Save(ctx context.Context, u *User) error {
    if m.err != nil {
        return m.err
    }
    if m.users == nil {
        m.users = make(map[string]*User)
    }
    m.users[u.Email] = u
    return nil
}

func (m *MockRepository) FindByEmail(ctx context.Context, email string) (*User, error) {
    if m.err != nil {
        return nil, m.err
    }
    return m.users[email], nil
}

// TestService_Register 手写 mock 测试
func TestService_Register(t *testing.T) {
    t.Run("success", func(t *testing.T) {
        repo := &MockRepository{}
        svc := NewService(repo)
        u, err := svc.Register(context.Background(), "Alice", "alice@example.com", 30)
        require.NoError(t, err)
        assert.Equal(t, "Alice", u.Name)
    })

    t.Run("email already exists", func(t *testing.T) {
        repo := &MockRepository{
            users: map[string]*User{
                "alice@example.com": {Name: "OldAlice"},
            },
        }
        svc := NewService(repo)
        _, err := svc.Register(context.Background(), "Alice", "alice@example.com", 30)
        assert.Error(t, err)
    })
}

// MockRepositoryWithTestify 使用 testify/mock
type MockRepositoryWithTestify struct {
    mock.Mock
}

func (m *MockRepositoryWithTestify) Save(ctx context.Context, u *User) error {
    args := m.Called(ctx, u)
    return args.Error(0)
}

func (m *MockRepositoryWithTestify) FindByEmail(ctx context.Context, email string) (*User, error) {
    args := m.Called(ctx, email)
    if args.Get(0) == nil {
        return nil, args.Error(1)
    }
    return args.Get(0).(*User), args.Error(1)
}

// TestService_Register_WithTestify 使用 testify/mock
func TestService_Register_WithTestify(t *testing.T) {
    t.Run("success", func(t *testing.T) {
        repo := new(MockRepositoryWithTestify)
        // 设置期望:FindByEmail 返回 nil(邮箱未注册)
        repo.On("FindByEmail", mock.Anything, "alice@example.com").
            Return(nil, nil)
        repo.On("Save", mock.Anything, mock.AnythingOfType("*user.User")).
            Return(nil)

        svc := NewService(repo)
        u, err := svc.Register(context.Background(), "Alice", "alice@example.com", 30)

        require.NoError(t, err)
        assert.Equal(t, "Alice", u.Name)
        repo.AssertExpectations(t)
    })

    t.Run("repo save failed", func(t *testing.T) {
        repo := new(MockRepositoryWithTestify)
        repo.On("FindByEmail", mock.Anything, "alice@example.com").
            Return(nil, nil)
        repo.On("Save", mock.Anything, mock.AnythingOfType("*user.User")).
            Return(errors.New("db connection failed"))

        svc := NewService(repo)
        _, err := svc.Register(context.Background(), "Alice", "alice@example.com", 30)

        assert.Error(t, err)
        repo.AssertExpectations(t)
    })
}

4.11 testing/quick 属性测试

// property_test.go
package user

import (
    "testing"
    "testing/quick"
    "unicode/utf8"
)

// TestNewUser_PropertyInverse 属性测试:若构造成功,Name 应保留输入(去除空格后)
func TestNewUser_PropertyInverse(t *testing.T) {
    fn := func(name string) bool {
        email := "prop@example.com"
        age := 25
        u, err := NewUser(name, email, age)
        if err != nil {
            // 校验失败时,只需确认是预期失败
            runeCount := utf8.RuneCountInString(name)
            return runeCount < 2 || runeCount > 64
        }
        // 校验成功时,Name 长度应在 2-64
        runeCount := utf8.RuneCountInString(u.Name)
        return runeCount >= 2 && runeCount <= 64
    }

    if err := quick.Check(fn, &quick.Config{MaxCount: 1000}); err != nil {
        t.Fatalf("property test failed: %v", err)
    }
}

// TestAgeGroup_Property 属性测试:AgeGroup 总返回预定义值之一
func TestAgeGroup_Property(t *testing.T) {
    validGroups := map[string]bool{
        "child": true, "teen": true, "adult": true, "senior": true,
    }
    fn := func(age uint8) bool {
        // age 范围 0-255,但 NewUser 限制 0-150
        a := int(age) % 151
        u, err := NewUser("Prop", "prop@example.com", a)
        if err != nil {
            return false
        }
        return validGroups[u.AgeGroup()]
    }
    if err := quick.Check(fn, &quick.Config{MaxCount: 1000}); err != nil {
        t.Fatalf("property test failed: %v", err)
    }
}

4.12 TestMain 与 setup/teardown

// main_test.go
package user

import (
    "log"
    "os"
    "testing"
)

// 全局测试状态
var testDB *TestDatabase

// TestMain 是整个测试程序入口
// 必须调用 m.Run() 并返回其结果
func TestMain(m *testing.M) int {
    // === Setup ===
    if err := setupTestEnv(); err != nil {
        log.Printf("setup failed: %v", err)
        os.Exit(1)
    }

    // 运行所有测试
    code := m.Run()

    // === Teardown ===
    teardownTestEnv()

    return code
}

func setupTestEnv() error {
    // 例如:启动 testcontainers PostgreSQL
    // 初始化 Redis 测试实例
    // 加载测试配置
    testDB = &TestDatabase{Name: "test_db"}
    return nil
}

func teardownTestEnv() {
    if testDB != nil {
        // 关闭数据库连接
        testDB = nil
    }
}

type TestDatabase struct {
    Name string
}

// TestWithTestMain 验证 TestMain 已正确 setup
func TestWithTestMain(t *testing.T) {
    if testDB == nil {
        t.Fatal("testDB should be initialized by TestMain")
    }
}

4.13 helper 与 cleanup

// helper_test.go
package user

import (
    "fmt"
    "io"
    "os"
    "path/filepath"
    "testing"
)

// newTestUser helper 函数,标记 t.Helper() 让失败栈定位到调用方
func newTestUser(t *testing.T, name string) *User {
    t.Helper()  // 关键:失败时报告调用方位置
    u, err := NewUser(name, "helper@example.com", 25)
    if err != nil {
        t.Fatalf("failed to create test user: %v", err)
    }
    return u
}

func TestHelper(t *testing.T) {
    u := newTestUser(t, "HelperAlice")
    if u.Name != "HelperAlice" {
        t.Errorf("unexpected name: %s", u.Name)
    }
}

// createTempFile 使用 t.Cleanup 自动清理
func createTempFile(t *testing.T, pattern string, content string) *os.File {
    t.Helper()
    f, err := os.CreateTemp("", pattern)
    if err != nil {
        t.Fatalf("failed to create temp file: %v", err)
    }
    // 注册 cleanup:测试结束时自动删除
    t.Cleanup(func() {
        f.Close()
        os.Remove(f.Name())
    })
    if _, err := io.WriteString(f, content); err != nil {
        t.Fatalf("failed to write temp file: %v", err)
    }
    if _, err := f.Seek(0, 0); err != nil {
        t.Fatalf("failed to seek: %v", err)
    }
    return f
}

func TestCleanup(t *testing.T) {
    f := createTempFile(t, "test-*.txt", "hello world")
    data, err := os.ReadFile(f.Name())
    if err != nil {
        t.Fatalf("read failed: %v", err)
    }
    if string(data) != "hello world" {
        t.Errorf("unexpected content: %s", data)
    }
    // 测试结束后,文件自动清理
}

// nestedCleanup 演示 cleanup 的 LIFO 顺序
func TestNestedCleanup(t *testing.T) {
    t.Cleanup(func() { fmt.Println("cleanup 1") })
    t.Cleanup(func() { fmt.Println("cleanup 2") })
    t.Cleanup(func() { fmt.Println("cleanup 3") })
    // 输出顺序:3, 2, 1 (LIFO)
}

// withTestDir 使用 t.TempDir 创建隔离的测试目录
func TestWithTempDir(t *testing.T) {
    dir := t.TempDir()  // 自动 cleanup
    path := filepath.Join(dir, "test.txt")
    if err := os.WriteFile(path, []byte("test"), 0644); err != nil {
        t.Fatal(err)
    }
    // 不需要手动清理
}

5. 对比分析

5.1 测试框架对比

5.2 断言库对比

// Go 原生
if got != want {
    t.Errorf("got %v, want %v", got, want)
}

// testify/assert
assert.Equal(t, want, got)
require.Equal(t, want, got)  // 失败时立即停止

// testify/suite
type MySuite struct {
    suite.Suite
}
func (s *MySuite) TestSomething() {
    s.Equal(42, answer)
}

// goconvey (BDD 风格)
Convey("Given a user", t, func() {
    Convey("When created with valid input", func() {
        u, err := NewUser("Alice", ...)
        Convey("Then no error should occur", func() {
            So(err, ShouldBeNil)
        })
    })
})

// Gomega (matcher 风格,常用于 Ginkgo)
Expect(answer).To(Equal(42))
Expect(err).NotTo(HaveOccurred())

5.3 性能测试工具对比

6. 常见陷阱与最佳实践

6.1 陷阱一:循环变量捕获(Go 1.21 及以下)

// 陷阱(Go 1.21 及以下)
func TestLoopVarTrap(t *testing.T) {
    cases := []int{1, 2, 3}
    for _, c := range cases {
        t.Run("case", func(t *testing.T) {
            t.Parallel()
            // Go 1.21:所有子测试都看到 c=3
            // Go 1.22+:每个子测试看到正确值
            t.Log(c)
        })
    }
}

// 修复:显式 shadow
func TestLoopVarFix(t *testing.T) {
    cases := []int{1, 2, 3}
    for _, c := range cases {
        c := c  // 显式新建变量
        t.Run("case", func(t *testing.T) {
            t.Parallel()
            t.Log(c)
        })
    }
}

6.2 陷阱二:t.Parallel 与共享全局状态

// 陷阱:data race
var globalCounter int

func TestParallelRace(t *testing.T) {
    t.Parallel()
    globalCounter++  // data race!
}

// 修复:使用 atomic 或独立状态
func TestParallelSafe(t *testing.T) {
    t.Parallel()
    var localCounter int
    localCounter++
    _ = localCounter
}

6.3 陷阱三:time.Now() 与 flaky test

// 陷阱:依赖时间精度
func TestCreatedAt(t *testing.T) {
    before := time.Now()
    u, _ := NewUser("Alice", "alice@example.com", 30)
    after := time.Now()
    // 多数情况通过,但时钟精度差异可能失败
    if u.CreatedAt != before && u.CreatedAt != after {
        t.Error("unexpected created time")
    }
}

// 修复:使用时间窗口
func TestCreatedAtRobust(t *testing.T) {
    before := time.Now()
    u, _ := NewUser("Alice", "alice@example.com", 30)
    after := time.Now()
    // 使用区间断言
    if u.CreatedAt.Before(before) || u.CreatedAt.After(after.Add(time.Millisecond)) {
        t.Errorf("created time %v not in [%v, %v]", u.CreatedAt, before, after)
    }
}

// 最佳实践:注入 clock 接口
type Clock interface {
    Now() time.Time
}

type realClock struct{}
func (realClock) Now() time.Time { return time.Now().UTC() }

type fakeClock struct{ t time.Time }
func (c fakeClock) Now() time.Time { return c.t }

func NewUserWithClock(name, email string, age int, clock Clock) (*User, error) {
    // ... 校验 ...
    return &User{CreatedAt: clock.Now()}, nil
}

6.4 陷阱四:goroutine 泄漏

// 陷阱:测试启动的 goroutine 未等待完成
func TestGoroutineLeak(t *testing.T) {
    ch := make(chan int)
    go func() {
        time.Sleep(time.Second)
        ch <- 42
    }()
    // 测试立即返回,goroutine 仍运行
    // 下一个测试可能受影响
}

// 修复 1:使用 sync.WaitGroup
func TestGoroutineWait(t *testing.T) {
    var wg sync.WaitGroup
    ch := make(chan int, 1)
    wg.Add(1)
    go func() {
        defer wg.Done()
        ch <- 42
    }()
    select {
    case v := <-ch:
        t.Log(v)
    case <-time.After(time.Second):
        t.Fatal("timeout")
    }
    wg.Wait()
}

// 修复 2:使用 go.uber.org/goleak 检测
// 在 TestMain 中
func TestMain(m *testing.M) int {
    defer goleak.VerifyNone(m)
    return m.Run()
}

6.5 陷阱五:Mock 过度耦合实现

// 反模式:mock 内部实现细节
type Service struct {
    repo *MockRepo  // 直接依赖 mock 类型
}

// 重构:依赖接口,而非具体实现
type Service struct {
    repo Repository  // 依赖接口
}

// 测试中注入 mock
svc := NewService(new(MockRepo))

6.6 陷阱六:基准测试未隔离环境

// 反模式:基准测试受 IO 影响
func BenchmarkFileRead(b *testing.B) {
    for i := 0; i < b.N; i++ {
        data, _ := os.ReadFile("large.dat")  // IO 抖动
        _ = data
    }
}

// 修复:预加载到内存
func BenchmarkFileReadInMem(b *testing.B) {
    data, _ := os.ReadFile("large.dat")
    b.SetBytes(int64(len(data)))
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = data  // 仅测量内存访问
    }
}

6.7 陷阱七:b.ResetTimer 位置错误

// 反模式:ResetTimer 在循环内
func BenchmarkWrong(b *testing.B) {
    for i := 0; i < b.N; i++ {
        b.ResetTimer()  // 错误!每次迭代重置
        _ = expensiveOp()
    }
}

// 修复:在循环外
func BenchmarkRight(b *testing.B) {
    setup()
    b.ResetTimer()  // 仅重置一次
    for i := 0; i < b.N; i++ {
        _ = expensiveOp()
    }
}

6.8 最佳实践清单

1. 优先表驱动测试:可读性高、易扩展、易于并行化。
2. 使用 t.Helper 标记辅助函数:失败栈定位准确。
3. 使用 t.Cleanup 替代 defer:支持嵌套、与 t.Parallel 兼容。
4. 使用 t.TempDir 隔离文件系统:自动清理。
5. 关键断言用 require,非关键用 assert:平衡可读性与停止时机。
6. 基准测试用 -count=10 + benchstat:统计显著。
7. 关键路径加 -race 检测:CI 中默认开启。
8. fuzzing 集成到 CI:定期运行,语料库纳入版本控制。
9. 覆盖率作为门槛,但不追求 100%:80-90% 通常足够,关注关键路径。
10. 测试金字塔 70/20/10:单元测试为主,集成/端到端为辅。
11. 测试名表达意图:TestNewUser_RejectsEmptyName 优于 TestNewUser1。
12. 避免测试中的逻辑分支:测试应线性,不应有 if-else 影响可读性。
13. 使用 testing.Short() 区分快速/慢速测试:CI 跑全量,本地开发跑快速。
14. golden file 解耦复杂期望:复杂数据结构用 JSON 文件存储。
15. mock 接口而非实现:降低耦合,支持重构。

7. 工程实践

7.1 CI 集成

.github/workflows/test.yml:

name: Test

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        go-version: ['1.21', '1.22']
    steps:
      - uses: actions/checkout@v4

      - name: Setup Go
        uses: actions/setup-go@v5
        with:
          go-version: ${{ matrix.go-version }}
          cache: true

      - name: Download dependencies
        run: go mod download

      - name: Vet
        run: go vet ./...

      - name: Lint
        uses: golangci/golangci-lint-action@v4
        with:
          version: latest

      - name: Test with race
        run: go test -race -coverprofile=coverage.txt -covermode=atomic ./...

      - name: Benchmark (smoke)
        run: go test -bench=. -benchtime=10x -run=^$ ./...

      - name: Fuzz (smoke)
        run: |
          go test -fuzz=FuzzNewUser -fuzztime=30s ./...

      - name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          file: ./coverage.txt

      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: test-results-${{ matrix.go-version }}
          path: |
            coverage.txt
            *.out