1
// src/testing/testing.go 核心类型 — https://github.com/golang/go/blob/go1.25.0/src/testing/testing.go
2
type T struct {
3
    common    // 公共方法
4
    isEnvSet  bool
5
    context   *testContext
6
}
7

8
type B struct {
9
    common
10
    N          int       // 基准测试迭代次数
11
    previousN  int
12
    previousDur time.Duration
13
}

1
func TestExample(t *testing.T) {
2
    // 日志输出
3
    t.Log("普通日志")          // 仅在失败或 -v 时显示
4
    t.Logf("格式化日志: %d", 1)
5

6
    // 标记失败（继续执行）
7
    t.Error("错误信息")        // 等价于 Log + Fail
8
    t.Errorf("格式化错误: %s", "err")
9

10
    // 标记失败并立即终止
11
    t.Fatal("致命错误")        // 等价于 Log + FailNow
12
    t.Fatalf("格式化致命错误: %s", "err")
13

14
    // 跳过测试
15
    t.Skip("跳过原因")
16
    t.Skipf("跳过: %s", "reason")
17
    t.SkipNow()               // 立即跳过
18

19
    // 并行测试
20
    t.Parallel()              // 标记为可并行执行
21

22
    // 子测试
23
    t.Run("子测试名", func(t *testing.T) {
24
        // 子测试逻辑
25
    })
26

27
    // 状态检查
28
    t.Failed()                // 是否失败
29
    t.Skipped()               // 是否跳过
30

31
    // 清理函数
32
    t.Cleanup(func() {
33
        // 测试结束后执行
34
    })
35

36
    // 临时目录
37
    t.TempDir()               // 自动清理的临时目录
38

39
    // 上下文
40
    t.Context()               // 返回 context.Context
41
}

1
func BenchmarkExample(b *testing.B) {
2
    // 重置计时器（忽略准备阶段）
3
    b.ResetTimer()
4

5
    // 暂停/恢复计时
6
    b.StopTimer()
7
    // 准备工作...
8
    b.StartTimer()
9

10
    // 报告内存分配
11
    b.ReportAllocs()
12

13
    // 设置吞吐量指标
14
    b.SetBytes(1024)          // 每次操作处理 1KB
15

16
    // 子基准测试
17
    b.Run("子基准", func(b *testing.B) {
18
        // ...
19
    })
20

21
    // 基准循环
22
    for i := 0; i < b.N; i++ {
23
        // 被测代码
24
    }
25
}

1
myapp/
2
├── calculator.go
3
├── calculator_test.go      # 单元测试
4
├── calculator_bench_test.go # 基准测试（可选分离）
5
└── calculator_fuzz_test.go  # 模糊测试（Go 1.18+）

1
func TestAdd(t *testing.T) {
2
    // Arrange（准备）
3
    calc := NewCalculator()
4
    a, b := 2, 3
5
    expected := 5
6

7
    // Act（执行）
8
    result := calc.Add(a, b)
9

10
    // Assert（断言）
11
    if result != expected {
12
        t.Errorf("Add(%d, %d) = %d; want %d", a, b, result, expected)
13
    }
14
}

1
// 辅助函数不以 Test 开头
2
func assertEqual(t *testing.T, got, want any, msg ...string) {
3
    t.Helper() // 标记为辅助函数，错误报告跳过此函数
4
    if got != want {
5
        message := ""
6
        if len(msg) > 0 {
7
            message = ": " + msg[0]
8
        }
9
        t.Errorf("got %v, want %v%s", got, want, message)
10
    }
11
}
12

13
func assertError(t *testing.T, err error, wantErr bool) {
14
    t.Helper()
15
    if (err != nil) != wantErr {
16
        t.Errorf("error = %v, wantErr %v", err, wantErr)
17
    }
18
}
19

20
// 使用示例
21
func TestDivide(t *testing.T) {
22
    calc := NewCalculator()
23

24
    // 正常情况
25
    result, err := calc.Divide(10, 2)
26
    assertEqual(t, result, 5)
27
    assertError(t, err, false)
28

29
    // 除零错误
30
    _, err = calc.Divide(10, 0)
31
    assertError(t, err, true)
32
}

1
// 没有 t.Helper() 时的错误报告：
2
//     calculator_test.go:15: got 3, want 5
3

4
// 有 t.Helper() 时的错误报告：
5
//     calculator_test.go:25: got 3, want 5
6
//     （指向实际测试代码，而非辅助函数）

1
func TestFileProcessing(t *testing.T) {
2
    // 创建临时文件
3
    tmpFile, err := os.CreateTemp("", "test_*.txt")
4
    if err != nil {
5
        t.Fatal(err)
6
    }
7

8
    // 注册清理函数
9
    t.Cleanup(func() {
10
        os.Remove(tmpFile.Name())
11
    })
12

13
    // 使用 t.TempDir() 更简洁
14
    // tmpDir := t.TempDir() // 自动清理
15

16
    // 测试逻辑...
17
}

1
func TestConcurrentMap(t *testing.T) {
2
    var m sync.Map
3
    var wg sync.WaitGroup
4

5
    // 并发写入
6
    for i := 0; i < 100; i++ {
7
        wg.Add(1)
8
        go func(n int) {
9
            defer wg.Done()
10
            m.Store(n, n*2)
11
        }(i)
12
    }
13

14
    // 并发读取
15
    for i := 0; i < 100; i++ {
16
        wg.Add(1)
17
        go func(n int) {
18
            defer wg.Done()
19
            if v, ok := m.Load(n); ok {
20
                if v != n*2 {
21
                    t.Errorf("m[%d] = %v; want %d", n, v, n*2)
22
                }
23
            }
24
        }(i)
25
    }
26

27
    wg.Wait()
28
}

1
func TestAdd(t *testing.T) {
2
    tests := []struct {
3
        name     string
4
        a, b     int
5
        want     int
6
        wantErr  bool
7
    }{
8
        {"positive numbers", 2, 3, 5, false},
9
        {"negative numbers", -1, -2, -3, false},
10
        {"mixed signs", -1, 2, 1, false},
11
        {"zeros", 0, 0, 0, false},
12
        {"overflow", math.MaxInt, 1, 0, true}, // 假设溢出返回错误
13
    }
14

15
    for _, tt := range tests {
16
        t.Run(tt.name, func(t *testing.T) {
17
            got, err := Add(tt.a, tt.b)
18
            if (err != nil) != tt.wantErr {
19
                t.Errorf("Add(%d, %d) error = %v, wantErr %v", tt.a, tt.b, err, tt.wantErr)
20
                return
21
            }
22
            if got != tt.want {
23
                t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, got, tt.want)
24
            }
25
        })
26
    }
27
}

1
func TestParseUser(t *testing.T) {
2
    tests := []struct {
3
        name    string
4
        input   string
5
        want    *User
6
        wantErr error
7
    }{
8
        {
9
            name:  "valid user",
10
            input: `{"name": "Alice", "age": 30}`,
11
            want: &User{Name: "Alice", Age: 30},
12
            wantErr: nil,
13
        },
14
        {
15
            name:    "empty name",
16
            input:   `{"name": "", "age": 30}`,
17
            want:    nil,
18
            wantErr: ErrEmptyName,
19
        },
20
        {
21
            name:    "invalid age",
22
            input:   `{"name": "Bob", "age": -1}`,
23
            want:    nil,
24
            wantErr: ErrInvalidAge,
25
        },
26
        {
27
            name:    "malformed JSON",
28
            input:   `{invalid}`,
29
            want:    nil,
30
            wantErr: &json.SyntaxError{},
31
        },
32
    }
33

34
    for _, tt := range tests {
35
        t.Run(tt.name, func(t *testing.T) {
36
            got, err := ParseUser(strings.NewReader(tt.input))
37

38
            // 错误类型检查
39
            if tt.wantErr != nil {
40
                if !errors.Is(err, tt.wantErr) && !errorsAs(err, tt.wantErr) {
41
                    t.Errorf("ParseUser() error = %v, want %v", err, tt.wantErr)
42
                }
43
                return
44
            }
45

46
            // 结果比较
47
            if diff := cmp.Diff(tt.want, got); diff != "" {
48
                t.Errorf("ParseUser() mismatch (-want +got):\n%s", diff)
49
            }
50
        })
51
    }
52
}
53

54
// 辅助函数：检查错误类型
55
func errorsAs(err, target error) bool {
56
    targetType := reflect.TypeOf(target)
57
    if targetType == nil {
58
        return false
59
    }
60
    targetType = targetType.Elem()
61
    return reflect.TypeOf(err).Elem().ConvertibleTo(targetType)
62
}

1
import "github.com/google/go-cmp/cmp"
2

3
func TestStructComparison(t *testing.T) {
4
    want := &User{
5
        Name:  "Alice",
6
        Email: "alice@example.com",
7
        CreatedAt: time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC),
8
    }
9

10
    got := &User{
11
        Name:  "Alice",
12
        Email: "alice@example.com",
13
        CreatedAt: time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC),
14
    }
15

16
    // 忽略某些字段
17
    opts := []cmp.Option{
18
        cmpopts.IgnoreFields(User{}, "CreatedAt"),
19
        cmpopts.IgnoreUnexported(User{}),
20
    }
21

22
    if diff := cmp.Diff(want, got, opts...); diff != "" {
23
        t.Errorf("User mismatch (-want +got):\n%s", diff)
24
    }
25
}

1
func BenchmarkAdd(b *testing.B) {
2
    // b.N 由框架自动调整
3
    for i := 0; i < b.N; i++ {
4
        Add(1, 2)
5
    }
6
}

1
# 运行所有基准测试
2
go test -bench=.
3

4
# 运行特定基准测试
5
go test -bench=BenchmarkAdd
6

7
# 增加运行时间（默认 1 秒）
8
go test -bench=. -benchtime=5s
9

10
# 运行指定次数
11
go test -bench=. -benchtime=1000x
12

13
# 显示内存分配统计
14
go test -bench=. -benchmem
15

16
# 禁用 CPU 优化
17
go test -bench=. -gcflags=-N

1
func BenchmarkJSONUnmarshal(b *testing.B) {
2
    // 准备阶段：不在计时范围内
3
    data := generateLargeJSON()
4

5
    // 重置计时器，忽略准备阶段
6
    b.ResetTimer()
7

8
    for i := 0; i < b.N; i++ {
9
        var result Data
10
        if err := json.Unmarshal(data, &result); err != nil {
11
            b.Fatal(err)
12
        }
13
    }
14
}
15

16
func BenchmarkFileWrite(b *testing.B) {
17
    for i := 0; i < b.N; i++ {
18
        // 每次迭代创建新文件
19
        b.StopTimer()
20
        f, err := os.CreateTemp("", "bench_")
21
        if err != nil {
22
            b.Fatal(err)
23
        }
24
        b.StartTimer()
25

26
        // 写入操作
27
        _, err = f.Write([]byte("test data"))
28
        f.Close()
29
        os.Remove(f.Name())
30

31
        if err != nil {
32
            b.Fatal(err)
33
        }
34
    }
35
}

1
func BenchmarkParallelProcess(b *testing.B) {
2
    b.RunParallel(func(pb *testing.PB) {
3
        for pb.Next() {
4
            Process(rand.Int())
5
        }
6
    })
7
}
8

9
// 运行时指定并行度
10
// go test -bench=ParallelProcess -cpu=1,2,4,8

1
func BenchmarkSliceAppend(b *testing.B) {
2
    b.ReportAllocs()
3

4
    for i := 0; i < b.N; i++ {
5
        var s []int
6
        for j := 0; j < 1000; j++ {
7
            s = append(s, j)
8
        }
9
    }
10
}
11

12
// 对比预分配
13
func BenchmarkSlicePrealloc(b *testing.B) {
14
    b.ReportAllocs()
15

16
    for i := 0; i < b.N; i++ {
17
        s := make([]int, 0, 1000)
18
        for j := 0; j < 1000; j++ {
19
            s = append(s, j)
20
        }
21
    }
22
}

1
BenchmarkSliceAppend-8     1000000    1200 ns/op    8192 B/op    10 allocs/op
2
BenchmarkSlicePrealloc-8   5000000     240 ns/op    8192 B/op     1 allocs/op

1
func BenchmarkJSON(b *testing.B) {
2
    data := generateTestData()
3

4
    b.Run("Unmarshal", func(b *testing.B) {
5
        for i := 0; i < b.N; i++ {
6
            var result Data
7
            json.Unmarshal(data, &result)
8
        }
9
    })
10

11
    b.Run("Marshal", func(b *testing.B) {
12
        d := Data{ /* ... */ }
13
        for i := 0; i < b.N; i++ {
14
            json.Marshal(d)
15
        }
16
    })
17

18
    // 不同数据大小
19
    sizes := []int{100, 1000, 10000}
20
    for _, size := range sizes {
21
        b.Run(fmt.Sprintf("size-%d", size), func(b *testing.B) {
22
            data := generateData(size)
23
            b.ResetTimer()
24
            for i := 0; i < b.N; i++ {
25
                process(data)
26
            }
27
        })
28
    }
29
}

1
func TestUserValidation(t *testing.T) {
2
    tests := []struct {
3
        name    string
4
        user    User
5
        wantErr bool
6
    }{
7
        {"valid user", User{Name: "Alice", Age: 25}, false},
8
        {"empty name", User{Name: "", Age: 25}, true},
9
        {"negative age", User{Name: "Bob", Age: -1}, true},
10
    }
11

12
    for _, tt := range tests {
13
        tt := tt // 捕获变量（Go 1.22+ 可省略）
14
        t.Run(tt.name, func(t *testing.T) {
15
            err := ValidateUser(tt.user)
16
            if (err != nil) != tt.wantErr {
17
                t.Errorf("ValidateUser() error = %v, wantErr %v", err, tt.wantErr)
18
            }
19
        })
20
    }
21
}

1
# 运行 TestUserValidation 下的所有子测试
2
go test -run TestUserValidation
3

4
# 运行特定子测试（使用 / 分隔）
5
go test -run TestUserValidation/valid_user
6
go test -run TestUserValidation/empty_name
7

8
# 使用正则匹配
9
go test -run "TestUserValidation/empty.*"

1
func TestParallel(t *testing.T) {
2
    t.Run("group", func(t *testing.T) {
3
        // 这两个子测试会并行执行
4
        t.Run("parallel-1", func(t *testing.T) {
5
            t.Parallel()
6
            time.Sleep(100 * time.Millisecond)
7
            // 测试逻辑...
8
        })
9

10
        t.Run("parallel-2", func(t *testing.T) {
11
            t.Parallel()
12
            time.Sleep(100 * time.Millisecond)
13
            // 测试逻辑...
14
        })
15

16
        // 这个子测试会等待上面的并行测试完成后执行
17
        t.Run("sequential", func(t *testing.T) {
18
            // 没有 t.Parallel()，顺序执行
19
        })
20
    })
21
}

1
group (开始)
2
├── parallel-1 (开始，并行)
3
├── parallel-2 (开始，并行)
4
├── [等待并行测试完成]
5
└── sequential (执行)
6
group (结束)

1
func BenchmarkStringConcat(b *testing.B) {
2
    parts := []string{"Hello", " ", "World", "!"}
3

4
    b.Run("plus-operator", func(b *testing.B) {
5
        for i := 0; i < b.N; i++ {
6
            s := parts[0] + parts[1] + parts[2] + parts[3]
7
            _ = s
8
        }
9
    })
10

11
    b.Run("fmt.Sprintf", func(b *testing.B) {
12
        for i := 0; i < b.N; i++ {
13
            s := fmt.Sprintf("%s%s%s%s", parts[0], parts[1], parts[2], parts[3])
14
            _ = s
15
        }
16
    })
17

18
    b.Run("strings.Builder", func(b *testing.B) {
19
        for i := 0; i < b.N; i++ {
20
            var sb strings.Builder
21
            for _, p := range parts {
22
                sb.WriteString(p)
23
            }
24
            _ = sb.String()
25
        }
26
    })
27

28
    b.Run("strings.Join", func(b *testing.B) {
29
        for i := 0; i < b.N; i++ {
30
            s := strings.Join(parts, "")
31
            _ = s
32
        }
33
    })
34
}

1
// 定义接口
2
type UserRepository interface {
3
    GetByID(ctx context.Context, id string) (*User, error)
4
    Save(ctx context.Context, user *User) error
5
}
6

7
// 真实实现
8
type DBUserRepository struct {
9
    db *sql.DB
10
}
11

12
func (r *DBUserRepository) GetByID(ctx context.Context, id string) (*User, error) {
13
    // 数据库查询...
14
}
15

16
// Mock 实现
17
type MockUserRepository struct {
18
    GetByIDFunc func(ctx context.Context, id string) (*User, error)
19
    SaveFunc    func(ctx context.Context, user *User) error
20
}
21

22
func (m *MockUserRepository) GetByID(ctx context.Context, id string) (*User, error) {
23
    if m.GetByIDFunc != nil {
24
        return m.GetByIDFunc(ctx, id)
25
    }
26
    return nil, errors.New("not implemented")
27
}
28

29
func (m *MockUserRepository) Save(ctx context.Context, user *User) error {
30
    if m.SaveFunc != nil {
31
        return m.SaveFunc(ctx, user)
32
    }
33
    return errors.New("not implemented")
34
}

1
func TestUserService_GetUser(t *testing.T) {
2
    tests := []struct {
3
        name    string
4
        mock    *MockUserRepository
5
        want    *User
6
        wantErr bool
7
    }{
8
        {
9
            name: "success",
10
            mock: &MockUserRepository{
11
                GetByIDFunc: func(ctx context.Context, id string) (*User, error) {
12
                    return &User{ID: id, Name: "Alice"}, nil
13
                },
14
            },
15
            want:    &User{ID: "1", Name: "Alice"},
16
            wantErr: false,
17
        },
18
        {
19
            name: "not found",
20
            mock: &MockUserRepository{
21
                GetByIDFunc: func(ctx context.Context, id string) (*User, error) {
22
                    return nil, ErrNotFound
23
                },
24
            },
25
            want:    nil,
26
            wantErr: true,
27
        },
28
    }
29

30
    for _, tt := range tests {
31
        t.Run(tt.name, func(t *testing.T) {
32
            service := NewUserService(tt.mock)
33
            got, err := service.GetUser(context.Background(), "1")
34
            if (err != nil) != tt.wantErr {
35
                t.Errorf("GetUser() error = %v, wantErr %v", err, tt.wantErr)
36
                return
37
            }
38
            if diff := cmp.Diff(tt.want, got); diff != "" {
39
                t.Errorf("GetUser() mismatch (-want +got):\n%s", diff)
40
            }
41
        })
42
    }
43
}

1
import "github.com/stretchr/testify/mock"
2

3
// Mock 对象
4
type MockRepository struct {
5
    mock.Mock
6
}
7

8
func (m *MockRepository) GetByID(ctx context.Context, id string) (*User, error) {
9
    args := m.Called(ctx, id)
10
    if args.Get(0) == nil {
11
        return nil, args.Error(1)
12
    }
13
    return args.Get(0).(*User), args.Error(1)
14
}
15

16
func (m *MockRepository) Save(ctx context.Context, user *User) error {
17
    args := m.Called(ctx, user)
18
    return args.Error(0)
19
}
20

21
// 测试
22
func TestUserService_Save(t *testing.T) {
23
    mockRepo := new(MockRepository)
24
    service := NewUserService(mockRepo)
25

26
    user := &User{ID: "1", Name: "Alice"}
27

28
    // 设置期望
29
    mockRepo.On("Save", mock.Anything, user).Return(nil)
30

31
    // 执行测试
32
    err := service.Save(context.Background(), user)
33
    assert.NoError(t, err)
34

35
    // 验证期望被满足
36
    mockRepo.AssertExpectations(t)
37
}
38

39
// 带返回值和错误的期望
40
func TestUserService_GetByID(t *testing.T) {
41
    mockRepo := new(MockRepository)
42
    service := NewUserService(mockRepo)
43

44
    expectedUser := &User{ID: "1", Name: "Alice"}
45

46
    mockRepo.On("GetByID", mock.Anything, "1").
47
        Return(expectedUser, nil).
48
        Once() // 只期望调用一次
49

50
    user, err := service.GetUser(context.Background(), "1")
51

52
    assert.NoError(t, err)
53
    assert.Equal(t, expectedUser, user)
54
    mockRepo.AssertExpectations(t)
55
}
56

57
// 基于条件的期望
58
func TestUserService_GetByID_MultipleCalls(t *testing.T) {
59
    mockRepo := new(MockRepository)
60

61
    // 第一次调用返回用户，第二次返回错误
62
    mockRepo.On("GetByID", mock.Anything, "1").
63
        Return(&User{ID: "1", Name: "Alice"}, nil).
64
        Once()
65

66
    mockRepo.On("GetByID", mock.Anything, "1").
67
        Return(nil, ErrNotFound).
68
        Once()
69

70
    // 或者使用 Run 来执行自定义逻辑
71
    mockRepo.On("GetByID", mock.Anything, mock.Anything).
72
        Run(func(args mock.Arguments) {
73
            id := args.Get(1).(string)
74
            fmt.Println("GetByID called with:", id)
75
        }).
76
        Return(&User{ID: "1"}, nil)
77
}

1
//go:generate mockgen -source=repository.go -destination=mock_repository.go -package=mocks
2

3
type Repository interface {
4
    Get(ctx context.Context, id string) (*Entity, error)
5
    Save(ctx context.Context, entity *Entity) error
6
}
7

8
// 测试代码
9
func TestWithGomock(t *testing.T) {
10
    ctrl := gomock.NewController(t)
11
    defer ctrl.Finish()
12

13
    mockRepo := mocks.NewMockRepository(ctrl)
14

15
    // 设置期望
16
    mockRepo.EXPECT().
17
        Get(gomock.Any(), "1").
18
        Return(&Entity{ID: "1"}, nil)
19

20
    mockRepo.EXPECT().
21
        Save(gomock.Any(), gomock.Any()).
22
        DoAndReturn(func(ctx context.Context, e *Entity) error {
23
            assert.Equal(t, "1", e.ID)
24
            return nil
25
        })
26

27
    // 使用 mockRepo...
28
}

1
import "net/http/httptest"
2

3
func TestHTTPHandler(t *testing.T) {
4
    handler := &UserHandler{}
5

6
    // 创建测试请求
7
    req := httptest.NewRequest("GET", "/users/1", nil)
8
    req = req.WithContext(context.WithValue(req.Context(), "userID", "1"))
9

10
    // 创建响应记录器
11
    rec := httptest.NewRecorder()
12

13
    // 执行请求
14
    handler.ServeHTTP(rec, req)
15

16
    // 验证响应
17
    assert.Equal(t, http.StatusOK, rec.Code)
18

19
    var response User
20
    json.Unmarshal(rec.Body.Bytes(), &response)
21
    assert.Equal(t, "1", response.ID)
22
}
23

24
// Mock HTTP Client
25
func TestHTTPClient(t *testing.T) {
26
    // 创建 mock server
27
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
28
        assert.Equal(t, "/api/users", r.URL.Path)
29
        w.Header().Set("Content-Type", "application/json")
30
        w.WriteHeader(http.StatusOK)
31
        json.NewEncoder(w).Encode(map[string]string{"id": "1", "name": "Alice"})
32
    }))
33
    defer server.Close()
34

35
    // 使用 mock server URL
36
    client := NewClient(server.URL)
37
    user, err := client.GetUser(context.Background(), "1")
38

39
    assert.NoError(t, err)
40
    assert.Equal(t, "Alice", user.Name)
41
}

1
# 查看覆盖率百分比
2
go test -cover ./...
3

4
# 查看详细覆盖率
5
go test -coverprofile=coverage.out ./...
6

7
# 查看函数级别覆盖率
8
go tool cover -func=coverage.out
9

10
# 生成 HTML 覆盖率报告
11
go tool cover -html=coverage.out -o coverage.html
12

13
# 按包查看覆盖率
14
go test -coverpkg=./... ./...

1
# set: 是否覆盖（默认）
2
go test -covermode=set -coverprofile=coverage.out
3

4
# count: 执行次数
5
go test -covermode=count -coverprofile=coverage.out
6

7
# atomic: 原子计数（用于并发测试）
8
go test -covermode=atomic -coverprofile=coverage.out

1
//go:build !coverage
2

3
package mypackage
4

5
// 不参与覆盖率统计的代码
6
func DebugOnly() {
7
    // ...
8
}

1
// 确保覆盖边界条件
2
func TestBoundaryConditions(t *testing.T) {
3
    // 空输入
4
    t.Run("empty input", func(t *testing.T) {
5
        result, err := Process([]int{})
6
        assert.NoError(t, err)
7
        assert.Nil(t, result)
8
    })
9

10
    // 单元素
11
    t.Run("single element", func(t *testing.T) {
12
        result, err := Process([]int{1})
13
        assert.NoError(t, err)
14
        assert.Equal(t, []int{1}, result)
15
    })
16

17
    // 大量数据
18
    t.Run("large input", func(t *testing.T) {
19
        data := make([]int, 10000)
20
        for i := range data {
21
            data[i] = i
22
        }
23
        result, err := Process(data)
24
        assert.NoError(t, err)
25
    })
26

27
    // 错误路径
28
    t.Run("nil input", func(t *testing.T) {
29
        result, err := Process(nil)
30
        assert.Error(t, err)
31
        assert.Nil(t, result)
32
    })
33
}

1
# 生成 CPU profile
2
go test -bench=. -cpuprofile=cpu.prof
3

4
# 生成内存 profile
5
go test -bench=. -memprofile=mem.prof
6

7
# 生成阻塞 profile
8
go test -bench=. -blockprofile=block.prof
9

10
# 生成互斥锁 profile
11
go test -bench=. -mutexprofile=mutex.prof
12

13
# 分析 profile
14
go tool pprof cpu.prof