Go语言的测试技术是相对低级的。它依赖一个 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数量。
手机扫一扫
移动阅读更方便
你可能感兴趣的文章