Go测试-《GO开发知识笔记》

admin
admin
admin
0
文章
0
评论
2025-11-04 01:01:50 编程 来源：ZONE.CI 全球网 0 阅读模式
  • 单元测试
    • 测试函数
      • 测试函数的格式
      • 测试函数示例
      • 测试组
      • 子测试
      • 测试覆盖率
    • 基准测试
      • 基准测试函数格式
      • 基准测试示例
      • 性能比较函数
      • 重置时间
      • 并行测试
    • Setup与TearDown
      • TestMain
      • 子测试的Setup与TearDown
    • 示例函数
      • 示例函数的格式
      • 示例函数示例

    单元测试

    Go语言中的测试依赖go test命令，编写测试代码和编写普通的Go代码过程是类似的，并不需要学习新的语法，规则或工具。go test命令是一个按照一定约定和组织的测试代码的驱动程序，在包目录内，所有以_test.go为后缀名的源代码文件都是go test测试的一部分，不会被go build编译到最终的可执行文件。在*_test.go文件中有三种类型的函数，单元测试函数，基准测试函数和示例函数。

    类型 格式 作用
    测试函数 函数名前缀为Test 测试程序的一些逻辑行为是否正确
    基准函数 函数前缀名为Benchmark 测试函数的性能
    示例函数 函数名为Example 为文档提供示例文档

    go test命令会遍历所有的*_test.go文件中符合上述命令的规则函数，然后生成一个临时的main包用于调用相应的测试函数，然后构建并运行，报告测试结果，最后清理测试中生成的临时文件。

    测试函数

    测试函数的格式

    每个测试函数必须导入testing包，测试函数的基本格式（签名）如下：

    1. func TestName(t *testing.T){
    2.     // ...
    3. }

    测试函数的名字必须以Test开头，可选的后缀名必须以大写字母开头，举几个例子：

    1. func TestAdd(t *testing.T){...}
    2. func TestSum(t *testing.T){...}
    3. func TestLog(t *testing.T){...}

    其种参数t用于报告测试失败和附加的日志信息。testing.T拥有如下方法：

    1. func (c *T) Error(args ...interface{})
    2. func (c *T) Errorf(format string, args ...interface{})
    3. func (c *T) Fail()
    4. func (c *T) Failed() bool
    5. func (c *T) Fatal(args ...interface{})
    6. func (c *T) Fatalf(format string,args ...interface{})
    7. func (c *T) Log(args ...interface{})
    8. func (c *T) Logf(format string,args ...interface{})
    9. func (c *T) Name() string
    10. func (c *T) Parallel()
    11. func (c *T) Run(name string, f func(t *T)) bool
    12. func (c *T) Skip(args ...interface{})
    13. func (c *T) SkipNow()
    14. func (c *T) Skipf(format string, args ...interfaceP{})
    15. func (c *T) Skipped() bool

    测试函数示例

    就像细胞是构成我们身体的基本单位，一个软件程序也是由很多单元组件构成的，单元组件可以是函数，结构体，方法和最终用户可能依赖的任意东西。总之我们需要确保这些最贱是能够正常运行的，单元测试是一些利用各种方法测试单元组件的程序，它会将结果与预期输出进行比较。接下来我们定义一个split的包，包里定义一个Split函数，具体实现如下：

    1. package spilt
    3. import (
    4.     "strings"
    5. )
    7. func Split(s, sep string)(result []string){
    8.     i := strings.Index(s, sep)  // 获取到第一次的索引值
    9.     for i > -1{   // 循环判断
    10.         result = append(result, s[:i])
    11.         s = s[i+1:]
    12.         i = strings.Index(s, sep)
    13.     }
    14.     result = append(result, s)
    15.     return
    16. }

    在当前目录下，我们创建一个split_test.go的测试文件，并定义一个测试函数如下：

    1. package spilt
    3. import (
    4.     "reflect"
    5.     "testing"
    6. )
    8. func TestSplit(t *testing.T) {  // 测试函数名必须以Test开头，必须接收一个*testing.T类型参数
    9.     got := Split("a:b:c",":")  // 程序输出的结果
    10.     want := []string{"a","b","c"}  // 期望的结果
    11.     if !reflect.DeepEqual(want, got){ // 因为slice不能直接比较，借助反射保重的方法比较
    12.         t.Errorf("excepted:%v,got:%v",want, got)  // 测试失败输出错误提示
    14.     }
    16. }

    在split包路径下，执行go test命令，可以看到输出的结果如下：

    1. D:\gocode\src\Negan\split>go test
    2. PASS
    3. ok      _/D_/gocode/src/Negan/split     0.600s

    一个测试用例有点单薄，我们在编写一个测试使用多个字符切割字符串的例子，在split_test.go中添加如下测试函数：

    1. func TestMoreSplit(t *testing.T){
    2.     got := Split("abcd","bc")
    3.     want := []string{"a", "d"}
    4.     if !reflect.DeepEqual(want, got){
    5.         t.Errorf("excepted:%v, got:%v",want, got)
    6.     }
    7. }

    再次运行go test命令，输出结果如下：

    1. D:\gocode\src\Negan\split>go test
    2. --- FAIL: TestMoreSplit (0.00s)
    3.     split_test.go:23: excepted:[a d], got:[a cd]
    4. FAIL
    5. exit status 1
    6. FAIL    _/D_/gocode/src/Negan/split     0.708s

    这一次我们的测试失败了，我们可以在go test命令后面添加-v参数，查看测试函数名称和运行时间。

    1. D:\gocode\src\Negan\split>go test -v
    2. === RUN   TestSplit
    3. --- PASS: TestSplit (0.00s)
    4. === RUN   TestMoreSplit
    5.     TestMoreSplit: split_test.go:23: excepted:[a d], got:[a cd]
    6. --- FAIL: TestMoreSplit (0.00s)
    7. FAIL
    8. exit status 1
    9. FAIL    _/D_/gocode/src/Negan/split     0.703s

    这次我们能清除的看到TestMoreSplit这个测试没有成功，还可以在go test命令后添加-run参数，它对应一个正则表达式，只有函数名匹配上的测试函数才会被go test命令执行。

    1. go test -run="More"
    2. --- FAIL: TestMoreSplit (0.00s)
    3.     split_test.go:23: excepted:[a d], got:[a cd]
    4. FAIL
    5. exit status 1
    6. FAIL    _/D_/gocode/src/Negan/split     0.735s

    现在我们回过头来解决我们程序中的问题，很显然我们最初的split函数并没有考虑到sep为多个字符的情况，我们来修复这个Bug:

    1. package spilt
    3. import (
    4.     "strings"
    5. )
    7. func Split(s, sep string)(result []string){
    8.     i := strings.Index(s, sep)  // 获取到第一次的索引值
    9.     for i > -1{   // 循环判断
    10.         result = append(result, s[:i])
    11.         s = s[i+len(sep):]  // 使用len(sep)获取sep长度
    12.         i = strings.Index(s, sep)
    13.     }
    14.     result = append(result, s)
    15.     return
    16. }

    这一次我们再来测试一下，注意当我们修改了我们的代码之后不要金金之星那些失败的测试函数，我们应该完整的运行所有的测试，保证不会因为修改代码而引入新的问题。

    1. go test -v
    2. === RUN   TestSplit
    3. --- PASS: TestSplit (0.00s)
    4. === RUN   TestMoreSplit
    5. --- PASS: TestMoreSplit (0.00s)
    6. PASS
    7. ok      _/D_/gocode/src/Negan/split     0.703s

    测试组

    我们现在还想要测试一下split函数对中文字符串的支持，这个时候我们可以再编写一个TestChineseSplit测试函数，但是我们也可以使用如下更友好的一种方式来添加更多的测试用例。

    1. func TestSplit(t *testing.T) {
    2.     // 定义一个测试用例类型
    3.     type test struct{
    4.         input string
    5.         sep string
    6.         want []string
    7.     }
    9.     // 定义一个存储测试用例的切片
    10.     tests := []test{
    11.         {input:"a:b:c",sep: ":",want:[]string{"a","b","c"}},
    12.         {input:"a:b:c",sep: ",",want:[]string{"a:b:c"}},
    13.         {input:"abcd",sep: "bc",want:[]string{"a","d"}},
    14.         {input:"上海自来水来自海上",sep: "自",want:[]string{"上海","来水来","海上"}},
    15.     }
    17.     // 遍历切片，逐一执行测试用例
    18.     for _, tc := range tests{
    19.         got := Split(tc.input,tc.sep)
    20.         if !reflect.DeepEqual(got,tc.want){
    21.             t.Errorf("excepted:%#v, got:%#v",tc.want, got)
    22.         }
    23.     }
    24. }

    执行go test -v命令

    1. go test -v
    2. === RUN   TestSplit
    3. --- PASS: TestSplit (0.00s)
    4. PASS
    5. ok      _/D_/gocode/src/Negan/split     0.742s

    子测试

    如果测试用例比较多的时候，我们是没有办法一眼看出具体是哪个测试用例失败了，我们可能会想到下面的解决方法:

    1. func TestSplit(t *testing.T) {
    2.     type test struct{
    3.         input string
    4.         sep string
    5.         want []string
    6.     }
    8.     tests := map[string]test{
    9.         "simple": {input:"a:b:c",sep: ":",want:[]string{"a","b","c"}},
    10.         "wrong sep": {input:"a:b:c",sep: ",",want:[]string{"a:b:c"}},
    11.         "more sep": {input:"abcd",sep: "bc",want:[]string{"a","d"}},
    12.         "leading sep": {input:"上海自来水来自海上",sep: "自",want:[]string{"","上海","来水来","海上"}},
    13.     }
    15.     for name, tc := range tests{
    16.         got := Split(tc.input, tc.sep)
    17.         if !reflect.DeepEqual(got, tc.want){
    18.             t.Errorf("name:%s excepted:%#v, got:%#v", name, tc.want, got)
    19.         }
    20.     }
    21. }

    上面的方法是能够解决问题的，同时Go1.7+中新增了子测试，我们可以按照如下方式使用t.Run执行子测试：

    1. func TestSplit(t *testing.T) {
    2.     type test struct{
    3.         input string
    4.         sep string
    5.         want []string
    6.     }
    8.     tests := map[string]test{
    9.         "simple": {input:"a:b:c",sep: ":",want:[]string{"a","b","c"}},
    10.         "wrong sep": {input:"a:b:c",sep: ",",want:[]string{"a:b:c"}},
    11.         "more sep": {input:"abcd",sep: "bc",want:[]string{"a","d"}},
    12.         "leading sep": {input:"上海自来水来自海上",sep: "自",want:[]string{"","上海","来水来","海上"}},
    13.     }
    15.     for name, tc := range tests{
    16.         t.Run(name, func(t *testing.T) {  // 使用t.Run()执行子测试
    17.             got := Split(tc.input, tc.sep)
    18.             if !reflect.DeepEqual(got, tc.want){
    19.                 t.Errorf("name:%s excepted:%#v, got:%#v", name, tc.want, got)
    20.             }
    21.         })
    22.     }
    23. }

    此时我们再执行go test -v命令就能够看到更清晰的输出内容了

    1. go test -v
    2. === RUN   TestSplit
    3. === RUN   TestSplit/more_sep
    4. === RUN   TestSplit/leading_sep
    5.     TestSplit/leading_sep: split_test.go:70: name:leading sep excepted:[]string{"", "上海", "来水来"
    6. , "海上"}, got:[]string{"上海", "来水来", "海上"}
    7. === RUN   TestSplit/simple
    8. === RUN   TestSplit/wrong_sep
    9. --- FAIL: TestSplit (0.00s)
    10.     --- PASS: TestSplit/more_sep (0.00s)
    11.     --- FAIL: TestSplit/leading_sep (0.00s)
    12.     --- PASS: TestSplit/simple (0.00s)
    13.     --- PASS: TestSplit/wrong_sep (0.00s)
    14. FAIL
    15. exit status 1
    16. FAIL    _/D_/gocode/src/Negan/split     0.773s

    我们知道可以通过-run=RegExp来指定运行的测试用例，还可以通过/指定要运行的子测试用例，例如：go test -v -run=Split/simple只会运行simple对应的子测试用例。

    1. go test -v -run=Split/simple
    2. === RUN   TestSplit
    3. === RUN   TestSplit/simple
    4. --- PASS: TestSplit (0.00s)
    5.     --- PASS: TestSplit/simple (0.00s)
    6. PASS
    7. ok      _/D_/gocode/src/Negan/split     0.713s

    测试覆盖率

    测试覆盖率是袋中被测试套件覆盖的百分比，通常我们使用的都是语句的覆盖率，也就是在测试中至少被运行一次的代码占总代码的比例。Go提供了内置功能来检查代码覆盖率，使用go test -cover来查看测试覆盖率。

    1. >go test -cover
    2. PASS
    3. coverage: 100.0% of statements
    4. ok      _/D_/gocode/src/Negan/split     0.685s

    从上面的结果可以看到我们的测试用例覆盖了100%的代码。Go还提供了一个额外的-coverprofile参数，用来将覆盖率相关的记录信息输出到一个文件，例如：

    1. >go test -cover -coverprofile=c.out
    2. PASS
    3. coverage: 100.0% of statements
    4. ok      _/D_/gocode/src/Negan/split     0.812s

    上面的命令会将覆盖率相关的信息输出到当前文件下面的c.out文件中，然后我们执行go tool cover -html=c.out,使用cover工具来处理生成的记录信息，该命令会打开本地的浏览器窗口生成一个html报告。

    基准测试

    基准测试函数格式

    基准测试就是在一定的工作负载之下检测程序性能的一种方法。基准测试的基本格式如下：

    1. func BenchmarkName(b *testing.B){
    2.     // ...
    3. }

    基准测试以Benchmark为前缀，需要一个*testing.B类型的参数b,基准测试必须要执行b.N次，这样测试才有对照性，b.N的值是系统根据实际情况去调整的，从而保证测试的稳定性，testing.B拥有的方法如下：

    1. func (c *B) Error(args ...interface{})
    2. func (c *B) Errorf(format string, args ...interface{})
    3. func (c *B) Fail()
    4. func (c *B) FailNow()
    5. func (c *B) Failed() bool
    6. func (c *B) Fatal(args ...interface{})
    7. func (c *B) Fatalf(format string, args ...interface{})
    8. func (c *B) Log(args ...interface{})
    9. func (c *B）Logf(format string, args ...interface{})
    10. func (c *B) Name() string
    11. func (b *B) ReportAllocs()
    12. func (b *B) ResetTimer()
    13. func (b *B) Run(name string, f func(b *B)) bool
    14. func (b *B) RunParallel(body func(*PB))
    15. func (b *B) SetBytes(n int64)
    16. func (b *B) SetParallelism(p int)
    17. func (c *B) Skip(args ...interface{})
    18. func (c *B) SkipNow()
    19. func (c *B) Skipf(format string, args ...interface{})
    20. func (c *B) Skipped() bool
    21. func (b *B) StartTimer()
    22. func (b *B) StopTimer()

    基准测试示例

    我们为split包中的Split函数编写基准测试如下：

    1. func BenchmarkSplit(b *testing.B) {
    2.     for i := 0; i < b.N; i++{
    3.         Split("上海自来水来自海上","水")
    4.     }
    5. }

    基准测试并不会默认执行，需要增加-bench参数，所以我们通过执行go test-bench=Split命令执行基准测试，输出结果如下：

    1. go test -bench=Split
    2. goos: windows
    3. goarch: amd64
    4. BenchmarkSplit-4         4818822               246 ns/op
    5. PASS
    6. ok      _/D_/gocode/src/Negan/split     2.041s

    其种BenchmarkSplit-4表示对Split函数进行基准测试，数字4表示GOMAXPROCS的值，这个对于并发基准测试很重要。4818822和246 ns/op表示每次代用Split函数耗时246ns,这个结果是4848822次调用的平均值。我们还可以为基准测试添加-benchmem参数来获得内存分配的统计数据。

    1. >go test -bench=Split -benchmem
    2. goos: windows
    3. goarch: amd64
    4. BenchmarkSplit-4         4708045               256 ns/op              48 B/op          2 allocs/op
    5. PASS
    6. ok      _/D_/gocode/src/Negan/split     2.220s

    其中48B/op表示每次操作内存分配了48字节，2 allocs/op则表示每次操作进行了2次内存分配，我们将我们的Split函数优化如下：

    1. func Split(s, sep string)(result []string){
    2.     result = make([]string,0,strings.Count(s,sep)+1)  // 提前分配好内存
    3.     i := strings.Index(s, sep)  // 获取到第一次的索引值
    4.     for i > -1{   // 循环判断
    5.         result = append(result, s[:i])
    6.         s = s[i+len(sep):]
    7.         i = strings.Index(s, sep)
    8.     }
    9.     result = append(result, s)
    10.     return
    11. }

    这一次我们提前使用make函数将result初始化一个容量足够大的切片，而不像之前一样通过调用append函数来追加，我们来看一下这个改进会带来多大的性能提升：

    1. go test -bench=Split -benchmem
    2. goos: windows
    3. goarch: amd64
    4. BenchmarkSplit-4         6301537               195 ns/op              32 B/op          1 allocs/op
    5. PASS
    6. ok      _/D_/gocode/src/Negan/split     2.072s

    性能比较函数

    上面的基准测试只能得到给定操作的绝对耗时，但是在很多性能问题是发生在两个不同操作之间的相对耗时，比如同一个函数处理1000个元素的耗时与处理一万个甚至100万个元素的耗时差别是多少呢？或者对于同一个任务酒精使用哪种算法性能更佳？我们通常需要对两个不同算法的实现使用相同的输入来进行基准比较测试。性能比较函数通常是一个带有参数的函数，被多个不同的Benchmark函数传入不同的值来调用。

    1. func benchmark(b *testing.B,size int){...}
    2. func Benchmark10(b *testing.B){benchmark(b,10)}
    3. func Benchmark100(b *testing.B){benchmark(b,100)}
    4. func Benchmark1000(b *testing.B){benchmark(b,1000)}

    我们编写一个计算斐波那契数列函数如下：

    1. // fib.go
    3. func Fib(n int) int{
    4.     if n < 2{
    5.         return n
    6.     }
    7.     return Fib(n-1) + Fib(n-2)
    8. }

    我们编写的性能比较函数如下：

    1. // fib-test.go
    3. import "testing"
    5. func benchmarkFib(b *testing.B, n int) {
    6.     for i:=0;i<b.N;i++{
    7.         Fib(n)
    8.     }
    9. }
    12. func BenchmarkFib1(b *testing.B) {
    13.     benchmarkFib(b,1)
    14. }
    15. func BenchmarkFib2(b *testing.B) {
    16.     benchmarkFib(b,2)
    17. }
    18. func BenchmarkFib3(b *testing.B) {
    19.     benchmarkFib(b,3)
    20. }
    21. func BenchmarkFib10(b *testing.B) {
    22.     benchmarkFib(b,10)
    23. }
    24. func BenchmarkFib20(b *testing.B) {
    25.     benchmarkFib(b,20)
    26. }
    27. func BenchmarkFib40(b *testing.B) {
    28.     benchmarkFib(b,40)
    29. }

    运行基准测试：

    1. >go test -bench=Fib
    2. goos: windows
    3. goarch: amd64
    4. BenchmarkFib1-4         380433421                3.06 ns/op
    5. BenchmarkFib2-4         121904761                9.22 ns/op
    6. BenchmarkFib3-4         87771267                14.1 ns/op
    7. BenchmarkFib10-4         2137042               539 ns/op
    8. BenchmarkFib20-4           19473             55064 ns/op
    9. BenchmarkFib40-4               2         997070300 ns/op
    10. PASS
    11. ok      _/D_/gocode/src/Negan/split     11.877s

    这里需要注意的是，默认情况下，每个基准测试至少运行1秒，如果在Benchmark函数返回时没有1秒，则b.N的值会按照1，2，5，10，20，50，…增加，并且函数再次运行。最终的BenchmarkFib40只运行了两次，每次运行的平均值只有不到一秒，像这种情况下我们使用-benchtime标志增加最小基准时间，以产生更准确的结果，例如：

    1. >go test -bench=Fib40 -benchtime=20s
    2. goos: windows
    3. goarch: amd64
    4. BenchmarkFib40-4              24        1020060225 ns/op
    5. PASS
    6. ok      _/D_/gocode/src/Negan/split     26.215s

    这一次BenchmarkFib40函数运行了24次，结果会更佳准确一些。使用性能比较函数做测试的时候容易犯的错误就是把b.N作为输入的大小，例如以下两个例子都是错误示例：

    1. // 错误示范1
    2. func BenchmarkFibWrong(b *testing.B){
    3.     for n:=0;n<b.N;n++{
    4.         Fib(n)
    5.     }
    6. }
    8. // 错误示例2
    9. func BenchmarkFibWrong2(b *testing.B){
    10.     Fib(b.N)
    11. }

    重置时间

    b.ResetTimer之前的处理不会放到执行时间里，也不会输出到报告中，所以可以在之前做一些不计划作为测试报告的操作。

    1. func BenchmarkSplit(b *testing.B) {
    2.     time.Sleep(5*time.Second)  // 架设需要做一些耗时的无关操作
    3.     b.ResetTimer()
    4.     for i := 0; i < b.N; i++{
    5.         Split("上海自来水来自海上","水")
    6.     }
    7. }

    并行测试

    func (b B) RunParallel(body func(PB))会以并行的方式执行给定的基准测试。RunParallel会创建多个goroutine，并将b.N分配给这些goroutine执行，其种goroutine的数量默认为GOMAXPROCS。用户想要增加非CPU受限（non-CPU-bound）基准测试的并行性，那么可以在RunParallel之前调用SetParallelism。RunParallel通常会与-cpu标志一同使用。

    1. func BenchmarkSplitParallel(b *testing.B) {
    2.     // b.SetParallelism(1)  // 设置使用cpu数
    3.     b.RunParallel(func(pb *testing.PB) {
    4.         for pb.Next(){
    5.             Split("上海自来水来自海上","水")
    6.         }
    7.     })
    8. }

    执行以下基准测试：

    1. go test -bench=Split
    2. goos: windows
    3. goarch: amd64
    4. BenchmarkSplit-4                 6023530               207 ns/op
    5. BenchmarkSplitParallel-4        16168431                74.0 ns/op
    6. PASS
    7. ok      _/D_/gocode/src/Negan/split     28.532s

    还可以通过测试命令后添加-cpu参数，如go test -bench=Split -cpu 1来指定使用cpu的数量。

    Setup与TearDown

    测试程序有时需要在测试之前进行额外的设置(setup)或在测试之后进行拆卸(teardown)。

    TestMain

    通过在_test.go文件中定义TestMain函数，可以在测试之前进行额外的设置(setup)或在测试之后进行拆卸(teardown)操作。如果测试文件包含函数func TestMain(m testing.M)那么生成的测试会先调用TestMain(n),然后再运行具体测试。TestMain运行在主goroutine中，可以在调用m.Run前后做任何设置(setup)和拆卸(teardown)。退出设施的时候应该使用m.Run的返回值作为参数调用os.Exit。一个使用TestMain来设置Setup和TearDown的示例如下：

    1. func TestMain(m *testing.M){
    2.     fmt.Println("write setup code here ...")  // 测试之前做一些设置
    3.     // 如果TestMain使用了flags,这里应该加上flag.Parse()'
    4.     retCode := m.Run()
    5.     fmt.Println("write teardown code here...") // 测试之后做一些拆卸工作
    6.     os.Exit(retCode)
    7. }

    需要注意的是：在调用TestMain时，flag.Parse并没有被调用。如果TestMain依赖于command-line标志(包括testing包的标记),则应该显示的调用flag.Parse。

    子测试的Setup与TearDown

    有时候我们可能需要为每个测试集设置Setup与Trardown,也有可能需要为每个子测试设置Setup与Trardown。下面我们定义两个工具函数如下：

    1. // 测试机的Setup与Teardown
    2. func setupTestCase(t *testing.T) func(t *testing.T){
    3.     t.Log("如果需要再次执行：测试之前的setup")
    4.     return func(t *testing.T){
    5.         t.Log("如有需要再次执行：测试之后的teardown")
    6.     }
    7. }
    9. // 子测试的Setup与Teardown
    10. func setupSubTest(t *testing.T) func(t *testing.T){
    11.     t.Log("如有需要再次执行：子测试之前的setup")
    12.     return func(t *testing.T){
    13.         t.Log("如有需要在此执行：子测试之后的teardown")
    14.     }
    15. }

    使用方式如下：

    1. func TestSplit(t *testing.T) {
    2.    type test struct{  // 定义test结构体
    3.       input string
    4.       sep string
    5.       want []string
    6.    }
    7.    tests := map[string]test{  // 测试用例用map存储
    8.       "simple":{input:"a:b:c",sep: ":",want:[]string{"a","b","c"}},
    9.       "wrong sep":{input:"a:b:c",sep: ",",want:[]string{"a:b:c"}},
    10.       "more sep":{input:"abcd",sep: "bc",want:[]string{"a","d"}},
    11.       "leading sep":{input:"上海自来水来自海上",sep: "水",want:[]string{"上海自来","来自海上"}},
    12.    }
    13.    teardownTestCase := setupTestCase(t)  // 测试之前执行setup操作
    14.    defer teardownTestCase(t)  // 测试之后执行testdown
    16.    for name,tc:=range tests{
    17.       t.Run(name,func(t *testing.T){  // 使用t.Run()执行子测试
    18.          teardownSubTest := setupSubTest(t)  // 子测试执行之前执行setup操作
    19.          defer teardownSubTest(t)  // 测试之后执行testdown操作
    20.          got := Split(tc.input,tc.sep)
    21.          if !reflect.DeepEqual(got,tc.want){
    22.             t.Errorf("excepted:%#v,got:%#v", tc.want,got)
    23.          }
    24.       })
    25.    }
    26. }

    测试结果如下：

    1. go test -v
    2. === RUN   TestSplit
    3.     TestSplit: split_test.go:104: 如果需要再次执行：测试之前的setup
    4. === RUN   TestSplit/simple
    5.     TestSplit/simple: split_test.go:112: 如有需要再次执行：子测试之前的setup
    6.     TestSplit/simple: split_test.go:114: 如有需要在此执行：子测试之后的teardown
    7. === RUN   TestSplit/wrong_sep
    8.     TestSplit/wrong_sep: split_test.go:112: 如有需要再次执行：子测试之前的setup
    9.     TestSplit/wrong_sep: split_test.go:114: 如有需要在此执行：子测试之后的teardown
    10. === RUN   TestSplit/more_sep
    11.     TestSplit/more_sep: split_test.go:112: 如有需要再次执行：子测试之前的setup
    12.     TestSplit/more_sep: split_test.go:114: 如有需要在此执行：子测试之后的teardown
    13. === RUN   TestSplit/leading_sep
    14.     TestSplit/leading_sep: split_test.go:112: 如有需要再次执行：子测试之前的setup
    15.     TestSplit/leading_sep: split_test.go:114: 如有需要在此执行：子测试之后的teardown
    16.     TestSplit: split_test.go:106: 如有需要再次执行：测试之后的teardown
    17. --- PASS: TestSplit (0.01s)
    18.     --- PASS: TestSplit/simple (0.00s)
    19.     --- PASS: TestSplit/wrong_sep (0.00s)
    20.     --- PASS: TestSplit/more_sep (0.00s)
    21.     --- PASS: TestSplit/leading_sep (0.00s)
    22. PASS
    23. ok      _/D_/gocode/src/Negan/split     0.716s

    示例函数

    示例函数的格式

    被go test特殊对待的第三种函数就是示例函数，它们的函数名以Example为前缀，它们既没有参数也没有返回值。标准格式如下：

    1. func ExampleName(){
    2.     //...
    3. }

    示例函数示例

    下面的代码使我们为Split函数编写一个示例函数：

    1. func ExampleSplit() {
    2.     fmt.Println(Split("a:b:c",":"))
    3.     fmt.Println(Split("上海自来水来自海上","水"))
    4.     // Output:
    5.     // [a b c]
    6.     // [上海自来 来自海上]
    7. }

    为代码编写示例代码有如下三个好处：

    • 示例函数能够作为文档直接使用，例如基于web的godoc中能把示例函数与对应的函数或包相关联；
    • 示例函数只要包含了//Ouput：也是可以通过go test运行的可执行测试 ```java go test -run Example PASS ok /D/gocode/src/Negan/split 0.691s

    ```

    • 示例函数提供了可以直接运行的示例代码，可以直接在golang.org的godoc文档服务器上使用Go Playgoround运行示例代码。
    weinxin
    版权声明
    本站原创文章转载请注明文章出处及链接，谢谢合作！
    ZONE.CI 全球网 | 安全领域涉猎者-乌云独行地带
    ZONE.CI 全球网
    安全领域涉猎者-乌云独行地带
    Go测试-《GO开发知识笔记》 编程

    Go测试-《GO开发知识笔记》

    单元测试测试函数测试函数的格式测试函数示例测试组子测试测试覆盖率基准测试基准测试函数格式基准测试示例性能比较函数重置时间并行测试Setup与TearDownTe
    11-040 评论
    ZONE.CI 全球网 | 安全领域涉猎者-乌云独行地带
    安全领域涉猎者-乌云独行地带
    ZONE.CI 全球网
    评论：0   参与：  0