golang 单元测试、基准测试、子测试、并发测试基础教程
一、go test基础
用法: go test [build/test flags] [packages] [build/test flags & test binary flags]
Go test 会自动测试由导入路径命名的软件包。并以下格式打印测试结果的摘要：
ok archive/tar 0.011s
FAIL archive/zip 0.022s
ok compress/gzip 0.033s
...
Go test 会重新编译每个软件包以及名称匹配的所有文件名形如 * _test.go 的测试文件。这些文件可以包含测试函数，基准测试函数和示例函数(test functions, benchmark functions, example functions)。更多有关信息，请参见“ go help testfunc”。
每个列出的包都执行单独的测试二进制文件。其中名称以“_”（包括“_test.go”）或“.”开头的文件将被忽略。而后缀为“_test”的测试文件将被编译为单独的程序包，并与主测试文件链接并执行。
go工具将忽略名为“testdata”的目录，该目录可用来存放测试所需的辅助数据。
作为构建测试二进制文件的一部分，go test 会对软件包及其测试文件执行run vet,用于检测其中是否存在重大问题。如果执行go vet阶段发现任何问题，会直接报告这些问题，并且不运行测试文件。检查内容只包括go vet检查的一个子集，包括：'atomic', 'bool', 'buildtags', 'errorsas',
'ifaceassert', 'nilfunc', 'printf', and 'stringintconv'。可以通过“go doc cmd/vet”查看 vet检查的相关文档。如果要禁用go vet的运行，请使用-vet=off标志。
所有测试输出和摘要行都打印到go命令的标准输出，即使测试将其打印为自己的标准错误。(go命令的标准错误保留用于打印建立测试时出错)。
Go test 以两种不同的模式运行：
第一种称为本地目录模式，执行go test时无需指定package参数调用（例如，“go test”或“go test -v'）。在这种模式下，go test会编译当前包，然后在当前目录中找到测试用例。缓存（如下所述）会被被禁用。包测试完成后，去打印摘要行显示测试状态（“ok”或“FAIL”），软件包名称和使用时间。
第二种称为包列表模式，在调用go test时需要明确package参数（例如“go test math”，“go test./...”，或者“go test .”）。在这种模式下，将编译并测试命令行上列出的每个软件包。如果一个包测试通过，仅打印最终的“ok”摘要。如果包测试失败，则打印完整的测试输出。如果使用-bench或-v标志调用，则go test会打印完整的输出(包括通过测试的包)，以显示要求的基准测试结果或详细的日志记录。在所有待测试包全部测试完毕，同时测试结果打印完成后，如果有任何一个测试未通过，则最后会打印一个’FAIL‘。
在第二种运行模式下，go test会缓存成功的包测试结果，以避免不必要的重复测试。当测试结果可以从缓存恢复时，执行go test将显示先前的测试结果。当发生这种情况时，结果将输出（cached）代替测试执行时间这一参数。
二、准备
接下来，将通过一个个例子说明单元测试、基准测试、子测试、并发测试到底该如何写，在此之前，我们需要先准备一个待测试的小功能。这里，我们以一个对全局map变量执行增删改查的功能为例，开发对应的测试代码。具体如下：
var Cash = make(map[string]string)
func Add(key,value string){
if _,ok := Cash[key];!ok{
Cash[key] = value
}
}
func Delete(key string){
if _,ok := Cash[key];ok{
delete(Cash,key)
}
}
func Update(key,value string){
Cash[key] = value
}
func Get(key string) string{
if v,ok := Cash[key];ok{
return v
}
return ""
}
func Clean(){
Cash = make(map[string]string)
}
这里我们可以没有为Cash变量添加锁机制，目的是为了在验证阶段通过并发测试找出这个’bug‘。另外，还额外提供了一个Clean()方法，用于清空变量的内容。
三、单元测试
单元测试是最简单，也是最基本的测试。例如，我们想要测试add和get功能是否正常，通常我们会这样写。
func TestAddAndGet(t *testing.T){
Add("a","aa")
fmt.Println(Get("a"))
}
这是最基本的测试方法，但是效率太低，同时需要开发者自己去判断结果是否正确。通常会通过Table-driven的方式实现这种简单重复的测试内容，我们可以按批次执行测试，并通过程序化的方式验证测试结果，具体如下：
func TestAdd(t *testing.T){
var addTests = []struct{
key string
value string
expected int
}{
{"a","aa",1},
{"b","bb",2},
{"c","cc",3},
{"c","cc",3},
{"c","cc",3},
{"d","dd",4},
{"e","ee",5},
{"f","ff",6},
{"g","gg",7},
{"h","hh",8},
{"i","ii",9},
{"j","jj",10},
}
quary := rand.Int()
for _,v := range addTests{
Add(v.key,v.value)
t.Logf("[goroutine:%d] add %s:%s",quary,v.key,v.value)
if len(Cash) != v.expected{
t.Errorf("add %s:%s len = %d; except %d",v.key,v.value,len(Cash),v.expected)
}
}
Clean()
}
如果某次插入操作出现异常会返回错误信息：
=== RUN TestAdd
basic_test.go:48: add d:dd len = 4; except 4
--- FAIL: TestAdd (0.00s)
FAIL
四、基准测试
基准测试，通常也被成为压测Benchmark。压测通常会自动的顺序执行多次，然后返回平均的压测参数。例如我们测试get方法的性能：
func BenchmarkGet(b *testing.B) {
b.Log("start")
var addTests = []struct{
key string
value string
expected int
}{
{"a","aa",1},
{"b","bb",2},
{"c","cc",3},
{"c","cc",3},
{"c","cc",3},
{"d","dd",4},
{"e","ee",5},
{"f","ff",6},
{"g","gg",7},
{"h","hh",8},
{"i","ii",9},
{"j","jj",10},
}
for _,v := range addTests{
Add(v.key,v.value)
}
//启动内存统计
b.ReportAllocs()
//重新计时
b.ResetTimer()
for i:=0;i测试结果为：
goos: darwin
goarch: amd64
pkg: test-learn
BenchmarkGet
basic_test.go:185: start
basic_test.go:185: start
basic_test.go:185: start
basic_test.go:185: start
basic_test.go:185: start
BenchmarkGet-12 2162974 546 ns/op 496 B/op 5 allocs/op
PASS
通过分析测试结果可知，测试流程共计执行5次，测试结果为平均值。benchmark允许自定义测试计时的起止时间，默认测试代码启动开始计时，测试结束停止计时。在本例中，由于我们想要测试get方法性能，因此排除前期数据插入时间。性能参数会更加准确，因此我们通过b.ResetTimer()初始化了计时器开始的时间。
如果我们关注的流程在测试代码前半段时呢？testing包提供了更加灵活的手动计时功能。
b.StartTimer()
b.StopTimer()
此外，testing支持内存统计功能，b.ReportAllocs()相当于在 go test 时添加-benchmem 标识。
2162974 ：基准测试的迭代总次数 b.N
546 ns/op：平均每次迭代所消耗的纳秒数
496 B/op：平均每次迭代内存所分配的字节数
5 allocs/op：平均每次迭代的内存分配次数
五、并发测试
执行并发测试有两种方式，一种是单元并发测试，另一种是基准并发测试。接下来我们将对两种并发测试方式分别进行介绍。再次之前我们需要先介绍一下 t.Parallel() 参数，该参数指明当前测试用例可与其他可并行执行的测试用例一起运行，仅仅声明了测试用例的属性，并不会真的去完成并发测试。
1、可并发执行的测试用例
为了更清楚的说明可并发执行t.Parallel() 属性的意义，我们通过以下例子说明。假如我们有两个测试插入数值的测试用例：
func TestCanParallelExecAdd(t *testing.T){
var addTests = []struct{
key string
value string
expected int
}{
{"a","aa",1},
{"b","bb",2},
{"c","cc",3},
{"c","cc",3},
{"c","cc",3},
{"d","dd",4},
{"e","ee",5},
{"f","ff",6},
{"g","gg",7},
{"h","hh",8},
{"i","ii",9},
{"j","jj",10},
}
t.Parallel()
quary := rand.Int()
t.Logf("[goroutine:%d] start",quary)
for _,v := range addTests{
Add(v.key,v.value)
t.Logf("[goroutine:%d] add %s:%s",quary,v.key,v.value)
if len(Cash) != v.expected{
t.Errorf("add %s:%s len = %d; except %d",v.key,v.value,len(Cash),v.expected)
}
}
Clean()
}
func TestCanParallelExecAdd2(t *testing.T){
var addTests = []struct{
key string
value string
expected int
}{
{"a","aa",1},
{"b","bb",2},
{"c","cc",3},
{"c","cc",3},
{"c","cc",3},
{"d","dd",4},
{"e","ee",5},
{"f","ff",6},
{"g","gg",7},
{"h","hh",8},
{"i","ii",9},
{"j","jj",10},
}
t.Parallel()
quary := rand.Int()
t.Logf("[goroutine:%d] start",quary)
for _,v := range addTests{
Add(v.key,v.value)
t.Logf("[goroutine:%d] add %s:%s",quary,v.key,v.value)
if len(Cash) != v.expected{
t.Errorf("add %s:%s len = %d; except %d",v.key,v.value,len(Cash),v.expected)
}
}
Clean()
}
这两个测试用例除了名字，内部实现完全一样，然后我们执行 go test 会返回错误： fatal error: concurrent map read and map write。 如果我们将t.Parallel()注释，或者将其中一个测试用例注释掉，将会通测试。
这是因为两个测试用例都声明了可并发执行，当我们执行go test时，两个测试用例将并发执行，而map不是线程安全的数据结构，因此会爆出异常。
到这里，基准并发测试的实现方式已经十分清晰，但是这需要十分冗余的测试代码，如果想要测试10并发量的测试难道要写10份逻辑一样的测试代码吗？
当然不是，testing包提供了子测试的概念，可以便于我们实现更加复杂的测试逻辑。
2、基于子测试的并发单元测试
子测试是指我们可以在单元测试中启动多个测试用例，具体如下：
func TestParallelAdd1(t *testing.T){
for i:=0;i<10;i++{
t.Run(fmt.Sprintf("g-%d",i), TestAdd)
}
}
我们通过t.run函数，批量启动了10个子测试用例。通过日志我们发现，这10个子测试用例是按顺序执行的，这是因为TestAdd单元测试并不支持并发执行，接下来我们对上述代码做出修改，为子测试用例添加可并发属性。
func TestParallelAdd(t *testing.T){
for i:=0;i<10;i++{
t.Run(fmt.Sprintf("g-%d",i), func(t *testing.T) {
t.Parallel()
TestAdd(t)
})
}
}
再次执行，发生了fatal error: concurrent map writes的异常，测试未通过。
3、并发基准测试
与单元测试不同，基准测试提供了并发测试的方法b.RunParallel，具体如下：
func BenchmarkParallelAdd(b *testing.B) {
b.Log("start")
var process uint32 = 0
var count uint64 = 0
b.SetParallelism(2)
b.RunParallel(func(pb *testing.PB) {
temp := atomic.AddUint32(&process,1)
b.Logf("[goroutine:%d] start",temp)
for pb.Next() {
atomic.AddUint64(&count,1)
// The loop body is executed b.N times total across all goroutines.
b.Logf("[goroutine:%d] count=%d",temp,atomic.LoadUint64(&count))
}
b.Logf("[goroutine:%d] end",temp)
})
}
通过 RunParallel 方法能够并行地执行给定的基准测试。RunParallel会创建出多个 goroutine，并将 b.N 分配给这些 goroutine 执行，其中 goroutine 数量的默认值为 GOMAXPROCS。用户如果想要增加非 CPU 受限（non-CPU-bound）基准测试的并行性，那么可以在 RunParallel 之前调用SetParallelism（如 SetParallelism(2)，则 goroutine 数量为 2*GOMAXPROCS）。RunParallel 通常会与 -cpu 标志一同使用。
六、示例功能
testing还提供了示例功能，一般用于展示某些功能的示例，此外也常用于测试。示例通常以example_test.go命名文件，示例函数通常以ExampleXxx_xxx命名，下划线及其后内容不是必须的。具体如下：
func ExampleGet() {
Add("a","aa")
Add("b","bb")
fmt.Println(Get("a"))
fmt.Println(Get("b"))
// Output:
// aa
// bb
}
七、总结
通常测试用例文件被建议与源文件写在同一个包中。
测试常用命令
go test执行当前包中全部测试用例，不包括 benchmark测试
go test -bench=.执行当前包中全部测试用例，包括 benchmark测试
go test -v执行测试用例时打印测试详情
go test -race检查当前测试代码是否存在竞争异常，用于检查线程安全
go test -cover检查测试代码覆盖率