测试：单元、表格驱动、基准、覆盖率

// calc.go —— 被测代码
package main

import "errors"

func Divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("除数不能为 0")
    }
    return a / b, nil
}

// calc_test.go —— 测试代码（同包 main，或换 _test 包后缀）
package main

import "testing"

func TestDivide(t *testing.T) {
    // 传入普通参数，用 t 汇报失败
    got, err := Divide(6, 3)
    if err != nil {
        t.Fatalf("不应出错: %v", err) // Fatal: 失败立即终止本测试
    }
    if got != 2 {
        t.Errorf("Divide(6,3) = %d, want 2", got) // Errorf: 失败记录但继续
    }
}

go test                 # 跑当前包全部测试
go test -v              # 显示每个用例名与结果
go test ./...           # 递归跑整个项目
go test -run TestDivide # 只跑名字含 TestDivide 的测试（支持正则）

func TestDivideTable(t *testing.T) {
    tests := []struct {
        name string // 用例名，用于子测试与失败定位
        a, b int
        want int
        wantErr bool
    }}{
        {"正数相除", 6, 3, 2, false},
        {"负数", -6, 3, -2, false},
        {"除数为零", 6, 0, 0, true},
        {"整除得1", 5, 5, 1, false},
        {"余数截断", 7, 2, 3, false}, // Go 整数除法向零截断
    }

    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.Fatalf("Divide(%d,%d) err = %v, wantErr %v", tt.a, tt.b, err, tt.wantErr)
            }
            if got != tt.want {
                t.Errorf("Divide(%d,%d) = %d, want %d", tt.a, tt.b, got, tt.want)
            }
        })
    }
}

# 运行全部子测试
go test -v

# 只运行指定子测试（外层/内层用 / 分隔）
go test -run 'TestDivideTable/正数相除'

# 用正则跑一组
go test -run 'TestDivideTable/(正数|负数)'

func TestParallel(t *testing.T) {
    cases := []int{1, 2, 3, 4}
    for _, n := range cases {
        n := n // Go 1.22 前子测试闭包捕获坑：需要复制变量
        t.Run("case", func(t *testing.T) {
            t.Parallel() // 标记该子测试并行
            // ... 相互独立的用例可并行提速
        })
    }
}

func TestWithFile(t *testing.T) {
    dir := t.TempDir() // 自动清理的临时目录，Go 测试最佳实践
    t.Cleanup(func() {
        // 手动清理逻辑（如删除后台进程）
    })
    _ = dir
}

// calc_test.go
func BenchmarkDivide(b *testing.B) {
    // b.N 由工具自动调整：先小后大，保证每轮足够采样时间
    for i := 0; i < b.N; i++ {
        _, _ = Divide(1000000, 7)
    }
}

func BenchmarkDivideParallel(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) { // 并行基准（多核压测）
        for pb.Next() {
            _, _ = Divide(1000000, 7)
        }
    })
}

go test -bench=.                          # 基准所有 BenchmarkXxx
go test -bench=BenchmarkDivide            # 精确一个
go test -bench=. -benchmem -benchtime=3s  # 带内存统计，跑 3 秒

# 输出示例：
# BenchmarkDivide-8        406130772    2.905 ns/op    0 B/op    0 allocs/op
#   │             │          │             │           │          │
#   │       CPU 核数(8)  循环次数     每次耗时    每次分配字节  每次分配次数

go test -cover                 # 输出覆盖率百分比
go test -coverprofile=cover.out # 输出覆盖数据到文件

# 生成 HTML 报告，浏览器逐行看哪些没测到
go tool cover -html=cover.out

go test -coverprofile=cover.out ./...
go tool cover -func=cover.out | tail -1   # 查看总覆盖率行

// 并发代码常见 bug：多 goroutine 读写共享变量
// 例：counter++ 由两个 goroutine 并发执行

# 用 -race 跑测试（编译期插桩，运行时检测竞态）
go test -race ./...

# 输出（检测到时）：
# ==================
# WARNING: DATA RACE
# Write at 0x00c0000be020 by goroutine 7:
#   ...
# ==================

func TestSlow(t *testing.T) {
    if testing.Short() { // 配合 go test -short 标记跳过慢测试
        t.Skip("短测试模式跳过慢用例")
    }
    // 跑一段很慢的逻辑
}

func TestNeedsEnv(t *testing.T) {
    token := os.Getenv("API_TOKEN")
    if token == "" {
        t.Skip("未设置 API_TOKEN，跳过")
    }
    // 依赖外部服务的测试
}

go test -short ./...   # 跳过被标记的慢测试，适合 CI 快速回归
go test -v             # 看到 t.Skip 的输出 "--- SKIP"

// 假设被测代码依赖一个接口
type Notifier interface {
    Send(msg string) error
}

// 手动写 mock：实现同接口
type mockNotifier struct {
    called bool
}

func (m *mockNotifier) Send(msg string) error {
    m.called = true          // 记录调用
    return nil               // 返回可控结果
}

func TestUsesNotifier(t *testing.T) {
    mock := &mockNotifier{}
    businessLogic := NewService(mock)

    businessLogic.Notify("hello")

    if !mock.called {
        t.Errorf("期望 Notifier 被调用")
    }
}

// handler.go —— 被测对象
func helloHandler(w http.ResponseWriter, r *http.Request) {
    name := r.URL.Query().Get("name")
    if name == "" {
        http.Error(w, "缺少 name 参数", http.StatusBadRequest)
        return
    }
    fmt.Fprintf(w, "Hello, %s!", name)
}

func NewMux() *http.ServeMux {
    mux := http.NewServeMux()
    mux.HandleFunc("/hello", helloHandler)
    return mux
}

// handler_test.go
package main

import (
    "io"
    "net/http"
    "net/http/httptest"
    "strings"
    "testing"
)

func TestHelloHandler(t *testing.T) {
    // 构造 httptest 服务器：内部起监听，用完自动关
    ts := httptest.NewServer(NewMux())
    defer ts.Close()

    // 表格驱动：cases 覆盖正常/缺参数/方法错误
    cases := []struct {
        name, query string
        wantCode    int
        wantBody    string
    }{
        {"正常", "?name=Tom", 200, "Hello, Tom!"},
        {"缺参数", "", 400, "缺少 name 参数"},
    }
    for _, c := range cases {
        t.Run(c.name, func(t *testing.T) {
            resp, err := http.Get(ts.URL + "/hello" + c.query)
            if err != nil {
                t.Fatal(err)
            }
            defer resp.Body.Close()

            if resp.StatusCode != c.wantCode {
                t.Errorf("code = %d, want %d", resp.StatusCode, c.wantCode)
            }
            body, _ := io.ReadAll(resp.Body)
            if !strings.Contains(string(body), c.wantBody) {
                t.Errorf("body = %q, want contains %q", body, c.wantBody)
            }
        })
    }
}

httptest.NewServer(handler)        // 完整 HTTP/1.1 监听
httptest.NewTLSServer(handler)     // HTTPS（客户端要用其 Client 证书）
httptest.NewRecorder()             // 不监听：直接捕获 handler 写入的响应

// 用 Recorder 做纯内存验证（更快）
func TestHelloRecorder(t *testing.T) {
    rec := httptest.NewRecorder()
    helloHandler(rec, httptest.NewRequest("GET", "/hello?name=Go", nil))
    if rec.Code != 200 || rec.Body.String() != "Hello, Go!" {
        t.Errorf("got %d %q", rec.Code, rec.Body.String())
    }
}

// fuzz 目标函数：与单元测试同名族
func FuzzStringToInt(f *testing.F) {
    f.Add("123")   // 种子语料：默认必跑
    f.Add("-42")
    f.Add("0")
    f.Fuzz(func(t *testing.T, s string) {
        got, err := StringToInt(s)
        if err != nil {
            return // 输入非法是允许的
        }
        // 有一条不变量：合法解析出的整数再转回字符串，前缀必须可再解析
        // 例如：任何被解析成功的输入 → 至少得出 int
        _ = got
    })
}

go test -fuzz=FuzzStringToInt -fuzztime=5s