Go 测试进阶实战——模糊测试 Fuzzing、基准测试、竞争条件检测

老张2026/4/30大约 7 分钟

Go 测试进阶实战——模糊测试 Fuzzing、基准测试、竞争条件检测

适读人群：写过基本单测、想进一步提升测试质量的 Go 工程师 | 阅读时长：约16分钟 | 核心价值：三种高级测试手段，让 bug 在上线前现形

那个"不可能出现"的 panic

有一次我们的 JSON 解析工具上线后，运行了三个月没问题，直到某天一个用户传了一个特殊的输入，程序直接 panic 了。

事后复现，那个输入是一串包含大量嵌套括号的字符串，触发了递归解析的栈溢出。

我当时就在想：如果我做了模糊测试，这个边界情况会在上线前就被发现。

正好 Go 1.18 把 Fuzzing 引入了标准库，不需要任何额外工具。这篇文章就把模糊测试、基准测试、竞争条件检测这三个"测试进阶"都讲清楚。

模糊测试（Fuzzing）

模糊测试的思路：给测试函数一个种子输入，然后让 Go 自动生成各种变体，寻找能触发 panic 或错误的边界情况。

// parser_test.go
package parser

import (
    "testing"
    "unicode/utf8"
)

// 被测函数：解析简单的 key=value 格式
func ParseKV(input string) (map[string]string, error) {
    result := make(map[string]string)
    if len(input) == 0 {
        return result, nil
    }

    // 这里有个潜在的 bug：没有处理 UTF-8 边界
    for i := 0; i < len(input); {
        // 找到下一个 '='
        eqPos := -1
        for j := i; j < len(input); j++ {
            if input[j] == '=' {
                eqPos = j
                break
            }
        }
        if eqPos == -1 {
            break
        }

        key := input[i:eqPos]

        // 找到下一个 '\n' 或结束
        nlPos := len(input)
        for j := eqPos + 1; j < len(input); j++ {
            if input[j] == '\n' {
                nlPos = j
                break
            }
        }

        value := input[eqPos+1 : nlPos]
        result[key] = value
        i = nlPos + 1
    }
    return result, nil
}

// 普通单元测试
func TestParseKV(t *testing.T) {
    tests := []struct {
        input string
        want  map[string]string
    }{
        {"name=alice\nage=30", map[string]string{"name": "alice", "age": "30"}},
        {"", map[string]string{}},
        {"key=value", map[string]string{"key": "value"}},
    }

    for _, tt := range tests {
        got, err := ParseKV(tt.input)
        if err != nil {
            t.Errorf("ParseKV(%q) error: %v", tt.input, err)
            continue
        }
        if len(got) != len(tt.want) {
            t.Errorf("ParseKV(%q) = %v, want %v", tt.input, got, tt.want)
        }
    }
}

// 模糊测试：让 Go 自动生成输入寻找 bug
func FuzzParseKV(f *testing.F) {
    // 添加种子语料库（模糊测试的起点）
    f.Add("name=alice\nage=30")
    f.Add("")
    f.Add("key=value")
    f.Add("=empty_key")
    f.Add("no_equals_sign")

    f.Fuzz(func(t *testing.T, input string) {
        // 模糊测试的核心约束：
        // 1. 不应该 panic
        // 2. 如果返回了结果，结果应该满足某些不变量

        result, err := ParseKV(input)
        if err != nil {
            // 允许返回 error，但不能 panic
            return
        }

        // 不变量检查：所有的 key 都应该是有效的 UTF-8
        for k := range result {
            if !utf8.ValidString(k) {
                t.Errorf("ParseKV returned non-UTF8 key: %q", k)
            }
        }
    })
}

运行模糊测试：

# 运行一次（只执行种子语料库，适合 CI）
go test -run FuzzParseKV ./...

# 真正开始模糊（持续生成新输入，直到找到 bug 或手动停止）
go test -fuzz FuzzParseKV -fuzztime=60s ./...

# 发现 bug 后，Go 会在 testdata/fuzz/FuzzParseKV/ 里保存触发 bug 的输入
# 之后 go test 会自动把这些案例加入回归测试

基准测试（Benchmark）

// string_ops_test.go
package stringops

import (
    "bytes"
    "fmt"
    "strings"
    "testing"
)

// 被测函数：字符串拼接的几种方式
func ConcatWithPlus(parts []string) string {
    result := ""
    for _, p := range parts {
        result += p // 每次都分配新字符串，O(n²)
    }
    return result
}

func ConcatWithBuilder(parts []string) string {
    var sb strings.Builder
    for _, p := range parts {
        sb.WriteString(p)
    }
    return sb.String()
}

func ConcatWithJoin(parts []string) string {
    return strings.Join(parts, "")
}

func ConcatWithBuffer(parts []string) string {
    var buf bytes.Buffer
    for _, p := range parts {
        buf.WriteString(p)
    }
    return buf.String()
}

// 基准测试
func BenchmarkConcatWithPlus(b *testing.B) {
    parts := make([]string, 100)
    for i := range parts {
        parts[i] = fmt.Sprintf("part%d", i)
    }

    b.ResetTimer() // 不把初始化时间计入
    for i := 0; i < b.N; i++ {
        ConcatWithPlus(parts)
    }
}

func BenchmarkConcatWithBuilder(b *testing.B) {
    parts := make([]string, 100)
    for i := range parts {
        parts[i] = fmt.Sprintf("part%d", i)
    }

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        ConcatWithBuilder(parts)
    }
}

func BenchmarkConcatWithJoin(b *testing.B) {
    parts := make([]string, 100)
    for i := range parts {
        parts[i] = fmt.Sprintf("part%d", i)
    }

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        ConcatWithJoin(parts)
    }
}

func BenchmarkConcatWithBuffer(b *testing.B) {
    parts := make([]string, 100)
    for i := range parts {
        parts[i] = fmt.Sprintf("part%d", i)
    }

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        ConcatWithBuffer(parts)
    }
}

// 带内存分配统计的基准测试
func BenchmarkJSONMarshal(b *testing.B) {
    data := struct {
        Name  string
        Age   int
        Items []string
    }{
        Name:  "Alice",
        Age:   30,
        Items: []string{"a", "b", "c", "d", "e"},
    }

    b.ReportAllocs() // 报告每次操作的内存分配次数和字节数
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = data
        // json.Marshal(data)
    }
}

// 表格驱动的基准测试（测试不同 input size）
func BenchmarkSort(b *testing.B) {
    sizes := []int{10, 100, 1000, 10000}
    for _, size := range sizes {
        b.Run(fmt.Sprintf("size=%d", size), func(b *testing.B) {
            data := make([]int, size)
            for i := range data {
                data[i] = size - i // 逆序数据，最坏情况
            }
            b.ResetTimer()
            for i := 0; i < b.N; i++ {
                b.StopTimer()
                tmp := make([]int, len(data))
                copy(tmp, data)
                b.StartTimer()
                // sort.Ints(tmp)
            }
        })
    }
}

运行基准测试：

# 运行基准测试（-bench 后是正则匹配）
go test -bench=. -benchmem ./...

# 只跑 Concat 相关的
go test -bench=BenchmarkConcat -benchmem -count=3 ./...

# 使用 benchstat 比较两次结果（需要安装 golang.org/x/perf/cmd/benchstat）
go test -bench=. -count=10 ./... > before.txt
# 修改代码后
go test -bench=. -count=10 ./... > after.txt
benchstat before.txt after.txt

竞争条件检测（Race Detector）

// cache_test.go
package cache

import (
    "sync"
    "testing"
)

// 这个 Cache 实现有竞争条件
type UnsafeCache struct {
    data map[string]string
}

func (c *UnsafeCache) Get(key string) (string, bool) {
    v, ok := c.data[key] // 并发读写 map，竞争条件！
    return v, ok
}

func (c *UnsafeCache) Set(key, value string) {
    c.data[key] = value // 并发读写 map，竞争条件！
}

// 修复后的实现
type SafeCache struct {
    mu   sync.RWMutex
    data map[string]string
}

func (c *SafeCache) Get(key string) (string, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    v, ok := c.data[key]
    return v, ok
}

func (c *SafeCache) Set(key, value string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.data[key] = value
}

// 竞争条件测试
func TestUnsafeCacheRace(t *testing.T) {
    cache := &UnsafeCache{data: make(map[string]string)}

    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(2)
        key := fmt.Sprintf("key%d", i)
        go func() {
            defer wg.Done()
            cache.Set(key, "value")
        }()
        go func() {
            defer wg.Done()
            cache.Get(key)
        }()
    }
    wg.Wait()
}

func TestSafeCacheRace(t *testing.T) {
    cache := &SafeCache{data: make(map[string]string)}

    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(2)
        i := i
        go func() {
            defer wg.Done()
            cache.Set(fmt.Sprintf("key%d", i), "value")
        }()
        go func() {
            defer wg.Done()
            cache.Get(fmt.Sprintf("key%d", i))
        }()
    }
    wg.Wait()
}

运行竞争检测：

# 开启竞争检测（性能会下降 2-20 倍，但能发现并发 bug）
go test -race ./...

# 竞争检测输出示例
# ==================
# WARNING: DATA RACE
# Write at 0x00c0001a4000 by goroutine 7:
#   main.(*UnsafeCache).Set()
#       /path/to/cache.go:15 +0x44
#
# Previous read at 0x00c0001a4000 by goroutine 8:
#   main.(*UnsafeCache).Get()
#       /path/to/cache.go:10 +0x38
# ==================