Go-知识测试-子测试

Go-知识测试-子测试

• 1. 介绍
• 2. 例子
• 3. 子测试命名规则
• 4. 选择性执行
• 5. 子测试并发
• 6. testing.T.Run
• 7. testing.T.Parallel
• 8. 子测试适用于单元测试
• 9. 子测试适用于性能测试
• 10. 总结
• • 10.1 启动子测试 Run
  • 10.2 启动并发测试 Parallel

建议先看：https://blog.csdn.net/a18792721831/article/details/140062769

Go-知识测试-工作机制

1. 介绍

子测试提供了一种在一个测试函数中执行多个测试的能力，可以自己编排执行顺序，或者做一些初始化等操作。

2. 例子

比如如下代码：

import "testing"  func SubA(t *testing.T) { 	t.Log("test A " + t.Name()) }  func SubB(t *testing.T) { 	t.Log("test B " + t.Name()) }  func SubC(t *testing.T) { 	t.Log("test C " + t.Name()) }  func TestSub(t *testing.T) { 	t.Run("name=A", SubA) 	t.Run("name=B", SubB) 	t.Run("name=C", SubC) } 

使用go test -v xx_test.go执行

3. 子测试命名规则

Run()方法的第一个参数作为子测试的名字，这里只是本层级的名字。
实际上子测试的内部命名规则是： <父测试名字>/<传递给Run的名字>
比如我们在B里面在调用A：

执行后：

name具有传递性

4. 选择性执行

在上面我们有 name=A,name=B,name=C 三个测试，如果只是想执行A呢
使用go test -v xx_test.go -run TestSub/name=A

选择性执行的字符串，是包含匹配，不是严格的正则匹配。

5. 子测试并发

可以看到，前面的子测试都是根据代码顺序执行，串行执行，并没有并发。
使用 t.Parallel 可以让当前测试函数允许并发。
比如如下例子不加并发的时候：

import ( 	"testing" 	"time" )  func SubA(t *testing.T) { 	t.Log("test A " + t.Name()) 	time.Sleep(time.Second*3) }  func SubB(t *testing.T) { 	t.Log("test B " + t.Name()) 	time.Sleep(time.Second*2) }  func SubC(t *testing.T) { 	time.Sleep(time.Second*1) 	t.Log("test C " + t.Name()) }  func TestSub(t *testing.T) { 	t.Run("name=A", SubA) 	t.Run("name=B", SubB) 	t.Run("name=C", SubC) } 

执行后用时超过6秒

允许并发：

import ( 	"testing" 	"time" )  func SubA(t *testing.T) { 	t.Parallel() 	t.Log("test A " + t.Name()) 	time.Sleep(time.Second * 3) }  func SubB(t *testing.T) { 	t.Parallel() 	t.Log("test B " + t.Name()) 	time.Sleep(time.Second * 2) }  func SubC(t *testing.T) { 	t.Parallel() 	time.Sleep(time.Second * 1) 	t.Log("test C " + t.Name()) }  func TestSub(t *testing.T) { 	t.Run("name=A", SubA) 	t.Run("name=B", SubB) 	t.Run("name=C", SubC) } 

A最先被调度，但是确是最后执行完毕。

需要注意的是，当开启子测试并发后，调用了子测试后，父测试的代码和子测试代码执行顺序就是随机的了。
所以如果在主测试中需要做一些初始化，然后在执行子测试，那么需要注意，有可能初始化还未完成，子测试已经开始执行了。

6. testing.T.Run

// 将运行f作为名为name的t的子测试。它在一个单独的goroutine中运行f // 并且阻塞直到f返回或调用t。并行成为并行测试。 // 运行报告f是否成功（或者至少在调用t.Parallel之前没有失败）。 // // Run可以从多个goroutine同时调用，但所有此类调用 // 必须在t的外部测试函数返回之前返回。 func (t *T) Run(name string, f func(t *T)) bool { 	atomic.StoreInt32(&t.hasSub, 1) 	testName, ok, _ := t.context.match.fullName(&t.common, name) 	if !ok || shouldFailFast() { 		return true 	} 	//记录此调用点的堆栈跟踪，以便如果子测试 	//在单独的堆栈中运行的函数被标记为助手，我们可以 	//继续将堆栈遍历到父测试中。 	var pc [maxStackLen]uintptr 	n := runtime.Callers(2, pc[:]) 	t = &T{ 		common: common{ 			barrier: make(chan bool), 			signal:  make(chan bool, 1), 			name:    testName, 			parent:  &t.common, 			level:   t.level + 1, 			creator: pc[:n], 			chatty:  t.chatty, 		}, 		context: t.context, 	} 	t.w = indenter{&t.common} 	if t.chatty != nil { 		t.chatty.Updatef(t.name, "=== RUN   %s\n", t.name) 	} 	//而不是在调用之前减少此测试的运行计数 	//tRunner并在之后增加它，我们依靠tRunner保持 	//计数正确。这样可以确保运行一系列顺序测试 	//而不会被抢占，即使它们的父级是并行测试。这 	//如果*parallel＝＝1，则可以特别减少意外。 	go tRunner(t, f) 	if !<-t.signal { 		//此时，FailNow很可能是在 		//其中一个子测验的家长测验。继续中止链的上行。 		runtime.Goexit() 	} 	return !t.failed } 

在testing.Run中，会创建一个testing.T对象，然后将调用者作为parent，然后调用testing.tRunner执行。
同时会设置父测试有子测试的标志：hasSub。
一个树形结构，父测试不知道有哪些子测试，但是父测试知道需要等待子测试执行完成。

7. testing.T.Parallel

// 与此测试并行运行的并行信号（且仅与） // 其他平行测试。当测试由于使用而多次运行时 // -test.count或-test.cpu，单个测试的多个实例从未在中运行 // 彼此平行。 func (t *T) Parallel() { 	if t.isParallel { 		panic("testing: t.Parallel called multiple times") 	} 	if t.isEnvSet { 		panic("testing: t.Parallel called after t.Setenv; cannot set environment variables in parallel tests") 	} 	t.isParallel = true 	if t.parent.barrier == nil { 		// T.Parallel has no effect when fuzzing. 		// Multiple processes may run in parallel, but only one input can run at a 		// time per process so we can attribute crashes to specific inputs. 		return 	} 	//我们不想把等待串行测试的时间包括在内 	//在测试持续时间内。记录到目前为止经过的时间，并重置 	//计时器之后。 	t.duration += time.Since(t.start) 	//添加到要由父级发布的测试列表中。 	t.parent.sub = append(t.parent.sub, t) 	t.raceErrors += race.Errors() 	if t.chatty != nil { 		//不幸的是，即使PAUSE表示命名测试是*no 		//运行时间较长*，cmd/test2json将其解释为更改活动测试 		//用于日志解析。我们可以修复cmd/test2json，但是 		//不会修复已经shell的第三方工具的现有部署 		//向外扩展到cmd/test2json的旧版本——因此仅修复cmd/test1json 		//目前还不够。 		t.chatty.Updatef(t.name, "=== PAUSE %s\n", t.name) 	} 	t.signal <- true   // Release calling test. 	<-t.parent.barrier // Wait for the parent test to complete. 	t.context.waitParallel() 	if t.chatty != nil { 		t.chatty.Updatef(t.name, "=== CONT  %s\n", t.name) 	} 	t.start = time.Now() 	t.raceErrors += -race.Errors() } 

设置当前testing.T的并发状态为true，因为Parallel在子测试中调用的，因此testing.T是子测试的T。
testing.Run是在父测试中调用的，因此testing.T是父测试。
将当前子测试加入到父测试的sub列表中，由父测试启动。

8. 子测试适用于单元测试

在testing.common中，hasSub表示是否有子测试，sub 则是子测试列表(testing.T)

在testing.tRunner中，有对子测试相关的支持

if len(t.sub) > 0 表示，如果有子测试，那么触发子测试执行，并且等待子测试执行完成。
else if t.isParallel 表示，如果是允许并发的，那么释放锁。
testing.tRunner 不管是父测试，还是子测试，都会执行。

9. 子测试适用于性能测试

在testing.B.Run中，设置父测试的hasSub标志为1。

并且创建一个testing.B，通过先调用testing.B.run1在调用testing.B.run执行。
并且子测试的数据会附加到父测试的报告中。

10. 总结

10.1 启动子测试 Run

Run 函数启动一个单独的协程来运行名字为name的子测试f，并且会阻塞等待其执行结束，除非子测试f显式调用Parallel将自己编程一个可并行的测试，最后返回bool类型的测试结果。
所有的测试，都是由TestMain使用Run方法直接或者间接启动。
每启动一个子测试，都会创建一个testing.T或者testing.B变量，该变量集成当前测试的部分属性，然后以新的
协程执行，当前测试会在子测试结束后返回子测试的结果。
子测试退出条件要么是子测试执行结束，要么是子测试设置了Parallel，否则是异常退出。

10.2 启动并发测试 Parallel

Parallel方法将当前测试加入并发队列。
启动并发测试，在排队等待过程中，消耗的时间不能统计到测试的耗时内，所以在测试真正被并发调度后，清空等待时间。