Golang单元测试对文件名和方法名，参数都有很严格的要求。
例如：
1、文件名必须以xx_test.go命名
2、方法必须是Test[^a-z]开头（T必须大写），func TestXxx (t *testing.T),Xxx部分可以为任意的字母数字的组合，但是首字母不能是小写字母[a-z]，例如Testintdiv是错误的函数名。
3、方法参数必须 t *testing.T
4、测试用例会按照源代码中写的顺序依次执行
5、函数中通过调用testing.T的Error, Errorf, FailNow, Fatal, FatalIf方法，说明测试不通过，调用Log方法用来记录测试的信息。
test的运行方式：
其中后面的test为test目录
Go 提供了 TestMain(*testing.M) 的函数，它在需要的时候代替运行所有的测试。使用 TestMain() 函数时，您有机会在测试运行之前或之后插入所需的任何自定义代码，但唯一需要注意的是必须处理 flag 解析并使用测试结果调用 os.Exit()。这听起来可能很复杂，但实际上只有两行代码。
测试的覆盖率
go tool命令可以报告测试覆盖率统计。使用 go test -cover 测试覆盖率。
可视化查看覆盖率：
执行go tool cover -html=cover.out命令，会在/tmp目录下生成目录coverxxxxxxx，比如/tmp/cover404256298。目录下有一个 coverage.html文件。用浏览器打开coverage.html，即可以可视化的查看代码的测试覆盖情况。
从内部测试
golang中大多数测试代码都是被测试包的源码的一部分。这意味着测试代码可以访问包种未导出的符号以及内部逻辑。就像我们之前看到的那样。
注：比如$GOROOT/src/pkg/path/path_test.go与path.go都在path这个包下。
从外部测试
有些时候，你需要从被测包的外部对被测包进行测试，比如测试代码在package foo_test下，而不是在package foo下。这样可以打破依赖循环。
1、功能测试
上一个完整的例子：
// how to run: go test -v github.com/welhzh/dago/test
package client import (
"flag"
"fmt"
"os"
"testing" "github.com/welhzh/dago/client"
) func initTest() {
} func destroyTest() {
}
// test example
func TestSum(t *testing.T) {
// 任选一种测试方式进行测试
// ================= test 方式一 ====================
var testInputs = []struct {
slice []int
// other inputs
expect int
}{
{[]int{, , , , }, },
{[]int{, , , , -}, },
} for _, oneInput := range testInputs {
actual := oneInput.slice[]
if actual != oneInput.expect {
t.Errorf("Sum(%q, %q) = %v; want %v", oneInput, oneInput, actual, oneInput.expect)
}
}
// ================================================= // ================= test 方式二 ====================
t.Run("[1,2,3,4,5]", testSumFunc(testInputs[].slice, testInputs[].expect))
t.Run("[1,2,3,4,-5]", testSumFunc(testInputs[].slice, testInputs[].expect))
// =================================================
} func testSumFunc(numbers []int, expected int) func(*testing.T) {
return func(t *testing.T) {
actual := numbers[]
if actual != expected {
t.Error(fmt.Sprintf("Expected the sum of %v to be %d but instead got %d!", numbers, expected, actual))
}
}
} func TestMain(m *testing.M) {
fmt.Println("test begin ...")
initTest() flag.Parse()
exitCode := m.Run() destroyTest()
fmt.Println("test end ...")
// Exit
os.Exit(exitCode)
}
格式形如：
go test [-c] [-i] [build flags] [packages] [flags for test binary]
参数解读：
-c : 编译go test成为可执行的二进制文件，但是不运行测试。
-i : 安装测试包依赖的package，但是不运行测试。
关于build flags，调用go help build，这些是编译运行过程中需要使用到的参数，一般设置为空
关于packages，调用go help packages，这些是关于包的管理，一般设置为空
关于flags for test binary，调用go help testflag，这些是go test过程中经常使用到的参数
-test.v : 是否输出全部的单元测试用例（不管成功或者失败），默认没有加上，所以只输出失败的单元测试用例。
-test.run pattern: 只跑哪些单元测试用例
-test.bench patten: 只跑那些性能测试用例
-test.benchmem : 是否在性能测试的时候输出内存情况
-test.benchtime t : 性能测试运行的时间，默认是1s
-test.cpuprofile cpu.out : 是否输出cpu性能分析文件
-test.memprofile mem.out : 是否输出内存性能分析文件
-test.blockprofile block.out : 是否输出内部goroutine阻塞的性能分析文件
-test.memprofilerate n : 内存性能分析的时候有一个分配了多少的时候才打点记录的问题。这个参数就是设置打点的内存分配间隔，也就是profile中一个sample代表的内存大小。默认是设置为512 * 1024的。如果你将它设置为1，则每分配一个内存块就会在profile中有个打点，那么生成的profile的sample就会非常多。如果你设置为0，那就是不做打点了。
你可以通过设置memprofilerate=1和GOGC=off来关闭内存回收，并且对每个内存块的分配进行观察。
-test.blockprofilerate n: 基本同上，控制的是goroutine阻塞时候打点的纳秒数。默认不设置就相当于-test.blockprofilerate=1，每一纳秒都打点记录一下
-test.parallel n : 性能测试的程序并行cpu数，默认等于GOMAXPROCS。
-test.timeout t : 如果测试用例运行时间超过t，则抛出panic
-test.cpu 1,2,4 : 程序运行在哪些CPU上面，使用二进制的1所在位代表，和nginx的nginx_worker_cpu_affinity是一个道理
-test.short : 将那些运行时间较长的测试用例运行时间缩短
2、性能测试
如果需要进行性能测试，则函数开头使用Benchmark就可以了。
//性能测试
func BenchmarkFibonacci(b *testing.B) {
for i := ; i < b.N; i++ {
Fibonacci()
}
}
接下来执行这个性能测试：
$ go test -bench=. lib
PASS
BenchmarkFibonacci 5000000 436 ns/op
ok lib 2.608s
其中第二行输出表示这个函数运行了5000000次，平均运行一次的时间是436ns。
这个性能测试只测试参数为10的情况。如果有需要可以测试多个参数：
//测试参数为5的性能
func BenchmarkFibonacci5(b *testing.B) {
for i := ; i < b.N; i++ {
Fibonacci()
}
} //测试参数为20的性能
func BenchmarkFibonacci20(b *testing.B) {
for i := ; i < b.N; i++ {
Fibonacci()
}
}
运行一下：
$ go test -bench=. lib
PASS
BenchmarkFibonacci 5000000 357 ns/op
BenchmarkFibonacci5 100000000 29.5 ns/op
BenchmarkFibonacci20 50000 44688 ns/op
ok lib 7.824s
如果性能测试的方法非常多，那需要的时间就会比较久。可以通过-bench=参数设置需要运行的性能测试的函数：
$ go test -bench=Fibonacci20 lib
PASS
BenchmarkFibonacci20 50000 44367 ns/op
ok lib 2.677s
3、IO相关测试 （高级测试技术）
testing/iotest包中实现了常用的出错的Reader和Writer，可供我们在io相关的测试中使用。主要有：
触发数据错误dataErrReader，通过DataErrReader()函数创建
读取一半内容的halfReader，通过HalfReader()函数创建
读取一个byte的oneByteReader，通过OneByteReader()函数创建
触发超时错误的timeoutReader，通过TimeoutReader()函数创建
写入指定位数内容后停止的truncateWriter，通过TruncateWriter()函数创建
读取时记录日志的readLogger，通过NewReadLogger()函数创建
写入时记录日志的writeLogger，通过NewWriteLogger()函数创建
4、黑盒测试 （高级测试技术）
testing/quick包实现了帮助黑盒测试的实用函数 Check和CheckEqual。
Check函数的第1个参数是要测试的只返回bool值的黑盒函数f，Check会为f的每个参数设置任意值并多次调用，如果f返回false，Check函数会返回错误值 *CheckError。Check函数的第2个参数 可以指定一个quick.Config类型的config，传nil则会默认使用quick.defaultConfig。quick.Config结构体包含了测试运行的选项。
# /usr/local/go/src/math/big/int_test.go
func checkMul(a, b []byte) bool {
var x, y, z1 Int
x.SetBytes(a)
y.SetBytes(b)
z1.Mul(&x, &y) var z2 Int
z2.SetBytes(mulBytes(a, b)) return z1.Cmp(&z2) ==
} func TestMul(t *testing.T) {
if err := quick.Check(checkMul, nil); err != nil {
t.Error(err)
}
}
CheckEqual函数是比较给定的两个黑盒函数是否相等，函数原型如下：
func CheckEqual(f, g interface{}, config *Config) (err error)
5、http测试 （高级测试技术）
net/http/httptest包提供了HTTP相关代码的工具，我们的测试代码中可以创建一个临时的httptest.Server来测试发送HTTP请求的代码:
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "Hello, client")
}))
defer ts.Close()
res, err := http.Get(ts.URL)
if err != nil {
log.Fatal(err)
}
greeting, err := ioutil.ReadAll(res.Body)
res.Body.Close()
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s", greeting)
还可以创建一个应答的记录器httptest.ResponseRecorder来检测应答的内容：
handler := func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "something failed", http.StatusInternalServerError)
}
req, err := http.NewRequest("GET", "http://example.com/foo", nil)
if err != nil {
log.Fatal(err)
}
w := httptest.NewRecorder()
handler(w, req)
fmt.Printf("%d - %s", w.Code, w.Body.String())
6、在进程里测试 （高级测试技术）
当我们被测函数有操作进程的行为，可以将被测程序作为一个子进程执行测试。下面是一个例子：
//被测试的进程退出函数
func Crasher() {
fmt.Println("Going down in flames!")
os.Exit()
} //测试进程退出函数的测试函数
func TestCrasher(t *testing.T) {
if os.Getenv("BE_CRASHER") == "" {
Crasher()
return
}
cmd := exec.Command(os.Args[], "-test.run=TestCrasher")
cmd.Env = append(os.Environ(), "BE_CRASHER=1")
err := cmd.Run()
if e, ok := err.(*exec.ExitError); ok && !e.Success() {
return
}
t.Fatalf(
7、竞争检测 （高级测试技术）
当两个goroutine并发访问同一个变量，且至少一个goroutine对变量进行写操作时，就会发生数据竞争（data race）。
为了协助诊断这种bug，Go提供了一个内置的数据竞争检测工具。
通过传入-race选项，go tool就可以启动竞争检测。
$ go test -race mypkg // to test the package
$ go run -race mysrc.go // to run the source file
$ go build -race mycmd // to build the command
$ go install -race mypkg // to install the package
一个数据竞争检测的例子：
//testrace.go package main import “fmt”
import “time” func main() { var i int =
go func() {
for {
i++
fmt.Println("subroutine: i = ", i)
time.Sleep( * time.Second)
}
}() for {
i++
fmt.Println("mainroutine: i = ", i)
time.Sleep( * time.Second)
}
}
运行：
$ go run -race testrace.go
8、并发测试 （高级测试技术）testing with concurrency
当测试并发代码时，总会有一种使用sleep的冲动。大多时间里，使用sleep既简单又有效。
但大多数时间不是”总是“。
我们可以使用Go的并发原语让那些奇怪不靠谱的sleep驱动的测试更加值得信赖。
9、静态分析工具vet查找错误 （高级测试技术）
vet工具用于检测代码中程序员犯的常见错误：
– 错误的printf格式
– 错误的构建tag
– 在闭包中使用错误的range循环变量
– 无用的赋值操作
– 无法到达的代码
– 错误使用mutex
等等。
使用方法：
go vet [package]
10、Mocks和fakes （高级测试技术）
通过在代码中使用interface，Go可以避免使用mock和fake测试机制。
例如，如果你正在编写一个文件格式解析器，不要这样设计函数：
func Parser(f *os.File) error
作为替代，你可以编写一个接受interface类型的函数:
func Parser(r io.Reader) error
和bytes.Buffer、strings.Reader一样，*os.File也实现了io.Reader接口。