单元测试和基准测试

本文已参与好文召集令活动，点击查看：后端、大前端双赛道投稿，2万元奖池等你挑战！

在平时，经过代码实战部分你能够看到，在写每一个功能的时候，都会编写测试代码。那是由于 TDD（Test-Driven Development，测试驱动开发）中提倡先编写测试代码，而后再编写功能代码，每作一个修改后，都要执行一次单元测试和基准测试，以此来验证功能和性能是否有问题。

特别是业务系统代码常常变动，单元测试和基准测试也就显得很是重要。而每种语言都有本身的测试框架，好比 Go 语言，它是门注重工程效率的语言，有着很是强大的工具链，它自带的测试框架，能知足咱们大部分测试要求。

因此，这里介绍如何使用 Go 测试框架作性能测试中的单元测试和基准测试。

单元测试

Go 测试框架中支持白盒测试和黑盒测试。如今我就以 xx.go 这个文件为例，给你详细介绍下如何作单元测试。

整体步骤

总的来讲，用 Go 测试框架作单元测试主要有这几个步骤。

• 第一，Go 测试框架要求测试代码文件名以 _test.go 结尾。为了测试 cache.go，咱们须要在 infrastructure/stores 目录下建立一个 cache_test.go 文件。

• 第二，cache_test.go 中第一行若是是 package stores，则表示该测试是白盒测试，这意味着除了这个包的全局函数外，你还能够测试它的私有函数；若是是 package stores_test，则表示黑盒测试，你只能够测试全局函数，里面的具体实现对于你来讲是个黑盒子。

• 第三，Go 测试框架要求单元测试函数须要以 Test 开头。为了测试 IntCache 和 ObjCache，咱们须要实现 TestIntCache 和 TestObjCache 这两个函数，它们的参数类型都是 testing.T 指针。

• 第四，在测试过程当中，若是发现错误，能够经过测试框架的 Error 方法或者 Fatal 方法输出错误。不一样的是，Error 方法仅仅输出错误，而 Fatal 方法却会结束当前测试。

• 第五，在终端进入项目根目录下，执行 go test ./infrastructure/stores 命令，将会执行 infrastructure/stores 目录下的全部单元测试。

结果一般会有三列：

1. 第一列是测试结果，ok 表示成功，FAIL 表示失败；

2. 第二列是被测试包的完整路径；

3. 第三列是执行测试耗费的时间。

当测试失败时，输出结果还会告诉你在哪一行报错了，格式一般是：第一行是测试函数，第二行是文件名和该文件的第几行，后面再跟上具体错误日志。好比，TestIntCache 这个测试函数在 cache_test.go 文件第 19 行报错。

覆盖率

在单元测试中，除了测试功能是否正常外，还有个很重要的指标：覆盖率。覆盖率用来衡量单元测试覆盖了多少代码，它是由覆盖测试统计出来的。覆盖率越高，说明单元测试越完备，对代码质量更有保障。

Go 的覆盖测试使用很简单，在 go test 命令后加上 -cover 参数便可。如执行 go test -cover ./infrastructure/stores 将会在以前的输出结果后面加上 coverage 开头的日志。好比 coverage: 61.0% of statements 。

虽然覆盖测试工具用起来很简单，但要想将覆盖率提高到 100% 则是很是困难。

第一，你须要找出来哪些地方没有覆盖到。

这里咱们须要用到 -coverprofile 参数，将详细的结果输出到文件中。好比 go test -coverprofile cover.out 即是将覆盖测试的结果输出到 cover.out 中。而后咱们用命令 go tool cover -html=cover.out -o cover.html 将测试结果输出为 html 文件，再用浏览器打开即可以看到哪些代码被单元测试覆盖到了，哪些没有被覆盖到。其中绿色部分表示已覆盖到的代码，红色部分表示没有覆盖到。效果以下：

咱们能够看到，Add 方法有大片代码没被测试覆盖到，咱们能够经过修改测试代码来覆盖这部分代码的测试。

第二，你须要对代码逻辑很是熟悉，特别是熟悉代码中的各类边界条件，并在测试代码中构造出这些边界条件来测试。

假如代码里有三个条件分支 A、B、C，你须要将这三个条件都构造出来，才能覆盖到它们各自分支下面的代码。这意味着，你在编写测试代码的时候，须要编写大量的测试用例，也就是构造大量的能触发边界条件的参数。若是没有好的代码功底，你的测试代码容易由于大量参数而变得混乱、臃肿。

有时候，一个功能可能会有多个参数，每一个参数又有多个边界值。当咱们采用控制变量法来测试的时候，全部参数的边界值又会产生多种组合，这个数量一般是每一个参数边界值数量的乘积。好比 A 参数有 2 个边界值，B 参数有 3 个边界值，那么将会存在 6 种组合 。为了便于管理，咱们须要将这些参数提取到核心测试代码以外，用数组和循环来管理测试用例。

好比咱们在测试 IntCache 的 Add 方法时，按照 key、delta 这两个参数的边界状况，就有 key 存在、不存在两种状况与 delta 为 -一、0、1 这三种状况的组合。咱们将 Add 方法的 key、delta 参数以及指望返回值的配置，用一个结构体数组来管理，并用循环遍历数组，根据数组中每一个元素的值调用 Add 方法并判断返回值与指望值是否相等。若是不相等则报错，输出有问题的测试用例，并终止测试。咱们能够获得以下代码：

func TestIntCache_Add(t *testing.T) {

   cache := NewIntCache()

   cases := []struct {

      key    string

      delta  int64

      expect int64

   }{

      {"test1", 0, 0},

      {"test1", 1, 1},

      {"test1", -1, 0},

      {"test1", 0, 0},

      {"test2", 1, 1},

      {"test3", -1, -1},

   }

   for _, c := range cases {

      if cache.Add(c.key, c.delta) != c.expect {

         t.Fatal(c)

      }

   }

}
复制代码

再次执行覆盖测试，你将看到代码覆盖率从 61.0% 提高到了 76.3%，Add 方法只剩下一行代码没覆盖到，而这行代码须要经过构造并发条件才能覆盖到。效果以下：

基准测试

基准测试属于性能测试，一般用于对具体的功能函数作性能分析，好比加密算法函数。基准测试须要有对比测试，以便衡量不一样代码实现之间的性能差别，从中选取性能最好的实现方式。

在 Go 测试框架中，基准测试函数须要以 Benchmark 开头。好比 BenchmarkIntCache_Set 表示对 IntCache 的 Set 方法进行基准测试。为了与 sync.Map 和 ObjCache 对比，咱们还须要实现 BenchmarkObjCache_Set 和 BenchmarkSyncMap_Set 这两个函数。

不过，当咱们要测试对象的方法比较多时，为每一个对象的每一个方法都实现一个独立的测试函数并非很方便。对此，咱们一般咱们采用分组测试的方式。Go 测试框架提供了一个 Run 方法可用于执行分组中的子测试，它有两个参数，第一个是子测试的名称，第二个是测试函数。

这里，咱们能够实现一个 BenchmarkCache_Set 函数来做为 Set 方法的测试组入口，里面包含 intCache、objCache、syncMap 这三个子测试。这样咱们能够为每一个子测试统一初始化公共资源，并复用核心代码逻辑。

为了复用代码，我实现了一个 benchmarkCacheSet 函数。它有三个参数：

• 测试框架生成的 testing.B 对象指针；

• setter 函数，它有 key 和 val 这两个参数，帮助设置被测对象中的 KV 值；

• 字符串数组 keys，表示用于测试的 key 集合。

在函数中，咱们调用框架的 ReportAllocs 方法，用于输出内存分配信息。在循环开始前，调用框架的 StartTimer 开始计时，循环结束后调用 StopTimer 结束计时。

在 BenchmarkCache_Set 中先初始化 keys，而后在三个子测试中分别初始化 IntCache、ObjCache、sync.Map，生成各自的 setter，并调用 benchmarkCacheSet 函数。

最终，咱们的测试代码以下：

func benchmarkCacheSet(b *testing.B, setter func(key string, val int64), keys []string) {

   b.ReportAllocs()

   b.StartTimer()

   l := len(keys)

   for i := 0; i < b.N; i++ {

      setter(keys[i%l], int64(i))

   }

   b.StopTimer()

}

func BenchmarkCache_Set(b *testing.B) {

   keys := make([]string, b.N, b.N)

   for i := 0; i < b.N; i++ {

      keys[i] = strconv.Itoa(i)

   }

   b.ResetTimer()

   b.Run("intCache", func(b *testing.B) {

      c := NewIntCache()

      setter := func(key string, val int64) {

         c.Set(key, val)

      }

      benchmarkCacheSet(b, setter, keys)

   })

   b.Run("objCache", func(b *testing.B) {

      c := NewObjCache()

      setter := func(key string, val int64) {

         c.Set(key, val)

      }

      benchmarkCacheSet(b, setter, keys)

   })

   b.Run("syncMap", func(b *testing.B) {

      c := sync.Map{}

      setter := func(key string, val int64) {

         c.Store(key, val)

      }

      benchmarkCacheSet(b, setter, keys)

   })

}
复制代码

咱们能够在终端执行命令 go test -bench=BenchmarkCache_Set ./infrastructure/stores 来运行上面实现的测试代码，你能够看到以 BenchmarkCache_Set 开头的三个子测试的结果。

须要注意的是，每一个子测试后面都有一个 -8，表示使用了 8 个 CPU 核。

另外，Go 测试框架默认会使用全部的 CPU 核，但因为电脑上一般会运行其余的程序，使用全部的核可能会致使不一样程序之间抢夺资源，影响测试结果。基于这一点，咱们能够在参数中指定 CPU 核数来测试。

具体来讲，咱们能够经过 -cpu 参数指定多种 CPU 核数来测试性能。好比，执行命令 go test -bench=BenchmarkCache_Set -cpu 1,2,3 ./infrastructure/stores 后，咱们将看到每一个子测试都用了不一样 CPU 核数来测试。不过，因为咱们的测试代码并无用到并发，所以测试结果不受 CPU 核数的影响。