Go 单元测试与基准测试

在 Go 语言中,标准库直接内置了 testing 包和 go test 命令。我们不需要安装任何第三方测试框架,就能编写自动化的 “单元测试(Unit Test)” 与 “基准测试(Benchmark)”。

其中,单元测试用来检验函数或方法的计算结果 “对不对”,防止修改代码时改坏原有功能。基准测试则用来测量代码的运行速度 “快不快” 以及内存开销大不大,方便我们评估程序性能。

编写第一个单元测试

所谓的 “单元测试”,就是针对单个函数或方法编写的自动化检验代码。我们可以把它看作流水线上的 “自动质检仪”:提前把输入和期望结果写进测试文件,以后每次改完代码只需执行 go test,程序就会自动核对结果并反馈通过(PASS)或失败(FAIL)。

Go 单元测试的自动检验机制

在 Go 语言中编写单元测试,我们需要遵循以下 3 条基本规则:

  • 测试文件名必须以 _test.go 结尾:测试文件通常和被测源码文件放在同一个包目录下,比如被测文件叫 calc.go,对应的测试文件就命名为 calc_test.go。
  • 测试函数名必须以 Test 开头:函数名格式为 TestXxx,其中 Test 后面的第一个字符不能是小写字母,一般直接拼上被测函数名,如 TestAdd。
  • 参数固定为 (t *testing.T):测试函数没有返回值,只接收一个 *testing.T 类型的指针参数 t,用来记录测试状态与失败信息。

语法:

func TestXxx(t *testing.T) {
    // 调用被测函数并比对结果
}

说明:

在测试函数内部,我们先调用被测函数拿到实际结果,再与期望结果进行比对。如果实际结果符合预期,函数正常执行结束就代表测试通过。如果结果不符合预期,就调用 t.Errorf() 输出错误原因,此时 go test 会将该测试标记为失败。

由于单元测试涉及多个文件配合,小伙伴们需要在本地环境中运行。我们先新建一个 calc 文件夹,在该目录的终端中执行 go mod init calc 初始化 Go Modules,随后创建 calc.go 和 calc_test.go 两个文件,目录结构如下:

calc/
├── go.mod
├── calc.go
└── calc_test.go

这里我们将包名定为 calc 来演示一个独立的工具包。如果在平时的 package main 项目中编写测试,做法也完全一样,只需要保证测试文件与被测源码文件位于同一目录、顶部包名一致即可。

示例 1:编写并运行单元测试

首先编写源码文件 calc.go,声明包名为 calc 并定义一个加法函数:

package calc

// 计算两个整数之和
func Add(a, b int) int {
    return a + b
}

接着在同一个目录下编写测试文件 calc_test.go:

package calc

import "testing"

func TestAdd(t *testing.T) {
    got := Add(10, 20)    // 实际计算结果
    want := 30            // 期望正确结果
    if got != want {
        t.Errorf("Add(10, 20) = %d,期望得到 %d", got, want)
    }
}

保存文件后,在 calc 目录的终端中执行 go test -v 命令,运行结果如下。

=== RUN   TestAdd
--- PASS: TestAdd (0.00s)
PASS
ok      calc    0.002s

分析:

在这个例子中,calc_test.go 和 calc.go 位于同一个自定义包下(包名均为 calc),因此测试代码可以直接调用同包内的 Add() 函数。

按照 Go 社区的习惯,我们通常将实际算出的结果命名为 got(得到的值),将标准答案命名为 want(想要的值)。这里 Add(10, 20) 返回的 30 与 want 相等,没有触发 t.Errorf(),因此终端输出 PASS 代表测试通过。

命令中的 -v 参数是英文 “verbose(详细)” 的缩写。如果不加 -v 直接运行 go test,终端只会在最后输出汇总结果。加上 -v 后,则会把每个测试函数的名字、通过状态和耗时都详细打印出来。

对于这个例子来说,如果后续修改代码时不小心把 calc.go 里的 a + b 写成了 a - b,再次执行 go test -v 命令,此时运行结果如下。

=== RUN   TestAdd
    calc_test.go:9: Add(10, 20) = -10,期望得到 30
--- FAIL: TestAdd (0.00s)
FAIL
FAIL    calc    0.002s

一旦实际结果与期望值不一致,t.Errorf() 就会打印报错信息,并明确指出是 calc_test.go 的第 9 行未通过,方便我们第一时间定位问题。

另外,报告测试失败除了使用 t.Errorf() 之外,也可以使用 t.Fatalf()。两者的区别在于:t.Errorf() 记录错误后会继续执行当前测试函数剩余的代码,而 t.Fatalf() 记录错误后会立即终止当前测试函数。

在本地反复练习时,大家还会注意到一个细节:如果没有修改任何代码,连续执行两次 go test,第 2 次输出结果末尾会出现 (cached) 标记。这是因为 Go 默认会缓存已通过的测试结果来提速。如果我们想跳过缓存强制重新运行,只需加上 -count=1 参数(即 go test -count=1)即可。

注意:

  • 文件名后缀不能写反:测试文件必须以 _test.go 结尾,如 calc_test.go。如果起名为 test_calc.go,go test 命令会将其当成普通源码文件而忽略。
  • Test 后面紧跟的字符不能是小写字母:测试函数必须写成 func TestAdd(t *testing.T)。如果误写成小写 func Testadd(t *testing.T),go test 不会执行该函数。

表格驱动测试

在示例 1 中,我们只测试了 10 + 20 这一组数据。但在实际开发中,测试一个函数通常需要同时覆盖正数、负数、零以及边界值等多组数据。如果每测一组数据都复制粘贴一遍 if got != want,代码就会变得非常啰嗦。

针对这种情况,Go 语言官方推荐采用 “表格驱动测试(Table-Driven Tests)”:先把多组测试数据装进结构体切片里,再在循环中调用 t.Run() 依次执行每一组子测试。

语法:

t.Run(子测试名称, func(t *testing.T) {
    // 单组数据的测试逻辑
})

说明:

t.Run() 的第 1 个参数是当前子测试的名称(string 类型),第 2 个参数是一个接收 t *testing.T 的匿名函数。每调用一次 t.Run(),测试框架就会启动一个独立的子测试,单独统计并展示该组数据的通过状态。

示例 2:使用表格驱动测试

我们将 calc_test.go 文件修改为如下内容,一次性验证 4 组不同的测试数据:

package calc

import "testing"

func TestAddTable(t *testing.T) {
    // 定义单组测试用例的结构体
    type testCase struct {
        name string
        a    int
        b    int
        want int
    }

    // 准备多组测试数据
    tests := []testCase{
        {name: "正数相加", a: 10, b: 20, want: 30},
        {name: "正负抵消", a: -5, b: 5, want: 0},
        {name: "全零相加", a: 0, b: 0, want: 0},
        {name: "负数相加", a: -10, b: -20, want: -30},
    }

    // 循环遍历并启动独立子测试
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            got := Add(tc.a, tc.b)
            if got != tc.want {
                t.Errorf("得到 %d,期望 %d", got, tc.want)
            }
        })
    }
}

在终端中执行 go test -v 命令,运行结果如下。

=== RUN   TestAddTable
=== RUN   TestAddTable/正数相加
=== RUN   TestAddTable/正负抵消
=== RUN   TestAddTable/全零相加
=== RUN   TestAddTable/负数相加
--- PASS: TestAddTable (0.00s)
    --- PASS: TestAddTable/正数相加 (0.00s)
    --- PASS: TestAddTable/正负抵消 (0.00s)
    --- PASS: TestAddTable/全零相加 (0.00s)
    --- PASS: TestAddTable/负数相加 (0.00s)
PASS
ok      calc    0.002s

分析:

上面的代码先定义了 testCase 结构体来表示单条测试记录,随后在 tests 切片里列出了 4 组不同场景的测试数据。

循环遍历时,t.Run() 为每一组数据都启动了一个独立的子测试。运行 go test -v 后,每组用例的名称都会像 TestAddTable/正数相加 这样单独列出来。一旦某一组未通过,我们马上就能定位是哪种情况出了错,后续补充新用例也只需往切片里多加一行数据。

在实际开发中,由于 testCase 结构体只在当前函数内部使用一次,很多开发者也会将其简写为匿名结构体切片。对于上面定义 tests 的代码来说,下面 2 种写法是等价的。

// 写法 1
type testCase struct {
    name       string
    a, b, want int
}
tests := []testCase{
    {"正数相加", 10, 20, 30},
    {"正负抵消", -5, 5, 0},
}

// 写法 2
tests := []struct {
    name       string
    a, b, want int
}{
    {"正数相加", 10, 20, 30},
    {"正负抵消", -5, 5, 0},
}

其中,写法 1 先单独定义结构体类型再初始化切片,层次分明。写法 2 直接声明并初始化了匿名结构体切片,省去了单独起类型名的步骤,小伙伴们平时编写测试时按个人习惯选用即可。

基准性能测试(Benchmark)

除了检验结果 “对不对” 的单元测试之外,testing 包还支持测量函数运行 “快不快” 的基准性能测试(Benchmark)。基准测试同样编写在 _test.go 文件中,非常适合用来横向对比两种写法的性能差距。

语法:

func BenchmarkXxx(b *testing.B) {
    for i := 0; i < b.N; i++ {
        // 调用被测函数
    }
}

说明:

基准测试的函数名必须以 Benchmark 开头,参数固定为 b *testing.B。在函数体内部,我们需要将待测代码放进 for i := 0; i < b.N; i++ 循环中。

这里的循环次数 b.N 不需要我们手动指定。测试框架会在运行期间自动调整 b.N 的大小,让被测代码反复执行足够多的次数,从而算出稳定的单次平均耗时。

示例 3:对比两种字符串拼接的性能

前面学习字符串拼接时,我们说过循环拼接字符串推荐使用 strings.Builder 而不是加号 +。下面我们在 calc_test.go 文件末尾追加两个基准测试函数,用实测数据直观对比两者的速度和内存开销。记得先在文件顶部 import 中补充 "strings",代码如下:

func BenchmarkJoinPlus(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := ""
        for j := 0; j < 100; j++ {
            s += "go"
        }
    }
}

func BenchmarkJoinBuilder(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var sb strings.Builder
        for j := 0; j < 100; j++ {
            sb.WriteString("go")
        }
        _ = sb.String()
    }
}

默认情况下,直接执行 go test 只会运行单元测试,不会运行基准测试。我们在终端执行 go test -bench=. -benchmem 命令,同时测量运行速度与内存分配情况,运行结果如下。

goos: windows
goarch: amd64
pkg: calc
cpu: Intel(R) Core(TM) i7-12700
BenchmarkJoinPlus-8          238920      4862 ns/op     10752 B/op     99 allocs/op
BenchmarkJoinBuilder-8      3415820       348 ns/op       504 B/op      6 allocs/op
PASS
ok      calc    3.124s

分析:

执行 go test -bench=. -benchmem 时,程序会先自动跑一遍当前包下的单元测试,确认逻辑无误后再开始基准测试。输出结果里每行关键数据包含以下 4 项指标:

  • BenchmarkJoinPlus-8:基准测试函数名,末尾的 -8 表示本次测试使用的 CPU 逻辑核数。
  • 238920 / 3415820:循环执行的总次数,也就是 b.N 最终调整到的数值。
  • ns/op:单次操作的平均耗时(纳秒)。可以看到 strings.Builder 仅需约 348 纳秒,比 + 号拼接的 4862 纳秒快了十几倍。
  • B/op 与 allocs/op:由 -benchmem 参数开启,分别代表每次操作平均分配了多少字节内存以及触发了多少次内存分配。用 + 号拼接 100 次触发了 99 次内存分配,而 strings.Builder 仅分配了 6 次,差距一目了然。

此外,有时基准测试在正式计时前需要先准备一批测试数据,比如初始化一个包含一万条记录的切片。这时我们可以在数据准备好后、进入 for i := 0; i < b.N; i++ 循环前调用一次 b.ResetTimer() 重置计时器,这样准备数据的耗时就不会算进测试结果里了。

在实际开发中,运行 go test 的常用命令如下表所示。

go test 常用命令
命令 说明
go test 运行当前包下所有单元测试
go test ./... 运行当前项目及所有子包测试
go test -v 详细打印每个测试名称与耗时
go test -run TestAdd 仅运行名称匹配的指定测试
go test -cover 运行测试并统计代码覆盖率
go test -count=1 跳过缓存强制重新运行测试
go test -bench=. -benchmem 运行基准测试并统计内存分配

常见问题

1. 项目里写了这么多 _test.go 测试文件,打包发布时会让程序体积变大吗?

不会。平时我们使用 go build 命令编译正式的可执行程序时,编译器会自动忽略所有以 _test.go 结尾的文件,只有执行 go test 命令时它们才会参与编译和运行。

2. 为什么基准测试要写 i < b.N 循环,不能自己固定循环 100 万次吗?

因为不同函数的执行速度相差很大。简单的整数加法跑 100 万次还不到 1 毫秒,容易受系统瞬时波动影响导致测不准。而复杂的文件或字符串操作跑 100 万次可能要等好几分钟。交给 b.N 自动调节循环次数,测试框架就能把测试时长控制在 1 秒左右,测出准确稳定的单次耗时。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号