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

   1 package data_test
   2
   3 import (
   4         "testing"
   5
   6         "github.com/stretchr/testify/assert"
   7         "github.com/stretchr/testify/require"
   8         data "github.com/tendermint/go-wire/data"
   9 )
  10
  11 // Key
  12 type Key interface{}
  13
  14 // implementations
  15 type Cool struct{ data.Bytes }
  16 type Lame struct{ data.Bytes }
  17
  18 var keyMapper data.Mapper
  19
  20 // register both private key types with go-wire/data (and thus go-wire)
  21 func init() {
  22         keyMapper = data.NewMapper(KeyS{}).
  23                 RegisterImplementation(Cool{}, "cool", 1).
  24                 RegisterImplementation(Lame{}, "lame", 88)
  25 }
  26
  27 // KeyS adds json serialization to Key
  28 type KeyS struct {
  29         Key
  30 }
  31
  32 func (p KeyS) MarshalJSON() ([]byte, error) {
  33         return keyMapper.ToJSON(p.Key)
  34 }
  35
  36 func (p *KeyS) UnmarshalJSON(data []byte) (err error) {
  37         parsed, err := keyMapper.FromJSON(data)
  38         if err == nil {
  39                 p.Key = parsed.(Key)
  40         }
  41         return
  42 }
  43
  44 func TestSimpleText(t *testing.T) {
  45         assert, require := assert.New(t), require.New(t)
  46
  47         data.Encoder = data.HexEncoder
  48         cases := []struct {
  49                 key      Key
  50                 expected string
  51         }{
  52                 {key: Cool{data.Bytes{0x42, 0x69}}, expected: "cool:4269"},
  53                 {key: Lame{data.Bytes{0x70, 0xA3, 0x1e}}, expected: "lame:70A31E"},
  54         }
  55
  56         for _, tc := range cases {
  57                 wrap := KeyS{tc.key}
  58                 // check json
  59                 _, err := data.ToJSON(wrap)
  60                 require.Nil(err, "%+v", err)
  61                 // check text
  62                 text, err := data.ToText(wrap)
  63                 require.Nil(err, "%+v", err)
  64                 assert.Equal(tc.expected, text)
  65         }
  66 }
  67
  68 func TestBytesTest(t *testing.T) {
  69         assert, require := assert.New(t), require.New(t)
  70
  71         data.Encoder = data.HexEncoder
  72         cases := []struct {
  73                 bytes    data.Bytes
  74                 expected string
  75         }{
  76                 {data.Bytes{0x34, 0x54}, "3454"},
  77                 {data.Bytes{}, ""},
  78                 {data.Bytes{0xde, 0xad, 0xbe, 0x66}, "DEADBE66"},
  79         }
  80
  81         for _, tc := range cases {
  82                 text, err := data.ToText(tc.bytes)
  83                 require.Nil(err, "%+v", err)
  84                 assert.Equal(tc.expected, text)
  85         }
  86 }