testdemo02/monster.go

  1. package monster
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6.     "io/ioutil"
  7. )
  9. type Monster struct {
  10.     Name  string
  11.     Age   int
  12.     Skill string
  13. }
  15. // Monster 绑定 Store 方法, 序列化 并 保存到文件中
  16. func (monster *Monster) Store() bool {
  17.     // 1、序列化
  18.     data, err := json.Marshal(monster)
  19.     if err != nil {
  20.         fmt.Println("序列化失败", err)
  21.         return false
  22.     }
  23.     // 2、保存到文件中
  24.     filePath := "d:/monster.txt"
  25.     _err := ioutil.WriteFile(filePath, data, 0666)
  26.     if _err != nil {
  27.         fmt.Println("保存文件失败", _err)
  28.         return false
  29.     }
  30.     return true
  31. }
  33. // Monster 绑定 ReStore 方法, 从文件中读取Json字符串， 并反序列化
  34. func (monster *Monster) ReStore() bool {
  35.     // 1、从文件中读取Json字符串
  36.     filePath := "d:/monster.txt"
  37.     data, err := ioutil.ReadFile(filePath)
  38.     if err != nil {
  39.         fmt.Println("读取文件失败", err)
  40.         return false
  41.     }
  42.     // 2、反序列化
  43.     error := json.Unmarshal(data, &monster)
  44.     if error != nil {
  45.         fmt.Println("反序列化失败", error)
  46.         return false
  47.     } else {
  48.         fmt.Println("monster=", monster)
  49.     }
  50.     return true
  51. }

testdemo02/monster_test.go

  1. package monster
  3. import (
  4.     "testing"
  5. )
  7. // 测试用例函数
  8. func TestStore(t *testing.T) {
  9.     monster := Monster{
  10.         Name:  "牛牛",
  11.         Age:   12,
  12.         Skill: "顶！",
  13.     }
  14.     res := monster.Store()
  15.     if !res {
  16.         t.Fatalf("monster.Store()错误， 实际为：%v, 期望为：%v", res, true)
  17.     } else {
  18.         t.Logf("monster.Store()成功， 实际为：%v, 期望为：%v", res, true)
  19.     }
  20. }
  22. func TestReStore(t *testing.T) {
  23.     var monster Monster
  24.     res := monster.ReStore()
  25.     if !res {
  26.         t.Fatalf("monster.Store()错误， 实际为：%v, 期望为：%v", res, true)
  27.     }
  29.     // 进一步判断
  30.     if monster.Name != "牛牛" {
  31.         t.Fatalf("monster.Name错误， 实际为：%v, 期望为：%v", monster.Name, "牛牛")
  32.     }
  34.     t.Logf("monster.Store()成功， 实际为：%v, 期望为：%v", res, true)
  35. }

测试结果

可单独测试 go test -v -run TestStore
go test -v -run TestReStore

  1. // go test -v
  2. === RUN   TestStore
  3.     monster_test.go:18: monster.Store()成功， 实际为：true, 期望为：true
  4. --- PASS: TestStore (0.00s)
  5. === RUN   TestReStore
  6. monster= &{牛牛 12 顶！}
  7.     monster_test.go:34: monster.Store()成功， 实际为：true, 期望为：true
  8. --- PASS: TestReStore (0.00s)
  9. PASS
  10. ok      go_code/unittest/testdemo02     1.104s