【Go语言学习】——测试

最新推荐文章于 2024-08-29 16:10:17 发布

原创最新推荐文章于 2024-08-29 16:10:17 发布 · 471 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#学习 #单元测试 #压力测试

单元测试

参考博客

Go语言中的测试依赖go test命令，并在后面加上-v后可以显示详细信息。在包目录内，所有以_test.go为后缀名的源代码文件都是go test测试的一部分，不会被go build编译到最终的可执行文件中。在*_test.go文件中有三种类型的函数，单元测试函数、基准测试函数和示例函数。

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

单元测试

通过设置测试函数对函数功能进行测试，将输出和预期结果进行对比，如果不正确则设置对应的错误级别和错误信息。

package split_string

import "strings"

// 待测函数，切割字符串

func Split(str string, sep string) []string {
	var ret []string
	index := strings.Index(str, sep)
	for index >= 0 {
		if index != 0 {
			ret = append(ret, str[:index])
		}
		str = str[index+len(sep):]
		index = strings.Index(str, sep)
	}
	ret = append(ret, str)
	return ret
}

package split_string

// 单元测试函数

import (
	"reflect"
	"testing"
)

func TestSplit(t *testing.T) {
	// 程序输出的结果
	got := Split("babcbef", "b")
	// 程序期望的结果
	want := []string{"a", "c", "ef"}
	// 通过反射来帮助对比切片的结果
	if !reflect.DeepEqual(got, want) {
		// 测试失败则给出错误提示
		t.Errorf("want:%v but got: %v", want, got)
	}
}

func Test2Split(t *testing.T) {
	// 程序输出的结果
	got := Split("a:b:c", ":")
	// 程序期望的结果
	want := []string{"a", "b", "c"}
	// 通过反射来帮助对比切片的结果
	if !reflect.DeepEqual(got, want) {
		// 测试失败则给出错误提示
		t.Errorf("want:%v but got: %v", want, got)
	}
}

func Test3Split(t *testing.T) {
	// 程序输出的结果
	got := Split("abcef", "bc")
	// 程序期望的结果
	want := []string{"a", "ef"}
	// 通过反射来帮助对比切片的结果
	if !reflect.DeepEqual(got, want) {
		// 测试失败则给出错误提示
		t.Errorf("want:%v but got: %v", want, got)
	}
}

测试组

通过建立测试用例切片，然后循环执行所有的测试用例，减少代码的重复量。

package split_string

// 单元测试组函数

import (
	"reflect"
	"testing"
)

func TestSplitGroup(t *testing.T) {
	type testCase struct {
		str  string
		sep  string
		want []string
	}
	testGroup := []testCase{
		{"babcbef", "b", []string{"a", "c", "ef"}},
		{"a:b:c", ":", []string{"a", "b", "c"}},
		{"abcef", "bc", []string{"a", "ef"}},
		{"沙河有沙又有河", "沙", []string{"河有", "又有河"}},
	}

	for _, tc := range testGroup {
		got := Split(tc.str, tc.sep)
		if !reflect.DeepEqual(got, tc.want) {
			t.Fatalf("want:%v got:%#v", tc.want, got)
		}
	}
}

子测试

利用子测试可以查看所有测试用例对应的测试信息，并且可以通过在后面加上-run=测试用例名（与输出中测试用例名一致）只测试其中一个测试用例

package split_string

import (
	"reflect"
	"testing"
)

func TestSplitSub(t *testing.T) {
	type testCase struct {
		str  string
		sep  string
		want []string
	}
	testGroup := map[string]testCase{
		"case_1": {"babcbef", "b", []string{"a", "c", "ef"}},
		"case_2": {"a:b:c", ":", []string{"a", "b", "c"}},
		"case_3": {"abcef", "bc", []string{"a", "ef"}},
		"case_4": {"沙河有沙又有河", "沙", []string{"河有", "又有河"}},
	}

	for name, tc := range testGroup {
		// 利用t.run执行子测试，可以看到每个测试用例对应的测试结果
		t.Run(name, func(t *testing.T) {
			got := Split(tc.str, tc.sep)
			if !reflect.DeepEqual(got, tc.want) {
				t.Fatalf("want:%v got:%#v", tc.want, got)
			}
		})
	}
}

测试覆盖率

通过go test -cover可以查看代码测试的覆盖的百分比，Go还提供了一个额外的-coverprofile参数，用来将覆盖率相关的记录信息输出到一个文件，例如：
```
split $ go test -cover -coverprofile=c.out
PASS
coverage: 100.0% of statements
ok      github.com/Q1mi/studygo/code_demo/test_demo/split       0.005s
```
上面的命令会将覆盖率相关的信息输出到当前文件夹下面的c.out文件中，然后我们执行go tool cover -html=c.out，使用cover工具来处理生成的记录信息，该命令会打开本地的浏览器窗口生成一个HTML报告。通常测试函数覆盖率要求100%，测试覆盖率60%

基准测试

基准测试就是在一定的工作负载之下检测程序性能的一种方法，它的定义是Benchmark为前缀，需要一个*testing.B类型的参数b，基准测试必须要执行b.N次。基准测试并不会默认执行，需要增加-bench参数。针对不同的优化方法比较输出结果来改进。

package split_string

import "testing"

// 基准测试

// 执行N遍测试性能
func BenchmarkSplit(b *testing.B) {
	// 这里的N是个未知数，尽量去跑到最大值
	for i := 0; i < b.N; i++ {
		Split("a:b:c", ":")
	}
}

运行go test -bench=Split命令执行基准测试，输出结果如下。其中数字12表示GOMAXPROCS（CPU内核数）的值，这个对于并发基准测试很重要。14801511 和78.45 ns/op表示每次调用Split函数耗时78.45ns

PS E:\GoWorkPlace\src\github.com\studygo\split_string> go test -bench=Split
goos: windows
goarch: amd64
pkg: github.com/studygo/split_string
cpu: Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz
BenchmarkSplit-12       14801511                78.45 ns/op
PASS
ok      github.com/studygo/split_string 1.412s

通过基准测试添加-benchmem参数，来获得内存分配的统计数据。其中48 B/op表示每次操作内存分配了48字节，1 allocs/op则表示每次操作进行了1次内存分配

PS E:\GoWorkPlace\src\github.com\studygo\split_string> go test -bench=Split -benchmem
goos: windows
goarch: amd64
pkg: github.com/studygo/split_string
cpu: Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz
BenchmarkSplit-12       15303565                75.82 ns/op           48 B/op          1 allocs/op
PASS
ok      github.com/studygo/split_string 1.407s

性能比较函数

性能比较函数通常是一个带有参数的函数，被多个不同的Benchmark函数传入不同的值来调用。

// 测试斐波那契数列性能
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) }

运行测试时可以在-bench=后写上公共函数名称前缀就可以调用所有对比的函数

PS E:\GoWorkPlace\src\github.com\studygo\split_string> go test -bench=Fib
goarch: amd64
pkg: github.com/studygo/split_string
cpu: Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz
BenchmarkFib1-12        844466212                1.386 ns/op
BenchmarkFib2-12        260821142                4.507 ns/op
BenchmarkFib3-12        168101977                7.047 ns/op
BenchmarkFib10-12        4449705               266.5 ns/op
BenchmarkFib20-12          35829             33102 ns/op
BenchmarkFib40-12              2         503109500 ns/op
PASS
ok      github.com/studygo/split_string 9.411s

默认情况下，每个基准测试至少运行1秒。如果在Benchmark函数返回时没有到1秒，则b.N的值会按1,2,5,10,20,50，…增加，并且函数再次运行。因此针对一次运行时间较长的函数可以-benchtime标志增加最小基准时间，以产生更准确的结果。

时间重置

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

func BenchmarkSplit(b *testing.B) {
	time.Sleep(5 * time.Second) // 假设需要做一些耗时的无关操作
	b.ResetTimer()              // 重置计时器
	for i := 0; i < b.N; i++ {
		Split("沙河有沙又有河", "沙")
	}
}

并行测试

func (b *B) RunParallel(body func(*PB))会以并行的方式执行给定的基准测试。

RunParallel会创建出多个goroutine，并将b.N分配给这些goroutine执行，其中goroutine数量的默认值为GOMAXPROCS。用户如果想要增加非CPU受限（non-CPU-bound）基准测试的并行性，那么可以在RunParallel之前调用SetParallelism 。RunParallel通常会与-cpu标志一同使用。
```
func BenchmarkSplitParallel(b *testing.B) {
	// b.SetParallelism(1) // 设置使用的CPU数
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			Split("沙河有沙又有河", "沙")
		}
	})
}
```
还可以通过在测试命令后添加-cpu参数如go test -bench=. -cpu 1来指定使用的CPU数量。