十五、单元测试

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

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

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

缺点：

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

基本介绍

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

单元测试作用：

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

单元测试

cal.go

func AddUpper(n int)int{
   res:=0
   for 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方法

总结

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

案例：

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("测试成功")
}