用go test -v 进行测试，-v显示所有详细信息
//测试文件以_test.go结尾
//函数名为TestXXX
func TestXXX(t *testing.T)
func TestMain(m *testing.M)
{
//导入数据
...
code:=m.Run()
...
//释放数据
os.Exit(code)
}
跳过某些测试用例：
执行go test -short
func TestTimeConsuming(t *testing.T) {
if testing.Short() {
t.Skip("short模式下会跳过该测试用例")
}
...
}
测试覆盖率：
执行go test test_test.go test.go --cover
单测Mock：
测试应该稳定和幂等。为保证测试不依赖于某个函数或者方法（比如读取文件内容，因文件内容不同导致测试结果不同），需要使用Mock机制
import "bou.ke/monkey"
func Patch(target, replacement interface{})//函数名、替代函数,为函数打桩
func Unpatch(target interface{}) //取消打桩
//示例：
func Hello(num int) string
monkey.Patch(Hello, func() string {
return ""
})
defer monkey.Unpatch(Hello)
基准测试：
以Benchmark为前缀的函数，参数必须是 b *testing.B，需要有一个for循环
//testing.B 类型提供以下方法来控制基准测试：
ResetTimer()//重置内存和计时器。
StopTimer()//停止计时器并记录时间。
StartTimer()//开始计时
ReportAllocs() //统计内存
B.N: 执行基准测试的次数
测试命令为：
go test [参数]，比如 go test -bench=. ，具体的命令参数及含义如下：
-bench regexp 性能测试，运行指定的测试函。
-bench . 运行所有的benchmark函数测试，指定名称则只执行具体测试方法而不是全部。
-benchmem 性能测试的时候显示测试函数的内存分配的统计信息。 /////
-count n 运行测试和性能多少此，默认一次。
-run regexp 只运行特定的测试函数。
-timeout t 测试时间如果超过 t 则panic，默认10分钟。
-v 显示测试的详细信息。
示例：
func BenchmarkFunc(b *testing.B) {
//init，不计入测试时间
b.ResetTimer()
for i := 0; i < b.N; i++ {
Func(1)
}
}
//并发基准测试
func BenchmarkFuncParallel(b *testing.B) {
b.ResetTimer()
b.RunParallel(func(pb *testing.pb){
for pb.Next(){
Func(1)
}
})
}
探索如何计算ns/op的（转载）
基准测试的测试结果一般是这样的： BenchmarkFib-xxx xxxx xxxx ns/op
那ns/op是怎么计算的呢？
探索一下...
测试代码1：
go
代码解读
复制代码
func testUnit() {
time.Sleep(200 * time.Millisecond)
}
func BenchmarkTestNsOp(b *testing.B) {
time.Sleep(1 * time.Second) // 模拟准备工作耗时
for i := 0; i < b.N; i++ {
testUnit()
}
time.Sleep(500 * time.Millisecond) // 模拟后置工作耗时
}
执行测试go test -v -bench=BenchmarkTestNsOp -run=^$ ./，测试结果：
text
代码解读
复制代码
BenchmarkTestNsOp
BenchmarkTestNsOp-12 1 1706702726 ns/op
PASS
ok go_reflect_1/test_benchmark/t1 2.086s
可以看到执行时间1.7s左右，当b.N等于1时，刚好是BenchmarkTestNsOp函数的执行耗时，因此可给出一个临时结论：ns/op = 测试用例执行的耗时 / b.N，但是这个结论不大准确，再看看如下的测试2。
测试代码2：
go
代码解读
复制代码
// testUnit 是被测函数
func testUnit() {
time.Sleep(200 * time.Millisecond)
}
func BenchmarkTestNsOp2(b *testing.B) {
start := time.Now()
b.StopTimer()
time.Sleep(1 * time.Second) // 模拟准备工作耗时
b.StartTimer()
testStart := time.Now()
for i := 0; i < b.N; i++ {
testUnit()
}
testCost := time.Since(testStart)
b.StopTimer()
time.Sleep(500 * time.Millisecond) // 模拟后置工作耗时
b.Logf("BenchmarkTestNsOp2 b.N:%d, test-cost:%v, all-cost:%v\n", b.N, testCost, time.Since(start))
}
执行go test -v -bench=BenchmarkTestNsOp2 -run=^$ ./，测试结果：
text
代码解读
复制代码
BenchmarkTestNsOp2
t1_test.go:123: BenchmarkTestNsOp2 b.N:1, test-cost:202.811446ms, all-cost:1.706372116s
t1_test.go:123: BenchmarkTestNsOp2 b.N:4, test-cost:814.561162ms, all-cost:2.320013451s
t1_test.go:123: BenchmarkTestNsOp2 b.N:5, test-cost:1.016851035s, all-cost:2.523482221s
BenchmarkTestNsOp2-12 5 203370351 ns/op
PASS
ok go_reflect_1/test_benchmark/t1 7.507s
分析测试结果：
如果按照临时结论：ns/op = 测试用例执行的耗时 / b.N，那此时的结果应该是ns/op = 2.5s / 5 = 0.5s，明显计算错误，因为实际上ns/op是203ms左右。
给出最终结论：ns/op = 测试用例执行测试的有效耗时 / b.N，这里所说的测试用例执行测试的有效耗时就等于代码中的test-cost，那按照最终结论来计算的话：ns/op = 1.0168s / 5，约等于203ms，结果正确！
