一、Go基础知识22、单元测试详解

一、编写单元测试用例

Go语言（也称为Golang）是一种开源的编程语言，具有简洁、高效、并发支持等特点。在Go语言中，单元测试是一种重要的测试方法，用于验证代码的各个单元（函数、方法等）是否按照预期进行工作。Go语言内置了一套测试框架。

举一个简单的Go语言单元测试的例子。假设有一个计算器的包，其中包含加法函数 Add 和减法函数 Sub。我们将编写单元测试来验证这两个函数的正确性。

首先，创建一个名为 calculator.go 的文件，包含以下代码：

// calculator.go
package calculator

// Add 函数用于两个整数相加
func Add(a, b int) int {
    return a + b
}

// Sub 函数用于两个整数相减
func Sub(a, b int) int {
    return a - b
}
1
2
3
4
5
6
7
8
9
10
11
12

接下来，创建一个名为 calculator_test.go 的文件，包含以下单元测试代码：

// calculator_test.go
package calculator

import "testing"

// TestAdd 函数用于测试 Add 函数
func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5

    if result != expected {
        t.Errorf("Add(2, 3) returned %d, expected %d", result, expected)
    }
}

// TestSub 函数用于测试 Sub 函数
func TestSub(t *testing.T) {
    result := Sub(5, 2)
    expected := 3

    if result != expected {
        t.Errorf("Sub(5, 2) returned %d, expected %d", result, expected)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

在这个例子中，我们使用了Go语言的测试框架，其中 TestAdd 和 TestSub 分别测试了 Add 和 Sub 函数。在每个测试函数中，我们调用相应的函数，然后使用 t.Errorf 函数来报告测试失败，并输出实际结果和期望结果。

接下来，打开命令行，进入包含这两个文件的目录，并运行以下命令来执行测试：

go test
1

如果一切正常，你将看到输出类似于以下内容：

PASS
ok      your/package/directory   0.001s
1
2

这表示所有的测试都通过了。如果有测试失败，将会显示相应的错误信息。

二、跳过耗时的测试用例

在Go语言中，你可以使用测试框架提供的 -short 标志来跳过耗时的单元测试用例。这个标志用于标识短测试，通常用于跳过那些可能需要较长时间才能完成的测试。通过这种方式，你可以在快速迭代和构建过程中跳过一些耗时的测试，以提高开发效率。

下面是一个简单的例子，演示如何在Go语言中使用 -short 标志跳过某些测试。假设有一个包含两个测试用例的文件 example_test.go：

// example_test.go
package example

import (
	"testing"
	"time"
)

// TestShort 单元测试用例，通常执行较快
func TestShort(t *testing.T) {
	time.Sleep(100 * time.Millisecond)
	// 你的测试逻辑...
}

// TestLong 单元测试用例，可能执行较长时间
func TestLong(t *testing.T) {
	time.Sleep(2 * time.Second)
	// 你的测试逻辑...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在这个例子中，TestShort 是一个执行较快的测试用例，而 TestLong 可能需要较长时间来完成。

现在，如果你想跳过那些执行时间较长的测试用例，可以在运行 go test 命令时使用 -short 标志。例如：

go test -short
1

这将会跳过执行时间较长的测试用例，只运行执行时间较短的测试用例。

在输出中，你可能会看到类似以下的内容：

=== RUN   TestShort
--- PASS: TestShort (0.10s)
PASS
ok      your/package/directory   0.120s
1
2
3
4

这表示只有 TestShort 被运行，并且通过了测试。TestLong 被跳过，因为我们使用了 -short 标志。

请注意，使用 -short 标志是一个约定，你需要在编写测试用例时考虑哪些测试是短暂的，并使用 -short 来标识它们。这样，在需要时，你可以选择性地跳过一些测试，以加快测试运行的速度。

三、基于表格驱动测试

Go语言中的表格驱动测试是一种测试方法，通过在测试用例中使用表格结构，可以轻松地测试同一函数或方法的多个输入和输出组合。

假设有一个包含两个函数的文件 math.go，其中包含一个加法函数 Add 和一个减法函数 Sub：

// math.go
package math

// Add 函数用于两个整数相加
func Add(a, b int) int {
    return a + b
}

// Sub 函数用于两个整数相减
func Sub(a, b int) int {
    return a - b
}
1
2
3
4
5
6
7
8
9
10
11
12

现在，我们将创建一个测试文件 math_test.go，使用表格驱动测试来测试这两个函数：

// math_test.go
package math

import (
	"testing"
)

// TestAddTableDriven 表格驱动测试 Add 函数
func TestAddTableDriven(t *testing.T) {
	// 定义测试用例的表格
	testCases := []struct {
		a, b     int
		expected int
	}{
		{1, 2, 3},   // 第一个测试用例
		{-1, 1, 0},  // 第二个测试用例
		{0, 0, 0},   // 第三个测试用例
		{10, -5, 5}, // 第四个测试用例
	}

	// 遍历测试用例表格
	for _, tc := range testCases {
		// 执行测试
		result := Add(tc.a, tc.b)

		// 检查结果是否符合预期
		if result != tc.expected {
			t.Errorf("Add(%d, %d) returned %d, expected %d", tc.a, tc.b, result, tc.expected)
		}
	}
}

// TestSubTableDriven 表格驱动测试 Sub 函数
func TestSubTableDriven(t *testing.T) {
	// 定义测试用例的表格
	testCases := []struct {
		a, b     int
		expected int
	}{
		{5, 2, 3},    // 第一个测试用例
		{10, 5, 5},   // 第二个测试用例
		{0, 0, 0},    // 第三个测试用例
		{-5, -10, 5}, // 第四个测试用例
	}

	// 遍历测试用例表格
	for _, tc := range testCases {
		// 执行测试
		result := Sub(tc.a, tc.b)

		// 检查结果是否符合预期
		if result != tc.expected {
			t.Errorf("Sub(%d, %d) returned %d, expected %d", tc.a, tc.b, result, tc.expected)
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

在这个例子中，我们定义了一个包含输入参数和期望输出的测试用例表格。然后，通过循环遍历表格中的每个测试用例，并对每个测试用例执行相应的函数。如果结果不符合预期，就使用 t.Errorf 报告测试失败。

运行测试的方式与之前相同：

go test
1

如果所有测试通过，你将看到类似以下的输出：

PASS
ok      your/package/directory   0.120s
1
2

表格驱动测试使得添加新的测试用例变得简单，只需在表格中添加新的行。

四、benchmark性能测试

在Go语言中，性能测试（Benchmark）是一种用于度量代码执行性能的测试方法。性能测试使用 testing 包提供的 Benchmark 函数，允许你对函数或方法的执行时间进行基准测试。

假设有一个包含两个函数的文件 math.go，其中包含一个加法函数 Add 和一个减法函数 Sub：

// math.go
package math

// Add 函数用于两个整数相加
func Add(a, b int) int {
    return a + b
}

// Sub 函数用于两个整数相减
func Sub(a, b int) int {
    return a - b
}
1
2
3
4
5
6
7
8
9
10
11
12

现在，我们将创建一个性能测试文件 math_benchmark_test.go，用于对 Add 函数进行性能测试：

// math_benchmark_test.go
package math

import (
	"testing"
)

// BenchmarkAdd 性能测试 Add 函数
func BenchmarkAdd(b *testing.B) {
	// 循环运行测试函数 b.N 次
	for i := 0; i < b.N; i++ {
		// 执行测试
		result := Add(2, 3)

		// 避免编译器优化删除对结果的引用
		_ = result
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在这个例子中，我们使用了 testing 包的 Benchmark 函数，并创建了一个 BenchmarkAdd 函数。在这个函数中，我们使用 b.N 来指定测试运行的次数，然后在循环中执行 Add 函数。我们还将结果存储在一个变量中，以防止编译器优化删除对结果的引用。

运行性能测试的方式如下：

go test -bench .
1

上述命令中的 . 表示运行当前目录下的所有性能测试。如果一切正常，你将看到类似以下的输出：

goos: linux
goarch: amd64
pkg: your/package/directory
BenchmarkAdd-4       1000000000               0.300 ns/op
PASS
ok      your/package/directory   0.318s
1
2
3
4
5
6

输出中的 BenchmarkAdd-4 表示运行在 4 个 CPU 核心上的 BenchmarkAdd 函数的性能测试。1000000000 表示测试运行的次数，0.300 ns/op 表示每次操作的平均纳秒数。

通过性能测试，你可以了解到函数在不同输入条件下的执行时间，以便进行性能优化或对比不同实现的性能。
请注意，性能测试的结果可能受到多种因素的影响，包括硬件、操作系统和其他正在运行的程序。因此，谨慎解释和使用性能测试的结果是很重要的。

五、主要参数

1、-bench regexp

• 解释： 运行与指定的正则表达式匹配的基准测试。
• 使用方式： go test -bench=RegExp，其中RegExp是一个正则表达式，用于匹配要运行的基准测试函数的名称。
• 导致结果： 只有函数名与指定的正则表达式匹配的基准测试将被运行。

2、-cover

• 解释： 启用测试覆盖率分析。
• 使用方式： go test -cover，在测试运行时收集覆盖率数据。
• 导致结果： 测试完成后，将输出每个文件的代码覆盖率统计。

3、-race

• 解释： 启用数据竞争检测。
• 使用方式： go test -race，对测试执行数据竞争检测。
• 导致结果： 如果测试中存在数据竞争，测试会报错并提供相关信息。

4、-v

• 解释： 详细模式，打印所有测试的名称和运行时间。
• 使用方式： go test -v，在测试运行时输出详细的测试信息。
• 导致结果： 输出更详细的测试执行信息，包括每个测试的名称和运行时间。

5、-run regexp

• 解释： 运行与指定的正则表达式匹配的测试函数。
• 使用方式： go test -run=RegExp，其中RegExp是一个正则表达式，用于匹配要运行的测试函数的名称。
• 导致结果： 只有函数名与指定的正则表达式匹配的测试将被运行。

6、-short

• 解释： 启用短模式测试。
• 使用方式： go test -short，在测试函数中，可以使用testing.Short()来决定是否跳过某些长时间运行的测试。
• 导致结果： 测试运行时将跳过那些标记为长时间运行的测试。

7、-timeout d

• 解释： 设置测试的超时时间。
• 使用方式： go test -timeout=d，其中d是时间持续值，如5s、2m等。
• 导致结果： 如果测试运行时间超过指定时间，测试将被中断并报错。

8、-parallel n

• 解释： 设置并行运行测试的最大数量。
• 使用方式： go test -parallel=n，其中n指定了可以并行运行的测试的最大数量。
• 导致结果： 测试将并行运行，但并行数量不会超过指定的数量。