介绍

1.所有文件名为xxx_test.go被识别为单元测试文件
2.函数名为Test开头表示逻辑测试
3.函数名为Benchmark开头表示性能测试
4.函数姓名为Example开头表示示例函数，用于生成函数文档

命令汇总

  1. 1.执行所有单测(必须在单测所在目录执行)
  2. go test
  3. 2.执行指定单测
  4. go test -run=Testxxx
  5. 3.执行指定测试组中某个case
  6. go test-run=Textxxx/case_1
  7. 4.查看详细信息
  8. go test -v
  9. 5.查看单侧覆盖率(单测和要测试的方法必须在同一个包下否则无法统计)
  10. go test -cover
  11. 6.覆盖率输出文件
  12. go test -cover -coverprofile=cover.out
  13. 7.通过html分析覆盖率文件
  14. go tool cover -html=cover.out
  15. 8.跳过测试(需要结合Testing.Short()开关使用，请参考示例)
  16. go test -short
  17. 9.性能基准测试（go test 不会执行性能基准测试）
  18. go test -bench=Split
  19. 10.性能基线测试查看内存分配情况
  20. go test -bench=Split -benchmem
  21. 11.性能基线测试执行测试时间
  22. go test -bench=Split -benchtime=20s
  23. 11.性能基线测试执行CPU数量执行
  24. go test -bench=Split -cpu=1

逻辑测试

所有测试函数必须以Test开头

1.准备一个需要测试的方法

  1. package splitstr
  3. import (
  4.     "strings"
  5. )
  7. func SplitString(str, sep string) []string {
  8.     var ss = make([]string, 0)
  9.     i := strings.Index(str, sep)
  10.     for i > -1 {
  11.         ss = append(ss, str[:i])
  12.         str = str[i+len(sep):]
  13.         i = strings.Index(str, sep)
  14.     }
  15.     ss = append(ss, str)
  16.     return ss
  17. }

2.对函数进行测试

  1. package tests
  3. import (
  4.     "go_chat/splitstr"
  5.     "reflect"
  6.     "testing"
  7. )
  9. //单元测试
  10. //1.所有文件名为xxx_test.go被识别为单元测试文件
  11. //2.函数名为Test开头表示测试函数逻辑
  12. //3.
  14. ////命令行输入 go test -run=Test1Split -v
  15. //表示只验证这一个函数
  16. //-v 表示输出详细信息
  17. //必须在当前xxx_test.go所在目录下执行命令才可执行单侧
  18. func Test1Split(t *testing.T) {
  19.     ret := splitstr.SplitString("1_2_3_4", "_")
  20.     want := []string{"1", "2", "3", "4"}
  21.     if !reflect.DeepEqual(ret, want) {
  22.         t.Errorf("want:%v but got:%v\n", want, ret)
  23.     }
  24. }
  26. func Test2Split(t *testing.T) {
  27.     //当开始short时进行方法跳过，按需使用
  28.     if testing.Short(){
  29.         t.Skip("跳过该测试方法")
  30.     }
  31.     ret := splitstr.SplitString("1_2_3_4", "_")
  32.     want := []string{"1", "2", "3", "5"}
  33.     if !reflect.DeepEqual(ret, want) {
  34.         t.Fatalf("want:%v but got:%v\n", want, ret)
  35.     }
  36. }

3.通过测试组进行批量测试

  1. package tests
  3. import (
  4.     "go_chat/splitstr"
  5.     "reflect"
  6.     "testing"
  7. )
  9. func TestSplit(t *testing.T) {
  10.     type test struct {
  11.         input string
  12.         sep   string
  13.         want  []string
  14.     }
  16.     tests := map[string]test{
  17.         "case_1": {input: "1_2_3_4", sep: "_", want: []string{"1", "2", "3", "4"}},
  18.         "case_2": {input: "1_2_43_4", sep: "_", want: []string{"1", "2", "3", "4"}},
  20.     }
  21.     //命令行输入 go test -run=TestSplit/case_1
  22.     //表示只包这一个单测
  23.     for name,tc :=range tests{
  24.         t.Run(name, func(t *testing.T) {
  25.             ret:=splitstr.SplitString(tc.input,tc.sep)
  26.             if !reflect.DeepEqual(ret,tc.want){
  27.                 t.Fatalf("want:%v but got:%v\n", tc.want, ret)
  28.             }
  29.         })
  30.     }
  32. }

4.并行测试

结合t.Parallel()实现

  1. package tests
  3. import (
  4.     "go_chat/splitstr"
  5.     "reflect"
  6.     "testing"
  7. )
  9. func TestSplit(t *testing.T) {
  10.     t.Parallel()//开启并行测试
  11.     type test struct {
  12.         input string
  13.         sep   string
  14.         want  []string
  15.     }
  17.     tests := map[string]test{
  18.         "case_1": {input: "1_2_3_4", sep: "_", want: []string{"1", "2", "3", "4"}},
  19.         "case_2": {input: "1_2_43_4", sep: "_", want: []string{"1", "2", "43", "4"}},
  21.     }
  22.     //命令行输入 go test -run=TestSplit/case_1
  23.     //表示只包这一个单测
  24.     for name,tc :=range tests{
  25.         tc:=tc //注意这里重新声明tc变量（避免多个goroutine中使用了相同的变量）
  26.         t.Run(name, func(t *testing.T) {
  27.             ret:=splitstr.SplitString(tc.input,tc.sep)
  28.             if !reflect.DeepEqual(ret,tc.want){
  29.                 t.Fatalf("want:%v but got:%v\n", tc.want, ret)
  30.             }
  31.         })
  32.     }
  34. }

5.代码生成工具

安装
go get -u github.com/cweill/gotests
#命令行执行
go tests -all -w split_str.go
#goland
image.png

生成测试如下

  1. package splitstr
  3. import (
  4.     "reflect"
  5.     "testing"
  6. )
  8. func TestSplitString(t *testing.T) {
  9.     type args struct {
  10.         str string
  11.         sep string
  12.     }
  13.     tests := []struct {
  14.         name string
  15.         args args
  16.         want []string
  17.     }{
  18.         {name: "s", args: args{str: "", sep: ""}, want: []string{}},
  19.     }
  20.     for _, tt := range tests {
  21.         t.Run(tt.name, func(t *testing.T) {
  22.             if got := SplitString(tt.args.str, tt.args.sep); !reflect.DeepEqual(got, tt.want) {
  23.                 t.Errorf("SplitString() = %v, want %v", got, tt.want)
  24.             }
  25.         })
  26.     }
  27. }

性能基准测试

  1. package splitstr
  3. import (
  4.     "reflect"
  5.     "testing"
  6. )
  8. //命令行执行  go test -bench=Split
  9. func BenchmarkSplit(b *testing.B) {
  10.     //b.N 表示执行的次数
  11.     for i := 0; i < b.N; i++ {
  12.         SplitString("1_2","_")
  13.     }
  14. }

基准测试并不会默认执行，需要增加-bench参数，所以我们通过执行go test -bench=Split命令执行基准测试，输出结果如下：
go test -bench=Split
image.png
其中BenchmarkSplit-8表示对Split函数进行基准测试，数字8表示GOMAXPROCS的值，这个对于并发基准测试很重要。16190835和81.3ns/op表示每次调用Split函数耗时203ns，这个结果是16190835次调用的平均值。
我们还可以为基准测试添加-benchmem参数，来获得内存分配的统计数据。
go test -bench=Split -benchmem
image.png
其中，48 B/op表示每次操作内存分配了48字节，2 allocs/op则表示每次操作进行了2次内存分配。

性能比较测试

性能比较函数通常是一个带有参数的函数，被多个不同的Benchmark函数传入不同的值来调用。例如两个相同功能的方法，通过性能计较计算出那个方法的性能更优

并发测试