开发中需要确认一个函数、模块结果是否正确

复制
func addUpper(n int)int{
   res:=0for i := 1; i <n ; i++ {
      res+=i
   }return res
}

传统方法测试就是调用这个函数，看返回结果是否正确

缺点：

1. 需要在main函数中调用，测试的时候去修改main函数，运行中的项目得停止来测试
2. 不利于管理，因为当我们测试多个函数或者多个模块时，都要写在main函数中，逻辑混乱
3. 引出党员测试，testing测试框架，可以很好解决问题

基本介绍

Go 语言中自带有一个轻量级的测试框架 testing 和自带的 go test 命令来实现单元测试和性能测试，testing 框架可以写测试用例、压力测试用例，

单元测试作用 ：

1. 确保每个函数是可运行，并且运行结果是正确的
2. 确保写出来的代码性能是好的，
3. 单元测试能及时的发现程序设计或实现的逻辑错误，使问题及早暴露，便于问题的定位解决， 而性能测试的重点在于发现程序设计上的一些问题，让程序能够在高并发的情况下还能保持稳定

单元测试

cal.go

复制
func AddUpper(n int)int{
   res:=0for i := 0; i < n; i++ {
      res += i
   }return res
}

cal_test.go

复制
//编写测试用例，测试addUpper是否正常
func TestAddUpper(t *testing.T) {
   res := AddUpper(10)if res != 55 {
      fmt.Println("AddUpper(10)执行错误，期望值=%v 实际值=%v", 55, res)}
 
   //输出日志
   t.Logf("AddUpper(10)执行正确")
}
C:\Users\55480\go\go\learn\testcase01>go test -v 
# learngo/learn/testcase01 
.\cat_test.go:15:3: Println call has possible formatting directive %v 
FAIL    learngo/learn/testcase01 [build failed] 

复制
# learngo/learn/testcase01 
.\cat_test.go:15:3: Println call has possible formatting directive %v 
FAIL    learngo/learn/testcase01 [build failed] 
 
C:\Users\55480\go\go\learn\testcase01>go test -v 
=== RUN   TestAddUpper 
AddUpper(10)执行错误，期望值=55 实际值=45    cat_test.go:18: AddUpper(10)执行正确 
--- PASS: TestAddUpper (0.00s) 
PASS 
ok      learngo/learn/testcase01        0.080s 

testing框架，会将xxx_test.go的文件加入，调用testXxx方法

总结

1. 测试用例文件名必须以_test.go结尾
2. 测试用例函数必须以Test开头（Test+函数名）
3. 形参必须是(T *tesing.T)
4. 一个测试用例文件中，可以有多个测试用例函数，也可与在不同文件，只要命名统一
5. 运行测试用例指令
6. go test 运行正确，无日志，错误会输出错误日志
7. go test -v 正确错误都会输出日志
8. 当出现错误时，可以使用 t.Fatalf 来格式化输出错误信息，并退出程序
9. t.Logf 方法可以输出相应的日志
10. 测试单个文件，一定要带上被测试的原文件 ：C:\Users\55480\go\learn\testcase01>go test -v cat_test.go cal.go
11. 测试单个方法 ： go test -v -test.run TestAddUpper
12. 默认扫描当前文件夹内所有的测试用例

案例：

复制
package main
 
import ("encoding/json""fmt""io/ioutil"
)
 
type monster struct {
   Name string
   Age int
   Skill string
}
//给monster绑定方法store，可以将一个monster变量（对象），序列化后保存到文件中
func (this *monster) Store()bool{//先序列化
   data,err:=json.Marshal(this)if err!=nil{
      fmt.Println("marshal err=",err)return  false}
 
   //保存到文件
   filePath:="c/monster.ser"
   err=ioutil.WriteFile(filePath,data,0777)if err!=nil{
      fmt.Println("write fiule err=",err)return false}return true
}
 
func (this *monster) ReStore()bool{//反先序列化
   filePath:="d/monster.ser"
   data,err:=ioutil.ReadFile(filePath)if err!=nil{
      fmt.Println("readFile ",err)return false}
 
   //反序列化
   err= json.Unmarshal(data,this)if err!=nil{
      fmt.Println("Unmarshal err ",err)return false}return true
}

测试案例

复制
package main
 
import "testing"
 
func TestStore(t *testing.T){//先创建一个monster实例
   monster := &monster{
      Name:"擦拭",
      Age:12,
      Skill:"风火轮",}
   res := monster.Store()if res{
      t.Fatalf("方法错误，希望为%v,实际为%v",true,res)}
   t.Logf("测试成功")
}
 
func TestReStore(t *testing.T){//先创建一个monster实例var monster= &monster{}
   res:=monster.ReStore()if res{
      t.Fatalf("方法错误，希望为%v,实际为%v",true,res)}
 
   if monster.Name !="擦拭" {
      t.Fatalf("方法错误，希望为%v,实际为%v","擦拭",res)
 
   }
   t.Logf("测试成功")
}