• [go学习笔记.第十三章.单元测试] 1.单元测试

    1.引入

     

            在工作中,经常会遇到这样的情况:就是去确认一个函数,或者一个模块的结果是否正确,比如:

    1. func AddUpdate(n int) int {
    2.     res := 0
    3.     for i := 1; i <= n; i++ {
    4.         res += i
    5.     }
    6.     return res
    7. }

    2.传统的方法

    1).传统方法来进行测试

     在main函数中,调用AddUpdate函数，看看实际输出的结果是否和预期的结果一致，如果一致，则说明函数正确，否则函数有错误，然后修改错误

    2).传统方法的缺点分析

    (1).不方便：

            我们需要在 main 函数中去调用，这样就需要去修改 main 函数，如果现在顶目正在运行，就可能去停止顶目

    (2).不利于管理:

            因为当我们测试多个函数或者多个模块时，都需要写在main函数中,不利于管理和清晰我们的思路

    (3)引出单元测试:  testing测试框架可以很好解决问题

    3.单元测试基本介绍

            go语言中自带有一个轻量级的测试框架testing和自带的go test 命令来实现单元测试和性能测试， testing 框架和其他语言中的测试框架类似，可以基于这个框架写针对相应函数的测试用例，也可以基于该框架写相应的压力测试用例。

    通过单元侧试，可以解决如下问题：

            (1).确保每个函数是可运行，并且运行结果是正确的

            (2).确保写出来的代码性能是好的

            (3).单元测试能及时的发现程序设计或实现的逻辑错误，使问题及早暴露，便于问题的定位解决，而性能测试的重点在于发现程序设计上的一些问题，让程序能够在高并发的情况下还能保持稳定

    4.快速入门

    使用go单元测试，对AddUpdate和 sub 函数进行测试.

    特别说明：

            测试时，可能需要暂时退出 360.（因为 360 可能会认为生成的测试用例程序是木马）演示如何进行单元测试：   

    cal.go:

    1. package main
    2.  
    3. //一个被测试的函数
    4. func AddUpper(n int) int {
    5.     res := 0
    6.     for i := 0; i <= n; i++ {
    7.         res += i 
    8.     }
    9.     return res 
    10. }
    11.  
    12. func getSub(n1 int, n2 int) int {
    13.     return n1 - n2  
    14. }
    15.

    cal_test.go:

    1. package main
    2.  
    3. import (
    4.     "testing" //引入go的testing测试框架
    5. )
    6.  
    7. //编写一个测试用例,去厕所addUpper是否正确
    8. func TestAddUpper(t *testing.T)  {
    9.     //调用
    10.     res := AddUpper(10)
    11.     if res != 55 {
    12.         t.Fatalf("AddUpper错误,返回值=%v,期望值=%v\n", res, 55)
    13.     }
    14.     //如果正确,输出日志
    15.     t.Logf("AddUpper(10)正确..")
    16. }

     sub_test.go:

    1. package main
    2.  
    3. import (
    4. 	_ "fmt"
    5. 	"testing" //引入go的testing测试框架
    6. )
    7.  
    8. //编写一个测试用例,去厕所addUpper是否正确
    9. func TestGetSub(t *testing.T)  {
    10. 	//调用
    11. 	res := getSub(10, 3)
    12. 	if res != 7 {
    13. 		t.Fatalf("getSub错误,返回值=%v,期望值=%v\n", res, 7)
    14. 	}
    15. 	//如果正确,输出日志
    16. 	t.Logf("getSub(10, 3)正确..")
    17. }

    结果: 

    1. go test -v
    2. === RUN   TestAddUpper
    3.     cal_test.go:16: AddUpper(10)正确..
    4. --- PASS: TestAddUpper (0.00s)
    5. === RUN   TestGetSub
    6.     sub_test.go:16: getSub(10, 3)正确..
    7. --- PASS: TestGetSub (0.00s)
    8. PASS
    9. ok      go_code/teststringdemo1/testcase      1.060s

    5.快速入门总结

    (1).测试用例文件名必须以_test.go 结尾。比如cal_test.go，cal不是固定的

    (2).测试用例函数必须以Test开头，一般来说就是Test+被测试的函数名，比如 TestAddUpper

    (3).TestAddUpper(t *testing.T)的形参类型必须是 *testing.T

    (4).一个测试用例文件中，可以有多个测试用例函数，比如TestAddUpdate,TestSub        

    (5).运行测试用例指令:

            1).cmd>go test [如果运行正确，无日志，错误时，会输出日志] 

            2). cmd>go test -v [运行正确或是错误，都输出日志］

    (6 ).当出现错误时，可以使用t.Fatalf 来格式化输出错误信息，并退出程序

    (7).t.Logf 方法可以输出相应的日志

    (8).测试用例函数，并没有放在 main 函数中，也执行了，这就是测试用例的方便之处

    (9). PASS表示测试用例运行成功， FAIL 表示测试用例运行失败

    (10).测试单个文件，一定要带上被测试的原文件

            go test -v cal_tesst.go cal.go

    (11).测试单个方法

           1). 当测试文件中有多个以Test开头的测试方法时,使用 go test -v -test.run TestAddUpper

           2).当测试文件中只有一个以Test开头的测试方法时,案例:

    1. package dao
    2.  
    3. import (
    4. 	"fmt"
    5. 	"go_code/web_app/book/model"
    6. 	"testing"
    7. 	"time"
    8. )
    9.  
    10. func TestOrder(t *testing.T)  {
    11. 	fmt.Println("添加订单测试相关")
    12. 	//t.Run("测试添加订单", testAddOrder)
    13. 	//t.Run("测试获取数据库中所有订单", testGetOrders)
    14. 	//t.Run("通过订单id获取对应的订单项", tesGetOrderItemsByOrderID)
    15. 	//t.Run("测试获取数据库中用户订单", testGetMyOrder)
    16. 	t.Run("测试根据订单号更新订单", testUpdateOrderState)
    17. }
    18.  
    19. //测试添加订单
    20. func testAddOrder(t *testing.T){
    21. 	//创建订单
    22. 	timeStr := time.Now().Format("2006-01-02 15:04:05")
    23. 	order := &model.Order{
    24. 		OrderID : "1234564",
    25. 		CreateTime: timeStr,
    26. 		TotalAmount: 2,
    27. 		TotalCount: 2,
    28. 		State: 0,
    29. 		UserID: 2,
    30. 	}
    31. 	//创建订单项
    32. 	orderItem1:=  &model.OrderItem{
    33. 		Count: 1,
    34. 		Amount: 1,
    35. 		Title: "测试",
    36. 		Author: "罗",
    37. 		Price: 1,
    38. 		ImgPath: "/static/img/default.jgp",
    39. 		OrderID: "1234564",
    40. 	}
    41. 	//创建订单项
    42. 	orderItem2:=  &model.OrderItem{
    43. 		Count: 1,
    44. 		Amount: 1,
    45. 		Title: "测试12",
    46. 		Author: "罗2",
    47. 		Price: 1,
    48. 		ImgPath: "/static/img/default.jgp",
    49. 		OrderID: "1234564",
    50. 	}
    51. 	//添加订单以及订单项
    52. 	err := AddOrder(order)
    53. 	if err != nil {
    54. 		fmt.Println("order add test fail,err=", err)
    55. 	}
    56. 	err1 := AddOrderItem(orderItem1)
    57. 	if err != nil {
    58. 		fmt.Println("order item add test fail,err=", err1)
    59. 	}
    60. 	err2 := AddOrderItem(orderItem2)
    61. 	if err != nil {
    62. 		fmt.Println("order item add test fail,err=", err2)
    63. 	}
    64. }
    65.  
    66. //测试获取数据库中所有订单
    67. func testGetOrders(t *testing.T)  {
    68. 	orders,_ := GetOrders()
    69. 	for _,v   := range orders {
    70. 		fmt.Println("图书:", v)
    71. 	}
    72. }
    73.  
    74. //测试获取数据库中用户订单
    75. func testGetMyOrder(t *testing.T)  {
    76. 	orders,_ := GetMyOrder(2)
    77. 	for _,v   := range orders {
    78. 		fmt.Println("图书:", v)
    79. 	}
    80. }
    81. //测试通过订单id获取对应的订单项
    82. func tesGetOrderItemsByOrderID(t *testing.T)  {
    83. 	order_items,_ := GetOrderItemsByOrderID("c341c646-6eab-4b74-771e-8dc5c9c1cbce")
    84. 	for _,v   := range order_items {
    85. 		fmt.Println("图书对应的订单项:", v)
    86. 	}
    87. }
    88.  
    89. //测试根据订单号更新订单
    90. func testUpdateOrderState(t *testing.T)  {
    91. 	err := UpdateOrderState("cf040684-d392-4c3e-5216-43777683f917", 2)
    92. 	if err != nil {
    93. 		fmt.Println(err)
    94. 	}
    95. }

    运行测试代码 go test -v -run TestOrder 即可 

    6.综合案例

    案例要求 

            (1).编写一个 Monster 结构体，字段 Name , Age , Skill

            (2).给 Monster 绑定方法 Store ，可以将一个 Monster变量(对象)，序列化后保存到文件中

            (3).给 Monster 绑定方法 ReStore ，可以将一个序列化的 Monster ，从文件中读取，并反序列化为 Monster 对象,检查反序列化，名字正确

            (4).编程测试用例文件store_test.go ，编写测试用例函数 TestStore和TestRestore 进行测试

    monster.go 

    1. package monster 
    2.  
    3. import (
    4.     "fmt"
    5.     "encoding/json"
    6.     "io/ioutil"
    7. )
    8.  
    9. type Monster struct {
    10.     Name string
    11.     Age int
    12.     Skill string
    13. }
    14.  
    15. //给Monster绑定方法Store,可以将一个monster变量(对象)序列化后保存到文件
    16. func (this *Monster) Store() bool  {
    17.     //直接将序列化后,保存
    18.     data, err := json.Marshal(this)
    19.     if err != nil {
    20.         fmt.Printf("marshal err = %v\n", err)
    21.         return false
    22.     }
    23.  
    24.     //保存到文件
    25.     filePath := "f:/www/monster.ser"
    26.     err = ioutil.WriteFile(filePath, data, 0666)
    27.     if err != nil {
    28.         fmt.Printf("write file err = %v\n", err)
    29.         return false
    30.     }
    31.     return true
    32. }
    33.  
    34. //给Monster绑定方法ResStore,可以将一个序列化的monster,从文件中读取,
    35. //并反序列化成Monster对象,检查反序列化,名字是否正确
    36. func (this *Monster) ResStore() bool  {
    37.     //先从文件中读出文件
    38.     filePath := "f:/www/monster.ser"
    39.     data, err := ioutil.ReadFile(filePath)
    40.     if err != nil {
    41.         fmt.Printf("read file err = %v\n", err)
    42.         return false
    43.     }
    44.     //反序列化
    45.     err = json.Unmarshal(data, this)
    46.     if err != nil {
    47.         fmt.Printf("unmarshal file err = %v\n", err)
    48.         return false
    49.     }
    50.     return true
    51. }

    monster_test.go 

    1. package monster
    2.  
    3. import(
    4.     "testing"
    5. )
    6.  
    7. func TestStore(t *testing.T)  {
    8.     //先创建一个Monster
    9.     monster := Monster{
    10.         Name : "张三",
    11.         Age : 12,
    12.         Skill : "爬树",
    13.     }
    14.     res := monster.Store()
    15.     if !res {
    16.         t.Fatalf("monster store err, 希望为:%v,实际为:%v", true, res)
    17.     }
    18.     t.Logf("monster store sueccss")
    19. }
    20.  
    21.  
    22. func TestResStore(t *testing.T)  {
    23.     //先创建一个monster实例,不需要指定字段的值
    24.     var monster Monster
    25.     res := monster.ResStore()
    26.     if !res {
    27.         t.Fatalf("monster resstore err, 希望为:%v,实际为:%v", true, res)
    28.     }
    29.     //进一步判断
    30.     if monster.Name != "张三" {
    31.         t.Fatalf("monster resstore err, 希望为:%v,实际为:%v", monster.Name, res)
    32.     }
    33.     t.Logf("monster resstore sueccss")
    34. }

     结果:

    1.  go test -v
    2. === RUN   TestStore
    3.     monster_test.go:18: monster store sueccss
    4. --- PASS: TestStore (0.00s)
    5. === RUN   TestResStore
    6.     monster_test.go:33: monster resstore sueccss
    7. --- PASS: TestResStore (0.00s)
    8. PASS
    9. ok      go_code/testcase     0.758s

    [上一节][go学习笔记.第十二章.文件操作] 2.json基本介绍

    [下一节][go学习笔记.第十四章.协程和管道] 1.协程的引入,调度模型以及运行cpu数目，协程资源竞争问题 

  • 相关阅读:
    echarts重叠柱状图（非堆叠柱状图）
    思科防火墙解析(ASA)
    基于图搜索的规划算法之A*家族（五）：D* 算法
    算法通关村-----图的基本算法
    03-JS循环语句
    C#学习笔记--面向对象三大特征
    Android多线程实现
    tomcat10.1.0源码分析
    vue实现keep-alive页面缓存【三步骤配置，一步到位】
    Otsu阈值分割详解
  • 原文地址：https://blog.csdn.net/zhoupenghui168/article/details/127740293