[TOC]

单元测试要求

因为golang语言设计，偏向工程性，故go 单元测试对文件名和方法名，参数都有很严格的要求

1. 测试文件名必须以xx_test.go命名
2. 测试方法必须是 Test[^a-z] 开头
3. 测试方法参数必须 t *testing.T

因为这种严格要求，故golang的单元测试写作规约是

1. 单元测试文件放置在同包目录中
2. 单元测试文件一般为，被测试文件_test.go
3. 如有额外需求，则追加中缀 如 被测试文件_instance_test.go
4. 测试文件内容中，除测试工具外，尽量保证不引入当前工程库，保证单元粒度

常用单元测试方法

• 快速测试

go test
# 让运行时间较长的测试用例运行时间缩短
go test -test.short
go test -v
# -test.v 是输出全部结果，无论成功失败，这里是测试当前目录下所有的测试用例
go test -test.v

测试当前目录下所有的测试用例，只输出错误的用例

# 输出全部结果 只测试 [代码]_test.go 内的用例
go test -test.v [代码].go [代码]_test.go
# 输出全部结果，-test.run 正则，是只执行当前
go test -test.v -test.run [pattern] [代码].go [代码]_test.go

go test 命令详解

命令格式

go test [-c] [-i] [build flags] [packages] [flags for test binary]

参数翻译

-c : 编译go test成为可执行的二进制文件，但是不运行测试
-i : 安装测试包依赖的package，但是不运行测试
    关于 build flags，调用go help build，这些是编译运行过程中需要使用到的参数，一般设置为空
    关于 packages，调用go help packages，这些是关于包的管理，一般设置为空
    关于 flags for test binary，调用go help testflag，这些是go test过程中经常使用到的参数

-test.v : 是否输出全部的单元测试用例（不管成功或者失败），默认没有加上，所以只输出失败的单元测试用例
-test.short : 将那些运行时间较长的测试用例运行时间缩短
-test.run pattern: 只跑哪些单元测试用例
-test.bench patten: 只跑那些性能测试用例
-test.benchmem : 是否在性能测试的时候输出内存情况
-test.benchtime t : 性能测试运行的时间，默认是1s
-test.cpuprofile cpu.out : 是否输出cpu性能分析文件
-test.memprofile mem.out : 是否输出内存性能分析文件
-test.blockprofile block.out : 是否输出内部goroutine阻塞的性能分析文件

-test.memprofilerate n : 内存性能分析的时候有一个分配了多少的时候才打点记录的问题
这个参数就是设置打点的内存分配间隔，也就是profile中一个sample代表的内存大小
默认是设置为512 * 1024
如果你将它设置为1，则每分配一个内存块就会在profile中有个打点，那么生成的profile的sample就会非常多
如果你设置为0，那就是不做打点了
你可以通过设置memprofilerate=1和GOGC=off来关闭内存回收，并且对每个内存块的分配进行观察

-test.blockprofilerate n: 基本同上，控制的是goroutine阻塞时候打点的纳秒数。
默认不设置就相当于 `-test.blockprofilerate=1`，每一纳秒都打点记录一下

-test.parallel n : 性能测试的程序并行cpu数，默认等于GOMAXPROCS

-test.timeout t : 如果测试用例运行时间超过t，则抛出panic
-test.cpu 1,2,4 : 程序运行在哪些CPU上面，使用二进制的1所在位代表，和nginx的nginx_worker_cpu_affinity是一个道理

setup 和 teardown

setup 和 teardown 是在每个 case 执行前后都需要执行的操作
该操作默认使用函数 TestMain 写作，并且默认不实现
所以需要对每组用例合辑自行实现，例如

func TestMain(m *testing.M) {
    // setup
    os.Exit(m.Run())
    // teardown
}

注意，一个包中，只能有一个 TestMain

测试断言工具

golang 的官方 testing 包中包含断言工具

func TestPrint(t *testing.T) {
    // 输出测试日志
    t.Logf()
    // 标记错误，但仍然执行后面的语句
    t.Fail()
    // 获取是否当前用例是执行错误的
    t.Failed()
    // 错误输出，等于 t.Logf 再执行 t.Fail()
    t.Errorf("%s", "run ErrorF")
    // 标记函数错误，并中断后面的执行
    t.FailNow()
    // 致命错误输出，等同于调用了 t.Logf 然后调用 t.FailNow()
    t.Fatalf("%s", "run Fatelf")
}

其他常用函数

// 获取测试用例名称
t.Name()
// 运行子测试用例
t.Run()
// 跳过后面的内容，后面将不再运行
t.SkipNow()
// 告知当前的测试是否已被忽略
t.Skipped()
// 并行测试
t.Parallel()

测试用例统计

goconvey

非常好用的三方测试覆盖统计工具

http://goconvey.co/
https://github.com/smartystreets/goconvey

go get -v github.com/smartystreets/goconvey

编译后，使用命令行工具在工程目录下运行

goconvey

goland-convey-live-template

let tabs and indents in go all to 2

• Template text:

func Test$TestName$(t *testing.T) {
  convey.Convey("mock Test$TestName$", t, func() {
    // mock
    $END$
    convey.Convey("do Test$TestName$", func() {
      // do
      convey.Convey("verify Test$TestName$", func() {
        // verify
        convey.So("", convey.ShouldEqual, "")
      })
    })
  })
}

or

func Test$TestName$(t *testing.T) {
  convey.Convey("Test$TestName$", t, func() {
    // mock
    $END$
    // do
    // verify
    convey.So("", convey.ShouldEqual, "")
  })
}

if use default tabs and indents in go

func Test$TestName$(t *testing.T) {
    convey.Convey("mock Test$TestName$", t, func() {
        // mock
        $END$
        convey.Convey("do Test$TestName$", func() {
            // do
            convey.Convey("verify Test$TestName$", func() {
                // verify
                convey.So("", convey.ShouldEqual, "")
            })
        })
    })
}

带有时间限制的测试

一种测试场景，在一个测试函数包含一段了耗时较长的代码，并且需要严格规定执行这个测试函数的耗时上限

在执行 go test 命令时加入标记 -timeout，且在达到其值所代表的时间上限时测试还未结束，那么就会引发一个运行时恐慌

-timeout 标记的值是类型 time.Duration 可以接受的时间表示法

例如，1h20s代表1小时20秒，2h45m 代表2小时45分钟，200ms代表200毫秒

如果只是想让测试尽快结束，使用 -short 标记意味着之后要运行的测试尽量缩短它们的运行时间。

代码包 testing 中有一个名为 Short() 的函数
这个函数在被调用后会返回一个类型 bool 的值。这个值表明了是否在执行 go test 命令的时候加入了 -short 标记
如果这个函数返回的 bool 值为 true , 那么就可以根据具体情况，去剪裁测试代码从而缩短测试运行时间

if testing.Short() {
    testCase(serverAddr, "SenderT", 1, (2 * time.Second), isShowLog)
} else {
    testCase(serverAddr, "SenderT1", 2, (2 * time.Second), isShowLog)
    testCase(serverAddr, "SenderT2", 1, (2 * time.Second), isShowLog)
}

并发测试

parallel标记

-parallel 标记默认使用Go语言最大并发处理数

• 功能：设置可并发执行的功能测试函数的最大数量
• 默认值：调用runtime.GOMAXPROCS(0)后的结果，即Go语言最大并发处理数量
• 先决条件：功能测试函数需要在开始处调用结构体testing.T类型的参数值的Parallel方法
• 生效的测试：功能测试

cpu标记

go test 命令还可以接受一个可自定义测试运行次数并在测试运行期间改变Go语言最大并发处理数的标记 -cpu

-cpu 标记可以是一个整数列表，多个整数之间用逗号分隔，例如 -cpu 1,2,4

• 功能：根据标记的值，迭代的设置Go语言并发处理最大数并执行全部功能测试或全部基准测试。迭代的次数与标记值中的整数个数一致
• 默认值：""，即空字符串
• 先决条件：无
• 生效的测试：功能测试和基准测试

-cpu 标记的处理方式和 -parallel 标记相反, -cpu 标记却会直接设置它
但由 -cpu 标记引发的Go语言最大并发处理数的设置操作并不会影响 -parallel 标记的默认值

因为 -parallel 标记的值是在测试运行程序初始化的时候设置的。如果在 go test 命令中没有显式地加入 -parallel 标记，则它的值会被设置为测试运行程序初始化时刻的Go语言最大并发处理数。在这个时刻，测试程序运行还没有把 -cpu 标记的值（如果有的话）解析成整数数组，也就无法使用这个数组中的整数设置Go语言最大并发处理数了。

基准测试

基准测试（Benchmark Test，简称BMT）是指，通过一些科学的手段实现对一类测试对象的某项性能指标进行可测量、可重复和可比对的测试。
很多时候，基准测试已被狭义地称为性能测试

基准测试函数要求

1. 测试文件名必须以xx_test.go命名
2. 测试方法必须是 Benchmark[^a-z] 开头
3. 测试方法参数必须 b *testing.B

基准测试计时器

定时器相关的方法有3个
它们是 StartTimer、StopTimer 和 ResetTimer

• b.StartTimer() 对当前的测试函数的执行进行计时
  这个方法被暴露出来的意义在于：计时器在被停止之后重新启动

StartTimer() 总会在开始执行基准测试函数的时候被自动地调用

• b.StopTimer() 使当前测试函数的计时器停止

• b.ResetTimer() 使当前测试函数的计时器重置计时
  就是把该函数的执行时间重置为 0，这相当于把当前函数中在 b.ResetTimer 语句之前的所有语句的执行时间都从该函数的执行时间中减去

内存分配统计

方法 b.ReportAllocs() 的含义是判断在启动当前测试的 go test 命令的后面是否有 -benchmem 标记
它会返回一个 bool 类型的结果值

方法 b.SetBytes() 接受一个 int64 类型的值，它被用于记录在单次操作中被处理的字节的数量
改方法能够从输入输出（IO）的角度统计出被测试的程序实体的实际性能

基准测试的运行

go test 命令后加入基准测试的标记即可

-bench regexp
在默认情况下，go test命令不会运行任何基准测试，但可以使用该标记以执行匹配“regexp”处的
正则表达式的基准测试函数，regexp可以被替换成任何正则表达式。
如果需要运行所有的基准测试函数，添加 –bench . 或 –bench=. 或 –bench="."

-benchmem
在输出内容中包含基准测试的内存分配统计信息

-benchtime t
间接地控制单个基准测试函数的操作次数
这里的t指的是执行单个测试函数的累积耗时上限
t的默认值是1s
t处的内容使用的是类型time.Duration可接受的时间表示法

基准测试报告分析

• op 操作次数 是当前的基准测试函数被执行的次数
• B/op 每次操作分配的字节的平均数
• ns/op操作平均耗时 是当前基准测试函数的平均执行时间
• MB/s 函数每秒能向系统写入多少兆字节( MB )的数据
• allocs/op 每次操作分配内存的次数