Go语言的测试技术是相对低级的。它依赖一个 go test 测试命令和一组按照约定方式编写的 测试函数，测试命令可以运行这些测试函数。编写相对轻量级的纯测试代码是有效的，而且它很容易延伸到基准测试和示例文档。
go test
编写测试代码和编写普通的Go代码过程是类似的，并不需要学习新的语法、规则或工具。
在包目录内，所有以_test.go为后缀名的源代码文件都是go test测试的一部分，不会被go build编译到最终的可执行文件中。
| 类型 | 格式 | 作用 |
| 测试函数 | 函数名前缀为Test | 测试程序的一些逻辑行为是否正确 |
| 基准函数 | 函数名前缀为Benchmark | 测试函数的性能 |
| 示例函数 | 函数名前缀为Example | 为文档提供示例文档 |
go test命令会遍历所有的*_test.go文件中符合上述命名规则的函数，然后生成一个临时的main包用于调用相应的测试函数，然后构建并运行、报告测试结果，最后清理测试中生成的临时文件。
测试函数
格式：测试函数的名字必须以Test开头，可选的后缀名必须以大写字母开头,参数t用于报告测试失败和附加的日志信息。
func TestName(t *testing.T){
// ...
}
testing.T的拥有的方法：
func (c *T) Error(args ...interface{})
func (c *T) Errorf(format string, args ...interface{})
func (c *T) Fail()
func (c *T) FailNow()
func (c *T) Failed() bool
func (c *T) Fatal(args ...interface{})
func (c *T) Fatalf(format string, args ...interface{})
func (c *T) Log(args ...interface{})
func (c *T) Logf(format string, args ...interface{})
func (c *T) Name() string
func (t *T) Parallel()
func (t *T) Run(name string, f func(t *T)) bool
func (c *T) Skip(args ...interface{})
func (c *T) SkipNow()
func (c *T) Skipf(format string, args ...interface{})
func (c *T) Skipped() bool
示例：自定义一个split函数，实现split功能：
func Split(s,sep string) (result []string) {
i := strings.Index(s,sep)
for i > -1{
result = append(result,s[:i])
s = s[i+1:]
i = strings.Index(s,sep)
}
result =append(result,s)
return
}
在当前目录下，创建一个split_test.go的测试文件，并定义一个测试函数如下：
func TsetSplit(t *testing.T) {
got := Split("a:b:c",":")
want := []string{"a","b","c"}
if !reflect.DeepEqual(want,got){
t.Errorf("期待:%v,得到:%v",want,got)
}
}
在split包路径下，执行go test命令，可以看到输出结果如下：
testing: warning: no tests to run
PASS
出现pass意味测试通过！
如果有多个测试函数，其中一个测试不过，会出现以下提示：
--- FAIL: TestMoreSplit (0.00s)
split_test.go:40: excepted:[a d], got:[a cd]
FAIL
exit status 1
如果要查看测试函数名称和运行时间,可以使用go test -v
=== RUN TestMoreSplit
--- FAIL: TestMoreSplit (0.00s)
split_test.go:40: excepted:[a d], got:[a cd]
FAIL
还可以在go test命令后添加-run参数，它对应一个正则表达式，只有函数名匹配上的测试函数才会被go test命令执行。
测试组
如果有多个测试，不必每个测试都写一个函数，可以使用测试组来完成。
//测试组
func TestSplit(t *testing.T) {
type test []struct{
input string
sep string
want []string
}
tests := test{
{input:"a:b:c",sep:":",want:[]string{"a","b","c"}},
{input:"a:b:c",sep:",",want:[]string{"a","b","c"}},
{input:"abcdbce",sep:"bc",want:[]string{"a","d","e"}},
{input:"上海自来水来自海上",sep:"海",want:[]string{"上","自来水来自","上"}},
}
for _,tc := range tests{
got := Split(tc.input,tc.sep)
if !reflect.DeepEqual(got,tc.want){
t.Errorf("期待:%v,获得:%v",tc.want,got)
}
}
}
执行go test -v，获得
=== RUN TestSplit
--- FAIL: TestSplit (0.00s)
split_test.go:59: 期待:[a b c],获得:[a:b:c]
split_test.go:59: 期待:[a d e],获得:[a cd ce]
split_test.go:59: 期待:[上 自来水来自 上],获得:[上 ��自来水来自 ��上]
FAIL
exit status 1
中文有乱码，这种情况下可以使用%#v的格式化方式查看乱码是什么：t.Errorf("期待:%#v,获得:%#v",tc.want,got)
得到：split_test.go:59: 期待:[]string{"上", "自来水来自", "上"},获得:[]string{"上", "\xb5\xb7自来水来自", "\xb5\xb7上"}
当测试组中测试比较多的时候，可以加个name来查看是哪个测试用例出了问题：
//测试组
func TestSplit(t *testing.T) {
type test struct{ // 定义test结构体
input string
sep string
want []string
}
tests := map[string]test{
"simple": {input:"a:b:c",sep:":",want:[]string{"a","b","c"}},
"simple1": {input:"a:b:c",sep:",",want:[]string{"a","b","c"}},
"simple2": {input:"abcdbce",sep:"bc",want:[]string{"a","d","e"}},
"simple3": {input:"上海自来水来自海上",sep:"海",want:[]string{"上","自来水来自","上"}},
}
for name,tc := range tests{
got := Split(tc.input,tc.sep)
if !reflect.DeepEqual(got,tc.want){
t.Errorf("测试名:%#v,期待:%#v,获得:%#v",name,tc.want,got)
}
}
}
输出的时候就会把测试用例的名字带上：
=== RUN TestSplit
--- FAIL: TestSplit (0.00s)
split_test.go:66: 测试名:"simple1",期待:[]string{"a", "b", "c"},获得:[]string{"a:b:c"}
split_test.go:66: 测试名:"simple2",期待:[]string{"a", "d", "e"},获得:[]string{"a", "cd", "ce"}
split_test.go:66: 测试名:"simple3",期待:[]string{"上", "自来水来自", "上"},获得:[]string{"上", "\xb5\xb7自来水来自", "\xb5\xb7上"}
FAIL
exit status 1
子测试
for name,tc := range tests{
t.Run(name, func(t *testing.T) {
got := Split(tc.input,tc.sep)
if !reflect.DeepEqual(got,tc.want){
t.Errorf("测试名:%#v,期待:%#v,获得:%#v",name,tc.want,got)
}
})
}
执行结果:
$go test -v
=== RUN TestSplit
=== RUN TestSplit/simple2
=== RUN TestSplit/simple3
=== RUN TestSplit/simple
=== RUN TestSplit/simple1
--- FAIL: TestSplit (0.00s)
--- FAIL: TestSplit/simple2 (0.00s)
split_test.go:71: 测试名:"simple2",期待:[]string{"a", "d", "e"},获得:[]string{"a", "cd", "ce"}
--- FAIL: TestSplit/simple3 (0.00s)
split_test.go:71: 测试名:"simple3",期待:[]string{"上", "自来水来自", "上"},获得:[]string{"上", "\xb5\xb7自来水来自", "\xb5\xb7上"}
--- PASS: TestSplit/simple (0.00s)
--- FAIL: TestSplit/simple1 (0.00s)
split_test.go:71: 测试名:"simple1",期待:[]string{"a", "b", "c"},获得:[]string{"a:b:c"}
FAIL
exit status 1
可以通过-run=RegExp来指定运行的测试用例，还可以通过/来指定要运行的子测试用例,只测试simple：$go test -v -run=Split/simple
测试覆盖率
在测试中至少被运行一次的代码占总代码的比例。Go提供内置功能来检查你的代码覆盖率。我们可以使用go test -cover来查看测试覆盖率。
$go test -cover
--- FAIL: TestSplit (0.00s)
--- FAIL: TestSplit/simple2 (0.00s)
split_test.go:71: 测试名:"simple2",期待:[]string{"a", "d", "e"},获得:[]string{"a", "cd", "ce"}
--- FAIL: TestSplit/simple3 (0.00s)
split_test.go:71: 测试名:"simple3",期待:[]string{"上", "自来水来自", "上"},获得:[]string{"上", "\xb5\xb7自来水来自", "\xb5\xb7上"}
--- FAIL: TestSplit/simple1 (0.00s)
split_test.go:71: 测试名:"simple1",期待:[]string{"a", "b", "c"},获得:[]string{"a:b:c"}
FAIL
coverage: 100.0% of statements
exit status 1
Go还提供了一个额外的-coverprofile参数，用来将覆盖率相关的记录信息输出到一个文件。$ go test -cover -coverprofile=c.out
执行go tool cover -html=c.out，使用cover工具来处理生成的记录信息，该命令会打开本地的浏览器窗口生成一个HTML报告。
用绿色标记的语句块表示被覆盖了，而红色的表示没有被覆盖。
基准测试
基准测试就是在一定的工作负载之下检测程序性能的一种方法。
格式：
func BenchmarkName(b *testing.B){
// ...
}
基准测试以Benchmark为前缀，需要一个'*testing.B'类型的参数b，基准测试必须要执行b.N次，这样的测试才有对照性，b.N的值是系统根据实际情况去调整的，从而保证测试的稳定性。 testing.B拥有的方法如下：
func (c *B) Error(args ...interface{})
func (c *B) Errorf(format string, args ...interface{})
func (c *B) Fail()
func (c *B) FailNow()
func (c *B) Failed() bool
func (c *B) Fatal(args ...interface{})
func (c *B) Fatalf(format string, args ...interface{})
func (c *B) Log(args ...interface{})
func (c *B) Logf(format string, args ...interface{})
func (c *B) Name() string
func (b *B) ReportAllocs()
func (b *B) ResetTimer()
func (b *B) Run(name string, f func(b *B)) bool
func (b *B) RunParallel(body func(*PB))
func (b *B) SetBytes(n int64)
func (b *B) SetParallelism(p int)
func (c *B) Skip(args ...interface{})
func (c *B) SkipNow()
func (c *B) Skipf(format string, args ...interface{})
func (c *B) Skipped() bool
func (b *B) StartTimer()
func (b *B) StopTimer()
为split编写基准测试：
//基准测试
func BenchmarkSplit(b *testing.B) {
for i:=0;i<b.N;i++{
Split("a:b:c",":")
}
}
通过执行go test -bench=Split命令执行基准测试，输出结果如下：
$go test -bench=Split
goos: darwin
goarch: amd64
pkg: xxxxxx
BenchmarkSplit-8 10000000 203 ns/op
PASS
其中BenchmarkSplit-8表示对Split函数进行基准测试，数字8表示GOMAXPROCS的值，这个对于并发基准测试很重要。10000000和203ns/op表示每次调用Split函数耗时203ns，这个结果是10000000次调用的平均值。
默认情况下，每个基准测试至少运行1秒!
可为基准测试添加-benchmem参数，来获得内存分配的统计数据。
$go test -bench=Split -benchmem
...
BenchmarkSplit-8 10000000 203 ns/op 112 B/op 3 allocs/op
...
112 B/op表示每次操作内存分配了112字节，3 allocs/op则表示每次操作进行了3次内存分配。
性能比较函数
性能比较函数通常是一个带有参数的函数，被多个不同的Benchmark函数传入不同的值来调用。
func benchmark(b *testing.B, size int){/* ... */}
func Benchmark10(b *testing.B){ benchmark(b, 10) }
func Benchmark100(b *testing.B){ benchmark(b, 100) }
func Benchmark1000(b *testing.B){ benchmark(b, 1000) }
使用斐波那契数的函数测试：
// Fib 是一个计算第n个斐波那契数的函数
func Fib(n int) int {
if n <2{
return n
}
return Fib(n-1) + Fib(n+2)
}
性能比较函数：
func benchmarkFib(b *testing.B, n int) {
for i := 0; i < b.N; i++ {
Fib(n)
}
}
func BenchmarkFib1(b *testing.B) { benchmarkFib(b, 1) }
func BenchmarkFib2(b *testing.B) { benchmarkFib(b, 2) }
func BenchmarkFib3(b *testing.B) { benchmarkFib(b, 3) }
func BenchmarkFib10(b *testing.B) { benchmarkFib(b, 10) }
func BenchmarkFib20(b *testing.B) { benchmarkFib(b, 20) }
func BenchmarkFib40(b *testing.B) { benchmarkFib(b, 40) }
默认情况下，每个基准测试至少运行1秒。如果在Benchmark函数返回时没有到1秒，则b.N的值会按1,2,5,10,20,50，…增加，并且函数再次运行。
还可以使用-benchtime标志增加最小基准时间，以产生更准确的结果。
并行测试
func (b *B) RunParallel(body func(*PB))会以并行的方式执行给定的基准测试。 RunParallel会创建出多个goroutine，并将b.N分配给这些 goroutine 执行， 其中 goroutine数量的默认值为GOMAXPROCS。用户如果想要增加非CPU受限（non-CPU-bound）基准测试的并行性， 那么可以在RunParallel之前调用SetParallelism 。RunParallel通常会与-cpu标志一同使用。go test -bench=. -cpu 1来指定使用的CPU数量。