go语言系统-从文件操作到单元测试

目录

  • 文件操作

    • 输入流和输出流
    • 打开文件和关闭文件
      • 使用的函数和方法
      • 案例演示
    • 读文件操作应用案例
    • 写文件操作应用案例
    • 判断文件是否存在
    • 文件编程应用实例
      • 拷贝文件
      • 统计英文、数字、空格和其它字符数量
  • 命令行参数
    • 举例说明
    • flag包用来解析命令行参数
  • Json
    • Json基本介绍

      • 应用场景
    • Json数据格式说明
    • Jsnon数据在线解析
    • Json的序列化
      • 应用案例
    • Json的反序列化
      • 应用案例
  • 单元测试
    • 先看一个需求
    • 传统的方法
      • 传统方法的缺点分析
    • 单元测试
      • 基本介绍
      • 快速入门
      • 单元测试快速入门总结
    • 综合案例
      • 单元测试综合案例要求：
      • 代码区

文件操作

文件是数据源(保存数据的地方)的一种，比如经常使用的word文档，txt文档，excel文件...都是文件。文件最主要的作用就是保存数据，它即可以保存一张图片，也可以保持视频，声音...

输入流和输出流

文件在程序中是以流的形式来操作的

流：数据在数据源(文件)和程序(内存)之间经历的路径

输入流：数据从数据源(文件)到程序(内存)的路径

输出流：数据从程序(内存)到数据源(文件)的路径

os.File封装所有文件相关操作，File是一个结构体

? 后面操作文件，会经常使用到os.File结构体

打开文件和关闭文件

使用的函数和方法

案例演示

import (
   "fmt"
   "os"
)

func main()  {
   //打开文件
   //概念说明：file的叫法
   //1. file 叫 file对象
   //2. file 叫 file指针
   //3. file 叫 file文件句柄
   file, err := os.Open("e:/test.txt")
   if err != nil {
      fmt.Println("Open file err = ", err)
   }
   //输出文件，看看文件是什么，看出file就是一个指针 *Filr
   fmt.Printf("file = %v", file)   //file = &{0xc000070780}
   //关闭
   err = file.Close()
   if err != nil {
      fmt.Println("Close file err = ", err)
   }
}

读文件操作应用案例

  1. 读取文件的内容并显示在终端(带缓冲区的方式)，使用os.Open，file.Close，bufio.NewReader()，reader.ReadString函数和方法
import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func main()  {
	//打开文件
	//概念说明：file的叫法
	//1. file 叫 file对象
	//2. file 叫 file指针
	//3. file 叫 file文件句柄
	file, err := os.Open("E:/gostudent/src/2020-04-02/utils/utils.go")
	if err != nil {
		fmt.Println("Open file err = ", err)
	}
	//当函数退出时，要及时的关闭file
	defer file.Close() //要及时关闭file句柄，否则会有内存泄漏
	//创建一个*Reader ， 是带缓冲的
	/*
	   const (
	      defaultBufSize = 4096  //默认的缓冲区为4096
	   )
	*/
	reader := bufio.NewReader(file)
	//循环读取文件的内容
	for {
		str, err := reader.ReadString(‘\n‘)  //读到一个换行就结束
		if err == io.EOF {      //io.EOF 表示文件的末尾
			break
		}
		//输出内容
		fmt.Print(str)
	}
	fmt.Println("文件读取结束...")
}
  1. 读取文件的内容并显示在终端(使用ioutil一次将整个文件读入到内存中)，这种方式适用于文件不大的情况。相关方法和函数ioutil.ReadFile
import (
	"fmt"
	"io/ioutil"
)

func main()  {
	//使用ioutil.ReadFile一次性将文件读取到位
	file := "E:/gostudent/src/2020-04-02/utils/utils.go"
	content, err := ioutil.ReadFile(file)
	if err != nil {
		fmt.Printf("read file err = %v", err)
	}
	//把读取到的内容显示到终端
	//fmt.Printf("%v", content) //[]byte
	fmt.Printf("%v", string(content)) // []byte
	//这里没有显示的Open文件，因此也不需要显示的Close文件
	//因为，文件的Open和Close被封装到ReadFile函数内部
}

写文件操作应用案例

os.OpenFile函数

  1. 创建一个新文件，写入内容：5句 “Hello,zisefeizhu”
import (
	"bufio"
	"fmt"
	"os"
)

func main()  {
	filePath := "E:/gostudent/src/2020-04-05/abc.txt"
	file, err := os.OpenFile(filePath, os.O_CREATE | os.O_WRONLY, 0666)
	if err != nil {
		fmt.Printf("open file err = %v \n", err)
		return
	}
	//及时关闭file句柄
	defer file.Close()
	//准备写入5句: "hello,zisefeizhu"
	str := "hello,zisefeizhu\n" // \n表示换行
	//写入时，使用带缓存的*Writer
	writer := bufio.NewWriter(file)
	for i := 0; i< 5; i++ {
		writer.WriteString(str)
	}
	//因为write是带缓存的，因此在调用WriterString方法时
	//其实内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据
	//真正写入到文件中，否则文件中会没有数据!!!
	writer.Flush()
}
  1. 打开一个存在的文件，将原来的内容覆盖成新的内容10句“你好，紫色飞猪”
import (
   "bufio"
   "fmt"
   "os"
)

func main()  {
   //2)打开一个存在的文件，将原来的内容覆盖成新的内容10句“你好，紫色飞猪”
   //1. 打开已经存在的文件E:/gostudent/src/2020-04-05/abc.txt
   filePath := "E:/gostudent/src/2020-04-05/abc.txt"
   file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_TRUNC, 0666)
   if err != nil {
      fmt.Printf("open file err = %v \n", err)
      return
   }
   //及时关闭file句柄
   defer file.Close()
   //准备写入10句: "hello,zisefeizhu"
   str := "你好，紫色飞猪!\n" // \n表示换行
   //写入时，使用带缓存的*Writer
   writer := bufio.NewWriter(file)
   for i := 0; i< 10; i++ {
      writer.WriteString(str)
   }
   //因为write是带缓存的，因此在调用WriterString方法时
   //其实内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据
   //真正写入到文件中，否则文件中会没有数据!!!
   writer.Flush()

}
  1. 打开一个存在的文件，在原来的内容追加内容“你好，jingxing”
import (
   "bufio"
   "fmt"
   "os"
)

func main()  {
   //1. 打开已经存在的文件E:/gostudent/src/2020-04-05/abc.txt
   filePath := "E:/gostudent/src/2020-04-05/abc.txt"
   file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_APPEND, 0666)
   if err != nil {
      fmt.Printf("open file err = %v \n", err)
      return
   }
   //及时关闭file句柄
   defer file.Close()
   //追加内容
   str := "你好，jingxing\n" // \n表示换行
   //写入时，使用带缓存的*Writer
   writer := bufio.NewWriter(file)
   for i := 0; i< 10; i++ {
      writer.WriteString(str)
   }
   //因为write是带缓存的，因此在调用WriterString方法时
   //其实内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据
   //真正写入到文件中，否则文件中会没有数据!!!
   writer.Flush()
}
  1. 打开一个存在的文件，将原来的内容读出显示在终端，并且追加5句“你好，深圳”
import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func main()  {
	//1. 打开已经存在的文件E:/gostudent/src/2020-04-05/abc.txt
	filePath := "E:/gostudent/src/2020-04-05/abc.txt"
	file, err := os.OpenFile(filePath, os.O_RDWR | os.O_APPEND, 0666)
	if err != nil {
		fmt.Printf("open file err = %v \n", err)
		return
	}
	//及时关闭file句柄
	defer file.Close()
	//先读取原来文件的内容，并显示在终端
	reader := bufio.NewReader(file)
	for {
		str, err := reader.ReadString(‘\n‘)
		if err == io.EOF {   //如果读取到文件的末尾
			break
		}
		//显示到终端
		fmt.Print(str)
	}
	//追加内容
	str := "你好，深圳\n" // \n表示换行
	//写入时，使用带缓存的*Writer
	writer := bufio.NewWriter(file)
	for i := 0; i< 5; i++ {
		writer.WriteString(str)
	}
	//因为write是带缓存的，因此在调用WriterString方法时
	//其实内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据
	//真正写入到文件中，否则文件中会没有数据!!!
	writer.Flush()
}

5）编写一个程序，将一个文件的内容，写入到另外一个文件。注：这两个文件已经存在了

说明：使用ioutil.ReadFile / ioutil.WriteFile完成写文件的任务

import (
   "fmt"
   "io/ioutil"
)
func main()  {
   //将e:/abc.txt 文件内容导入到e:/abc.txt
   //1. 首先将 e:/abc.txt 内容读取到内存
   //2. 将读取到的内容写入d:/abc.txt
   file1Path := "E:/gostudent/src/2020-04-05/abc.txt"
   file2Path := "D:/abc.txt"
   data, err := ioutil.ReadFile(file1Path)
   if err != nil {
      //说明读取文件有错误
      fmt.Printf("read file err = %v\n", err)
      return
   }
   err = ioutil.WriteFile(file2Path, data, 0666)
   if err != nil {
      fmt.Printf("write file error = %v \n", err)
   }
}

判断文件是否存在

Go判断文件或文件夹是否存在的方法为使用os.Stat()函数对返回的错误值进行判断：

  1. 如果返回的错误为nil，说明文件或文件夹存在
  2. 如果返回的错误类型使用os.IsNotExist()判断为true，说明文件或文件夹不存在
  3. 如果返回的错误为其它类型，则不确定是否存在

文件编程应用实例

拷贝文件

说明：将一张图片/电影/mp3拷贝到另一个文件e:/abc.jpg

func Copy(dst Writer,src Reader)(written int64, err error)

注意：Copy函数是io 包提供的

import (
   "bufio"
   "fmt"
   "io"
   "os"
)
//编写一个函数，接收两个文件路径 srcFileName dstFileName
func CopyFile(srcFileName string, dstFileName string) (written int64, err error) {
   srcFile, err := os.Open(srcFileName)
   if err != nil {
      fmt.Printf("open file err = %v\n", err)
   }
   defer  srcFile.Close()
   //通过srcfile，获取到Reader
   reader := bufio.NewReader(srcFile)
   //打开dstFileName
   dstFile,err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, 0666)
   if err != nil {
      fmt.Printf("open file err = %v\n", err)
      return
   }
   //通过dstFile，获取到Writer
   writer := bufio.NewWriter(dstFile)
   defer  dstFile.Close()
   return io.Copy(writer, reader)
}
func main()  {
   //将d:/abc.jpg 文件拷贝到e:/abc.jpg
   //调用CopyFile 完成文件拷贝
   srcFile := "d:/abc.jpeg"
   dstFile := "e:/abc.jpg"
   _, err := CopyFile(srcFile, dstFile)
   if err == nil {
      fmt.Printf("拷贝完成\n")
   } else {
      fmt.Printf("拷贝错误 err = %v\n", err)
   }
}

统计英文、数字、空格和其它字符数量

import (
   "bufio"
   "fmt"
   "io"
   "os"
)
//定义一个结构体，用于保存统计结果
type CharCount struct {
   ChCount int //记录英文个数
   NumCount int //记录数字的个数
   SpaceCount int //记录空格的个数
   OtherCount int //记录其它字符的个数
}

func main()  {
   //思路：打开一个文件，创一个Reader
   //每读取一行，就去统计该行有多少个英文、数字、空格和其它字符
   //然后将结果保存到一个结构体
   fileName := "E:/gostudent/src/2020-04-05/abc.txt"
   file,err := os.Open(fileName)
   if err != nil {
      fmt.Printf("open file err = %v \n", err)
      return
   }
   defer  file.Close()
   //定义个CharCount实例
   var count CharCount
   //创建一个Reader
   reader := bufio.NewReader(file)
   //开始循环读取fleName的内容
   for {
      str, err := reader.ReadString(‘\n‘)
      if err == io.EOF { //读到文件末尾就退出
         break
      }
      //为了兼容中文字符，可以将str转成[]rune
      strChange := []rune(str)
      //遍历str，进行统计
      for _,v := range strChange {
         switch  {
         case v >= ‘a‘ && v <= ‘z‘ :
            fallthrough //穿透
         case v >= ‘A‘ && v <= ‘Z‘ :
            count.ChCount++
         case v == ‘ ‘ || v == ‘\t‘ :
            count.SpaceCount++
         case v >= ‘0‘ && v <= ‘9‘ :
            count.NumCount++
         default:
            count.OtherCount++
         }
      }
   }
   //输出统计的结果看看是否正确
   fmt.Printf("字符的个数为 = %v 数字的个数为 = %v 空格的个数为 = %v 其它字符个数 = %v",
      count.ChCount, count.NumCount, count.SpaceCount, count.OtherCount)
}

命令行参数

希望能够获取到命令行输入的各种参数，该如何处理？

os.Args是一个string的切片，用来存储所有的命令行参数

举例说明

import (
	"fmt"
	"os"
)

func main()  {
	fmt.Println("命令行的参数有：", len(os.Args))
	//遍历os.Args切片，就可以得到所有的命令行输入参数值
	for i, v := range os.Args {
		fmt.Printf("args[%v] = %v \n", i ,v)
	}
}
//E:\gostudent\src\2020-04-05>go run main.go 999
//命令行的参数有： 2
//args[0] = C:\Users\lxxxxn\AppData\Local\Temp\go-build133979866\b001\exe\main.
//exe
//args[1] = 999

flag包用来解析命令行参数

说明：前面的方式是比较原生的方式，对解析参数不是特别的方便，特别是带有指定参数形式的命令行

比如:cmd>main.exe -f c:/aaa.txtx -p 200 -u root 这样形式的命令行，go设计者给提供了flag包，可以方便的解析命令行参数，而且参数顺序可以随意

import (
	"flag"
	"fmt"
)

func main()  {
	//定义几个变量，用于接收命令行的参数值
	var user string
	var pwd string
	var host string
	var port int
	//&user就是接收用户命令行中输入的 -u 后面的参数值
	//"u" 就是-u 指定参数
	//" " 默认值
	//"用户名，默认为空" 说明
	flag.StringVar(&user, "u","","用户名，默认为空")
	flag.StringVar(&pwd,"pwd","","密码，默认为空")
	flag.StringVar(&host,"h","localhost","主机名，默认为localhost")
	flag.IntVar(&port,"port",3306,"端口号，默认为3306")
	//有一个非常重要的操作转换，必须调用该方法
	flag.Parse()
	//输出结果
	fmt.Printf("user = %v pwd = %v host = %v port = %v",
		user, pwd, host, port)
}
//E:\gostudent\src\2020-04-05>go run main.go -u root -pwd zisefeizhu -h 20.0.0.201 -port 3306
//user = root pwd = zisefeizhu host = 20.0.0.201 port = 3306

Json

Json基本介绍

Json(JavaScript Object Notation)是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。key - val

Json是在2001年开始推广使用的数据格式，目前已经成为主流的数据格式

Json易于机器解析和生成，并有效地提升网络传输效率，通常程序在网络传输时会先将数据(结构体、map等)序列化成json字符串，到接收方得到json字符串时，在反序列化恢复成原来的数据类型(结构体、map等)。这种方式已然成为各个语言的标准

应用场景

Json数据格式说明

在JS语言中，一切都是对象。因此，任何数据类型都可以通过JSON来表示，例如字符串、数字、对象、数组、map、结构体等

JSON键值对是用来保存数据的一种方式

键/值对组合中的键名写在前面并用双引号“”包裹，使用冒号：分隔，然后紧接值：

[{"key1":val1,"key2":val2,"key3":val3,"key4":[val4,val5]},
{"key1":val1,"key2":val2,"key3":val3,"key4":[val4,val5]}]
比如
{"firstName":"Json"}

{"name":"tom","age":18,"address":["北京","上海"]}

[{"name":"zisefeizhu","age":18,"address":["北京","上海"]},
{"name":"jingxing","age":18,"address":["北京","上海"]}]

Jsnon数据在线解析

https://www.json.cn/ 网站可以验证一个json格式的数据是否正确。尤其是在编写比较复杂的json格式数据时，很有用

Json的序列化

json序列化是指，将有key - value 结构的数据类型(比如结构体、map、切片)系列化成json字符串的操作

应用案例

演示一下结构体、map和切片的序列化，其它数据类型的序列化类似

import (
   "encoding/json"
   "fmt"
)
//定义一个结构体
type Monster struct {
   Name string
   Age int
   Bithday string
   Sal float64
   Skill string
}

func testStruct()  {
   //演示
   monster := Monster{
      Name : "牛魔王",
      Age : 500,
      Bithday : "2001-11-11",
      Sal : 8000.0,
      Skill : "牛头拳",
   }
   //将monster 序列化
   data, err := json.Marshal(&monster)
   if err != nil {
      fmt.Printf("序列号错误 err = %v \n", err)
   }
   //输出序列化后的结果
   fmt.Printf("monster 序列化后 = %v \n", string(data))
}
//将map进行序列化
func testMap()  {
   //定义一个map
   var a map[string]interface{}
   //使用map，需要先make
   a = make(map[string]interface{})
   a["name"] = "红孩儿"
   a["age"] = 30
   a["address"] = "洪崖洞"
   //将a这个map进行序列化
   data, err := json.Marshal(a)
   if err != nil {
      fmt.Printf("序列号错误 err = %v \n", err)
   }
   //输出序列化后的结果
   fmt.Printf("monster 序列化后 = %v \n", string(data))
}
//演示对切片进行序列化，这个切片[]map[string]interface{}
func testSlice()  {
   var slice []map[string]interface{}
   var m1 map[string]interface{}
   //使用map前，需要先make
   m1 = make(map[string]interface{})
   m1["name"] = "jack"
   m1["age"] = "7"
   m1["address"] = "北京"
   slice = append(slice, m1)

   var m2 map[string]interface{}
   //使用map前，需要先make
   m2 = make(map[string]interface{})
   m2["name"] = "tom"
   m2["age"] = "20"
   m2["address"] = [2]string{"墨西哥","夏威夷"}
   slice = append(slice, m2)
   //将切片进行序列化操作
   data, err := json.Marshal(slice)
   if err != nil {
      fmt.Printf("序列号错误 err = %v \n", err)
   }
   //输出序列化后的结果
   fmt.Printf("monster 序列化后 = %v \n", string(data))
}
//对基本数据类型序列化，意义不大
func testFloat64()  {
   var num1 float64 = 2345.67
   //对num1进行序列化
   data, err := json.Marshal(num1)
   if err != nil {
      fmt.Printf("序列号错误 err = %v \n", err)
   }
   //输出序列化后的结果
   fmt.Printf("monster 序列化后 = %v \n", string(data))
}
func main()  {
   //演示将结构体、map、切片进行序列化
   testStruct()
   testMap()
   testSlice()
   testFloat64()
}
//输出
// monster 序列化后 = {"Name":"牛魔王","Age":500,"Bithday":"2001-11-11","Sal":8000,"Skill":"牛头拳"}
//monster 序列化后 = {"address":"洪崖洞","age":30,"name":"红孩儿"}
//monster 序列化后 = [{"address":"北京","age":"7","name":"jack"},{"address":["墨西哥","夏威夷"],"age":"20","name":"tom"}]
//monster 序列化后 = 2345.67

注意事项

对于结构体的序列化，如果希望序列化后的key的名字可以重新制定，那么可以给struct制定一个tag标签

import (
   "encoding/json"
   "fmt"
)
//定义一个结构体
type Monster struct {
   Name string  `json:"monster_name"` //反射机制 //:两边不要分开
   Age int `json:"monster_age"`
   Bithday string
   Sal float64
   Skill string
}

func testStruct()  {
   //演示
   monster := Monster{
      Name : "牛魔王",
      Age : 500,
      Bithday : "2001-11-11",
      Sal : 8000.0,
      Skill : "牛头拳",
   }
   //将monster 序列化
   data, err := json.Marshal(&monster)
   if err != nil {
      fmt.Printf("序列号错误 err = %v \n", err)
   }
   //输出序列化后的结果
   fmt.Printf("monster 序列化后 = %v \n", string(data))
}
func main()  {
   //演示将结构体、map、切片进行序列化
   testStruct()
}
//输出
// monster 序列化后 = {"monster_name":"牛魔王","monster_age":500,"Bithday":"2001-11-11","Sal":8000,"Skill":"牛头拳"}

Json的反序列化

json反序列化是指，将json字符串反序列化成对应的数据类型(比如结构体、map、切片)的操作

应用案例

演示一下将json字符串反序列化成结构体、map和切片

import (
   "encoding/json"
   "fmt"
)
//定义一个结构体
type Monster struct {
   Name string
   Age int
   Birthday string
   Sal float64
   Skill string
}
//演示将json字符串，反序列化成struct
func unmarshalStruct()  {
   //说明str在项目开发中，是通过网络传输获取到.. 或者是读取文件获取到
   str := "{\"Name\":\"牛魔王\",\"Age\":500,\"Birthday\":\"2001-11-11\",\"Sal\":8000,\"Skill\":\"牛头拳\"}"
   //定义一个Monster 实例
   var monster Monster
   err := json.Unmarshal([]byte(str), &monster)
   if err != nil {
      fmt.Printf("unmarshal err = %v\n", err)
   }
   fmt.Printf("反序列化后 monster = %v monster.Name = %v \n", monster, monster.Name)
}
//演示将json字符串，反序列化成map
func unmarshalMap()  {
   str := "{\"address\":\"洪崖洞\",\"age\":30,\"name\":\"红孩儿\"}"
   //定义一个map
   var a map[string]interface{}
   //反序列化
   //注意：反序列化map,不需要make，因为make操作被封装到Unmarshal函数
   err := json.Unmarshal([]byte(str), &a)
   if err != nil {
      fmt.Printf("unmarshal err = %v\n", err)
   }
   fmt.Printf("反序列化后 a = %v\n",a)
}
//演示将json字符串，反序列化成切片1
func unmarshalSlice()  {
   str := "[{\"address\":\"北京\",\"age\":\"7\",\"name\":\"jack\"},"+
      "{\"address\":[\"墨西哥\",\"夏威夷\"],\"age\":\"20\",\"name\":\"tom\"}]"
   //定义一个slice
   var slice []map[string]interface{}
   //反序列化，不需要make，因为make操作被封装到Unmarshal函数
   err := json.Unmarshal([]byte(str), &slice)
   if err != nil {
      fmt.Printf("unmarshal err = %v\n", err)
   }
   fmt.Printf("反序列化后 slice = %v\n", slice)
}

func main()  {
   unmarshalStruct()
   unmarshalMap()
   unmarshalSlice()
}
//输出
//反序列化后 monster = {牛魔王 500 2001-11-11 8000 牛头拳} monster.Name = 牛魔王
//反序列化后 a = map[address:洪崖洞 age:30 name:红孩儿]
//反序列化后 slice = [map[address:北京 age:7 name:jack] map[address:[墨西哥 夏威夷] age:20 name:tom]]

注意事项

? 1) 在反序列化一个json字符串时，要确保反序列化后的数据类型和原来序列化前的数据类型一致

? 2) 如果json字符串是通过程序获取到的，则不需要再对“”转义处理

单元测试

先看一个需求

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

如：

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

传统的方法

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

//一个被测试函数
func addUpper(n int) int {
   res := 0
   for i := 1; i <= n - 1; i++ {
      res += i
   }
   return res
}
func main()  {
   //传统的测试方法，就是在main函数中使用看看结果是否正确
   res := addUpper(10)
   if res != 55 {
      fmt.Printf("addUpper错误 返回值 = %v 期望值 = %v\n ", res, 55)
   } else {
      fmt.Printf("addUpper正确 返回值 = %v 期望值 = %v\n", res, 55)
   }
}
//addUpper错误 返回值 = 45 期望值 = 55

传统方法的缺点分析

  1. 不方便，需要在main函数中去调用，这样就需要去修改main函数，如果现在项目正在运行，就可能去停止项目
  2. 不利于管理，因为当我们测试多个函数或者多个模块时，都需要写在main函数，不利于我们管理和清晰我们思路
  3. 引出单元测试。 -> testing测试框架 可以解决问题

单元测试

基本介绍

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

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

快速入门

使用Go的单元测试，对addUpper和sub函数进行测试

特别说明：测试时，可能需要暂时退出360(因为360可能会认为生成的测试用例程序是木马)

演示如何进行单元测试

单元测试的运行原理示意图

单元测试快速入门总结

  1. 测试用例文件名必须以 _test.go结尾。比如cal_test.go，cal不是固定的
  2. 测试用例函数必须以Test开头，一般来说就是Test+被测试的函数名，比如TestAddUpper
  3. TestAddUpper(t *testing.T)的形参类型必须是 *testing.T
  4. 一个测试用例文件中，可以有多个测试用例韩式，比如TestAddUpper，TestSub
  5. 运行测试用例指令

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

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

  1. 当出现错误时，可以使用t.Fatalf来格式化输出错误信息，并退出程序
  2. t.Logf方法可以输出相应的日志
  3. 测试用例函数，并没有放在main函数中，也可以执行，这就是测试用例的方便之处
  4. PASS表示测试用例运行成功，FALL表示测试用例运行失败
  5. 测试单个文件，一定要带上被测试的源文件

? go test -v cal_test.go cal.go

  1. 测试单个方法

? go test -v -test.run TestAddUpper

综合案例

单元测试综合案例要求：

  1. 编写一个Monster结构体，字段Name、Age、Skill
  2. 给Monster绑定方法Store，可以将一个Monster变量(对象)，序列化后保存到文件中
  3. 给Monster绑定方法ReStore，可以将一个序列化的Monster，从文件中读取，并反序列化为Monster对象，检查反序列化，名字正确
  4. 编程测试用例文件store_test.go,编写测试用例函数TestStore和TestRestore进行测试

代码区

monster/monster.go

package monster

import (
   "encoding/json"
   "io/ioutil"
   "fmt"
)

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 := "e:/monster.ser"
   err = ioutil.WriteFile(filePath, data, 0666)
   if err != nil {
      fmt.Println("write file err =",err)
      return false
   }
   return true
}
//给Monster绑定方法ReStore，可以将一个序列化的Monster从文件中读取，
//并反序列化为Monster对象，检查反序列化，名字正确
func (this *Monster) ReStore() bool {
   //1. 先从文件中，读取序列化的字符串
   filePath := "e:/monster.ser"
   data, err := ioutil.ReadFile(filePath)
   if err != nil {
      fmt.Println("ReadFile err =", err)
      return false
   }
   //2. 使用读取到data []byte，对反序列化
   err = json.Unmarshal(data, this)
   if err != nil {
      fmt.Println("UnMarshal err = ", err)
      return false
   }
   return true
}

monster/monster_test.go

package monster

import "testing"
//测试用例，测试Store方法
func TestStore(t *testing.T)  {
   //先创建一个Monster实例
   monster := &Monster{
      Name: "红孩儿",
      Age: 10,
      Skill: "吐火",
   }
   res := monster.Store()
   if !res {
      t.Fatalf("monster.Store() 错误，希望为 = %v 实例为 = %v",true,res)
   }
   t.Logf("monster.Store() 测试成功！")
}
func TestReStore(t *testing.T)  {
   //测试数据是很多，测试很多次，才确定函数，模块..
   //先创建一个Monster实例，不需要制定字段的值
   var monster = &Monster{}
   res := monster.ReStore()
   if !res {
      t.Fatalf("monster.ReStore() 错误，希望为 = %v 实例为 = %v",true,res)
   }
   //进一步判断
   if monster.Name != "红孩儿" {
      t.Fatalf("monster.ReStore() 错误，希望为 = %v 实例为 = %v","红孩儿",monster.Name)
   }
   t.Logf("monster.ReStore() 测试成功！")
}

原文地址：https://www.cnblogs.com/zisefeizhu/p/12638713.html

时间： 2024-11-03 01:22:24

go语言系统-从文件操作到单元测试的相关文章

Unix/Linux环境C编程入门教程(41) C语言库函数的文件操作详解

?? 上一篇博客我们讲解了如何使用Linux提供的文件操作函数,本文主要讲解使用C语言提供的文件操作的库函数. 1.函数介绍 fopen(打开文件) 相关函数 open,fclose 表头文件 #include<stdio.h> 定义函数 FILE * fopen(const char * path,const char * mode); 函数说明 参数path字符串包含欲打开的文件路径及文件名,参数mode字符串则代表着流形态. mode有下列几种形态字符串: r 打开只读文件,该文件必须存

C语言样式的文件操作函数

使用C语言样式的文件操作函数,需要包含stdio.h头文件. 1.打开文件的函数: 1 //oflag的取值为“w”或“r”,分别表示以写或读的方式打开 2 FILE* fd = fopen(filename.c_str(), oflag); 2.写文件的函数原型: size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream ); 其中buffer是需要向文件中写入的内容在内存中的首地址指针,size是待写入

C语言复习：文件操作

文件操作专题 C语言文件读写概念 文件分类 按文件的逻辑结构: 记录文件:由具有一定结构的记录组成(定长和不定长) 流式文件:由一个个字符(字节)数据顺序组成 按存储介质: 普通文件:存储介质文件(磁盘.磁带等) 设备文件:非存储介质(键盘.显示器.打印机等) 按数据的组织形式: 文本文件: ASCII文件,每个字节存放一个字符的ASCII码 二进制文件:数据按其在内存中的存储形式原样存放 每个文件都以文件名为标识,I/O设备的文件名是系统定义的,如: COM1或AUX--第一串行口,附加设备

C语言中的文件操作---重定向操作文件

先说个题外话,文件操作以及字符串与字符深入处理(就是那些什么puts(), getchar()什么的)是本人深入认识C++最后的两座大山.而今天先把重定向文件操作解决掉. 输入输出重定向恐怕是文件I/O操作中最简单的方法了,具体用法是现在main函数的开头加入两条语句,例如: freopen("D:\\input.txt", "r", stdin); freopen("D:\\output.txt", "w", stdout)

go语言之行--文件操作、命令行参数、序列化与反序列化详解

一.简介 文件操作对于我们来说也是非常常用的,在python中使用open函数来对文件进行操作,而在go语言中我们使用os.File对文件进行操作. 二.终端读写 操作终端句柄常量 os.Stdin: 标准输入 os.Stdout: 标准输出 os.Stderr: 标准错误输出 读写示例: package main import ( "fmt" "os" ) var( username,password string ) func main() { fmt.Prin

Go语言基础之文件操作

本文主要介绍了Go语言中文件读写的相关操作. 文件是什么? 计算机中的文件是存储在外部介质(通常是磁盘)上的数据集合,文件分为文本文件和二进制文件. 打开和关闭文件 os.Open()函数能够打开一个文件,返回一个*File和一个err.对得到的文件实例调用close()方法能够关闭文件. package main import ( "fmt" "os" ) func main() { // 只读方式打开当前目录下的main.go文件 file, err := os

C语言中的文件操作(2)---标准I/O文件操作

在上一篇文章中,我们初步了解了freopen()函数的用法.但在一些算法竞赛中不允许使用文件重定向操作,这时我们就只能用标准C头文件stdio.h中的fopen()函数进行对文件的读写了. fopen()函数的不足之处就在于使用的方法复杂,写起来比较麻烦.但是它灵活度比freopen()要高得多,比如支持多文件同时读写等等. 实现方法:在main函数之前定义一个类型为FILE*的指针,并使它指向创建的文件. FILE* fp1 = fopen("D:\\abc.in", "r

C语言文件操作函数大全(超详细)

C语言文件操作函数大全(超详细) 作者: 字体:[增加 减小] 类型:转载 本篇文章是对C语言中的文件操作函数进行了详细的总结分析,需要的朋友参考下 fopen(打开文件)相关函数 open,fclose表头文件 #include<stdio.h>定义函数 FILE * fopen(const char * path,const char * mode);函数说明 参数path字符串包含欲打开的文件路径及文件名,参数mode字符串则代表着流形态.mode有下列几种形态字符串:r 打开只读文件,

go语言文件操作

摘要: 本文主要解说go语言的文件操作.系统底层的open\write等系统调用,往往操作的文件对象是文件描写叙述符;而C语言库的文件操作须要借助fopen/fread等函数,它们的操作对象是文件指针.go语言中,对文件操作进行了进一步封装-- 1.os包中File类 首先,file类是在os包中的,封装了底层的文件描写叙述符和相关信息,同一时候封装了Read和Write的实现. type File struct { *file } type file struct { fd int name