为go程序编写测试用例

原文地址

本文是我的一些总结和记录。

Go 如何编写测试用例

Go语言中自带有一个轻量级的测试框架testing，使用自带的go test命令来实现单元测试和性能测试。可以基于这个框架写针对相应函数的测试用例，也可以基于该框架写相应的压力测试用例。

建议安装gotests插件自动生成测试代码

go get -u -v github.com/cweill/gotests/…

普通测试

go test 命令会执行当前目录下的测试文件，测试代码和被测代码放在同一目录下。

接下来我们在该目录下面创建两个文件：gotest.go和gotest_test.go

gotest.go:这个文件里面我们是创建了一个包，里面有一个函数实现了除法运算:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    package gotest

    import (
        "errors"
    )

    func Division(a, b float64) (float64, error) {
        if b == 0 {
            return 0, errors.New("除数不能为0")
        }

        return a / b, nil
    }

测试文件的规则:
- 文件名必须是_test.go结尾的，这样在执行go test的时候才会执行到相应的代码。
- 你必须import testing这个包 .
- 所有的测试用例函数必须是Test开头
- 测试用例会按照源代码中写的顺序依次执行
- 测试函数TestXxx()的参数是testing.T，我们可以使用该类型来记录错误或者是测试状态
- 测试格式：func TestXxx (t *testing.T),Xxx部分可以为任意的字母数字的组合，但是首字母不能是小写字母[a-z]，例如Testintdiv是错误的函数名。
- 函数中通过调用testing.T的Error, Errorf, FailNow, Fatal, FatalIf方法，说明测试不通过，调用Log方法用来记录测试的信息。

测代码 gotest_test.go ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package gotest
	
	import (
		"testing"
	)
	
	func Test_Division_1(t *testing.T) {
		if i, e := Division(6, 2); i != 3 || e != nil { //try a unit test on function
			t.Error("除法函数测试没通过") // 如果不是如预期的那么就报错
		} else {
			t.Log("第一个测试通过了") //记录一些你期望记录的信息
		}
	}
	
	func Test_Division_2(t *testing.T) {
		t.Error("就是不通过")
	}

我们在项目目录下面执行 go test ,就会显示如下信息：

	--- FAIL: Test_Division_2 (0.00 seconds)
		gotest_test.go:16: 就是不通过
	FAIL
	exit status 1
    FAIL	gotest	0.013s

从这个结果显示测试没有通过，因为在第二个测试函数中我们写死了测试不通过的代码t.Error，那么我们的第一个函数执行的情况怎么样呢？默认情况下执行 go test 是不会显示测试通过的信息的。

我们需要带上参数 go test -v ，这样就会显示如下信息：

	=== RUN Test_Division_1
	--- PASS: Test_Division_1 (0.00 seconds)
		gotest_test.go:11: 第一个测试通过了
	=== RUN Test_Division_2
	--- FAIL: Test_Division_2 (0.00 seconds)
		gotest_test.go:16: 就是不通过
	FAIL
	exit status 1
    FAIL	gotest	0.012s

上面的输出详细的展示了这个测试的过程，我们看到测试函数1Test_Division_1测试通过，而测试函数2Test_Division_2测试失败了，最后得出结论测试不通过。接下来我们把测试函数2修改成如下代码：

压力测试

压力测试用例必须遵循如下格式，其中XXX可以是任意字母数字的组合，但是首字母不能是小写字母,必须是导出的。

func BenchmarkXXX(b *testing.B) { … }
go test不会默认执行压力测试的函数，如果要执行压力测试需要带上参数-test.bench，语法:-test.bench=”test_name_regex”,例如go test -test.bench=”.*“表示测试全部的压力测试函数。
在压力测试用例中,请记得在循环体内使用testing.B.N,以使测试可以正常的运行。
文件名也必须以_test.go结尾

压力测试代码 webbench_test.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package gotest

import (
	"testing"
)

func Benchmark_Division(b *testing.B) {
	for i := 0; i < b.N; i++ { //use b.N for looping 
		Division(4, 5)
	}
}

func Benchmark_TimeConsumingFunction(b *testing.B) {
	b.StopTimer() //调用该函数停止压力测试的时间计数

	//做一些初始化的工作,例如读取文件数据,数据库连接之类的,
	//这样这些时间不影响我们测试函数本身的性能

	b.StartTimer() //重新开始时间
	for i := 0; i < b.N; i++ {
		Division(4, 5)
	}
}

原文中执行命令 go test webbench_test.go -test.bench=”.*“ 能够看到测试结果输出：

Benchmark_Division-4   	                     500000000	      7.76 ns/op	     456 B/op	      14 allocs/op
Benchmark_TimeConsumingFunction-4            500000000	      7.80 ns/op	     224 B/op	       4 allocs/op
PASS
ok  	gotest	9.364s

上面的结果显示我们没有执行任何TestXXX的单元测试函数，显示的结果只执行了压力测试函数，第一条显示了Benchmark_Division执行了500000000次，每次的执行平均时间是7.76纳秒，第二条显示了Benchmark_TimeConsumingFunction执行了500000000，每次的平均执行时间是7.80纳秒。最后一条显示总共的执行时间。

但是我使用vscode 编写的环境下在终端执行命令提示找不到Division函数，不过可以用vscode 自带的插件运行成功。看了下vscode 执行的过程发现使用的命令是：

go test -benchmem -run=^$ go-xie-tutorials/11-gotest/gotest -bench ^(Benchmark_TimeConsumingFunction)$

尝试自己在终端输入，最后发现在我环境下可以正常执行的命令是：

go test -benchmem -run=gotest -bench Ben*

会执行Ben开头的所有测试函数，结果如下：

goos: linux
goarch: amd64
pkg: go-xie-tutorials/11-gotest/gotest
Benchmark_Division-4                    2000000000               0.35 ns/op            0 B/op          0 allocs/op
Benchmark_TimeConsumingFunction-4       2000000000               0.35 ns/op            0 B/op          0 allocs/op
PASS
ok      go-xie-tutorials/11-gotest/gotest       1.521s

结果看起来差不多，但是B 和allocs 都是0，不知道哪里有问题。

通过上面对单元测试和压力测试的学习，我们可以看到testing包很轻量，编写单元测试和压力测试用例非常简单，配合内置的go test命令就可以非常方便的进行测试，这样在我们每次修改完代码,执行一下go test就可以简单的完成回归测试了。

使用defer会产生额外的消耗

来看一个例子：

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import (
)

func  DoDefer(key,value string) {
	defer func(key,value string) {
		_ = key + value
	}(key,value)
}

func DoNotDefer(key,value string) {
	_ = key + value
}

测试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
	"testing"
)

func BenchmarkDoDefer(b *testing.B) {
	for i := 0; i < b.N; i++ {
		DoDefer("煎鱼", "https://github.com/EDDYCJY/blog")
	}
}

func BenchmarkDoNotDefer(b *testing.B) {
	for i := 0; i < b.N; i++ {
		DoNotDefer("煎鱼", "https://github.com/EDDYCJY/blog")
	}
}

go test -bench=. -benchmem -run=none
结果:

1
2
3
4
5
6
7
goos: linux
goarch: amd64
pkg: myfile/benchmark-test
BenchmarkDoDefer-4              20000000                95.9 ns/op            48 B/op          1 allocs/op
BenchmarkDoNotDefer-4           30000000                48.3 ns/op            48 B/op          1 allocs/op
PASS
ok      myfile/benchmark-test   3.536s

关于defer的消耗问题可以参考Go defer 会有性能损耗

结论

一个 defer 关键字实际上包含了不少的动作和处理，和你单纯调用一个函数一条指令是没法比的。而与对照物相比，它确确实实是有性能损耗，目前延迟调用的全部开销大约在 50ns，但 defer 所提供的作用远远大于此，你从全局来看，它的损耗非常小，并且官方还不断地在优化中。

因此，对于 “Go defer 会有性能损耗，尽量不能用？” 这个问题，我认为该用就用，应该及时关闭就不要延迟，在 hot paths 用时一定要想清楚场景。最后补充上柴大的回复：“不是性能问题，defer 最大的功能是 Panic 后依然有效。如果没有 defer，Panic 后就会导致 unlock 丢失，从而导致死锁了”，非常经典

在最新的go 1.13 版本中 defer的新能提升了30%

– 返回顶部 –

上篇RESTful架构及Go语言的实现笔记

下篇gin框架的调用流程