GOLang单元测试用法详解

概念

单元测试 UT测试，针对程序来进行正确检测测试工作，一个优秀强壮代码 需要有完美的 UT测试用例

go test基本用法

• go test 测试用例放在 *_test.go 文件中，与被测函数放到同一个目录下面go build 时候不会构建成包一部分

• 被测试用例函数命名 TestXXX. 第一个字母必须大写

• 测试函数： 检测逻辑是否正确

• 基准函数以BenChmark 为函数名称前缀， 衡量函数性能

• 示例函数： 以Example 函数名称为前缀函数 提供编译器正确性的示例文档

go test 基础用例

首先 GoLand 中go Test 不成熟，如果直接运行 会抛出 Undefined 的指令

借助GoLand 对于指定方式 使用Generate 对需要函数产生对应的XX_test.go 文件

只能 Teiminal 下：

如果想 直接运行当前目录下所有测试用例： run go test,在当前目录下面右键即可
如果指向单纯运行某个函数 需要 到该目录下面：

go test -v -run TestXXX 即可

goLand 给我们产生的单元测试使用用例 值需要我们字节填写对应 name(测试用例名称)，args(数组，输入参数) want(返回参数)

type args struct {
s string
}
tests := []struct {
name string
args args
want bool
}{
// TODO: Add test cases.
{
"test1",
args{
"kafka",
},
true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := IsPalindrome(tt.args.s); got != tt.want {
t.Errorf("IsPalindrome() = ％v, want ％v", got, tt.want)
}
})
}

使用 Go mod 解决此问题

在 GoPATH目录下 手动窗口 bin, pkg, src 三个目录

配置 Go Moudle 路径

直接运行GOLand 即可

go test -v : 测试函数名字和运行时间
go test -v -run 对应正则表达式，测试函数与正确表达式匹配才会过滤 指定某个特定函数

测试可执行程序

用来测试一个可执行程序一个包的名字是main, 示例： 将程序拆分两个函数， echo 函数完成真正的工作 main 函数用于处理命令行参数和 echo可能返回错误

import (
   "flag"
   "fmt"
   "io"
   "os"
   "strings"
)
var (
   n = flag.Bool("n", false, "omit trailing newline")
   s = flag.String("s", " ", "separator")
)
var out io.Writer = os.Stdout // modified during testing
func main() {
   flag.Parse()
   if err := echo(!*n, *s, flag.Args()); err != nil {
       fmt.Fprintf(os.Stderr, "echo: ％v\n", err)
       os.Exit(1)
   }
}
func echo(newline bool, sep string, args []string) error {
   fmt.Fprint(out, strings.Join(args, sep))
   if newline {
       fmt.Fprintln(out)
   }
   return nil
}

import (
   "bytes"
   "fmt"
   "testing"
)
func TestEcho(t *testing.T) {
   var tests = []struct {
       newline bool
       sep     string
       args    []string
       want    string
   }{
       {true, "", []string{}, "\n"},
       {false, "", []string{}, ""},
       {true, "\t", []string{"one", "two", "three"}, "one\ttwo\tthree\n"},
       {true, ",", []string{"a", "b", "c"}, "a,b,c\n"},
       {false, ":", []string{"1", "2", "3"}, "1:2:3"},
   }
   for _, test := range tests {
       descr := fmt.Sprintf("echo(％v, ％q, ％q)",
           test.newline, test.sep, test.args)
       out = new(bytes.Buffer) // captured output
       if err := echo(test.newline, test.sep, test.args); err != nil {
           t.Errorf("％s failed: ％v", descr, err)
           continue
       }
       got := out.(*bytes.Buffer).String()
       if got != test.want {
           t.Errorf("％s = ％q, want ％q", descr, got, test.want)
       }
   }
}

外部测试包解决循环依赖

外部测试主要用来 解决 测试过程中循环依赖问题， GO语言中禁止包进行循环依赖，解决一个下层包的测试代码导入上层包的这种行为解决方案：z在net.url 包所在目录声明一个独立url_test 测试包，其中包名_test 后缀告诉go test 工具创建一个额外包进行允许测试

测试覆盖比例

go test -run=Coverage -coverprofile=c.out gopl.io/ch7/eval

go tool cover -html=c.out

测试基准函数

在固定的工作负载下的性能，一Benchmark 前缀

go test -bench=IsPalindrome , . 表示匹配所有基准测试函数

func BenchmarkIsPalindrome(b *testing.B) {
for i := 0; i < b.N; i++ {
IsPalindrome("A man, a plan, a canal: Panama")
}
}
goos: windows
goarch: amd64
pkg: goprograme/src
cpu: Intel(R) Core(TM) i5-3210M CPU @ 2.50GHz
BenchmarkIsPalindrome
BenchmarkIsPalindrome-4          2308773               502.9 ns/op

1. 基准函数数字后缀 -4 表示运行时候对应 GOMAXPROCS 值， 与并发相关的基准测试重要信息
2. 每个调用函数 花费时间 502.9 微妙
3. 明显 上面 函数 判断是 第二个函数 使用 

1.n := len(letters) /2 z只比较一般方式优化 测试后只是改进 提升 4％

2. 在每个字符预先分配一个足够大的数组，这样避免在append 函数时候可能导致内存多次重新分配
-- 通过性能工具的测试 从而优化我们的程序

func IsPalindrome(s string) bool {
   letters := make([]rune, 0, len(s))
   for _, r := range s {
       if unicode.IsLetter(r) {
           letters = append(letters, unicode.ToLower(r))
       }
   }
   n := len(letters) / 2
   for i := 0; i < n; i++ {
       if letters[i] != letters[len(letters)-1-i] {
           return false
       }
   }
   return true
}

来源：https://blog.csdn.net/qq_27217017/article/details/125829414