GO 单元测试

概念

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

go test 基本用法

1. go test 测试用例放在 *_test.go 文件中，与被测函数放到同一个目录下面go build 时候不会构建成包一部分
2. 被测试用例函数命名 TestXXX. 第一个字母必须大写
3. 测试函数： 检测逻辑是否正确
4. 基准函数以BenChmark 为函数名称前缀， 衡量函数性能
5. 示例函数： 以Example 函数名称为前缀函数 提供编译器正确性的示例文档

go test 基础用例

1. 首先 GoLand 中go Test 不成熟，如果直接运行 会抛出 Undefined 的指令
   
2. 借助GoLand 对于指定方式 使用Generate 对需要函数产生对应的XX_test.go 文件
   
3. 只能 Teiminal 下：

4. 如果想 直接运行当前目录下所有测试用例： run go test,在当前目录下面右键即可
5. 如果指向单纯运行某个函数 需要 到该目录下面：
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 解决此问题

6. 在 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
}