vendor/github.com/tendermint/go-wire/data/pointer_test.go

   1 package data_test
   2
   3 import (
   4         "fmt"
   5         "testing"
   6
   7         "github.com/stretchr/testify/assert"
   8         "github.com/stretchr/testify/require"
   9         data "github.com/tendermint/go-wire/data"
  10 )
  11
  12 type Ptr interface {
  13         Point() string
  14 }
  15
  16 // implementations
  17 type PStr string
  18 type PInt int
  19
  20 func (p *PStr) Point() string {
  21         if p == nil {
  22                 return "snil"
  23         }
  24         return string(*p)
  25 }
  26
  27 func (p *PInt) Point() string {
  28         if p == nil {
  29                 return "inil"
  30         }
  31         return fmt.Sprintf("int: %d", int(*p))
  32 }
  33
  34 var ptrMapper data.Mapper
  35
  36 // we register pointers to those structs, as they fulfill the interface
  37 // but mainly so we can test how they handle nil values in the struct
  38 func init() {
  39         ps, pi := PStr(""), PInt(0)
  40         ptrMapper = data.NewMapper(KeyS{}).
  41                 RegisterImplementation(&ps, "str", 5).
  42                 RegisterImplementation(&pi, "int", 25)
  43 }
  44
  45 // PtrS adds json serialization to Ptr
  46 type PtrS struct {
  47         Ptr
  48 }
  49
  50 func (p PtrS) MarshalJSON() ([]byte, error) {
  51         return ptrMapper.ToJSON(p.Ptr)
  52 }
  53
  54 func (p *PtrS) UnmarshalJSON(data []byte) (err error) {
  55         parsed, err := ptrMapper.FromJSON(data)
  56         if err == nil && parsed != nil {
  57                 p.Ptr = parsed.(Ptr)
  58         }
  59         return
  60 }
  61
  62 // TestEncodingNil happens when we have a nil inside the embedding struct
  63 func TestEncodingNil(t *testing.T) {
  64         assert, require := assert.New(t), require.New(t)
  65
  66         s := PStr("foo")
  67         i := PInt(567)
  68         ptrs := []Ptr{&s, &i, nil}
  69
  70         for i, p := range ptrs {
  71                 wrap := PtrS{p}
  72
  73                 js, err := data.ToJSON(wrap)
  74                 require.Nil(err, "%d: %+v", i, err)
  75
  76                 parsed := PtrS{}
  77                 err = data.FromJSON(js, &parsed)
  78                 require.Nil(err, "%d: %+v", i, err)
  79                 if wrap.Ptr != nil {
  80                         assert.Equal(parsed.Point(), wrap.Point())
  81                 }
  82                 assert.Equal(parsed.Ptr, wrap.Ptr)
  83         }
  84 }