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

   1 package data_test
   2
   3 import (
   4         "encoding/json"
   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 func TestEncoders(t *testing.T) {
  13         assert := assert.New(t)
  14
  15         hex := data.HexEncoder
  16         b64 := data.B64Encoder
  17         rb64 := data.RawB64Encoder
  18         cases := []struct {
  19                 encoder         data.ByteEncoder
  20                 input, expected []byte
  21         }{
  22                 // hexidecimal
  23                 {hex, []byte(`"1A2B3C4D"`), []byte{0x1a, 0x2b, 0x3c, 0x4d}},
  24                 {hex, []byte(`"DE14"`), []byte{0xde, 0x14}},
  25                 // these are errors
  26                 {hex, []byte(`0123`), nil},     // not in quotes
  27                 {hex, []byte(`"dewq12"`), nil}, // invalid chars
  28                 {hex, []byte(`"abc"`), nil},    // uneven length
  29
  30                 // base64
  31                 {b64, []byte(`"Zm9v"`), []byte("foo")},
  32                 {b64, []byte(`"RCEuM3M="`), []byte("D!.3s")},
  33                 // make sure url encoding!
  34                 {b64, []byte(`"D4_a--w="`), []byte{0x0f, 0x8f, 0xda, 0xfb, 0xec}},
  35                 // these are errors
  36                 {b64, []byte(`"D4/a++1="`), nil}, // non-url encoding
  37                 {b64, []byte(`0123`), nil},       // not in quotes
  38                 {b64, []byte(`"hey!"`), nil},     // invalid chars
  39                 {b64, []byte(`"abc"`), nil},      // length%4 != 0
  40
  41                 // raw base64
  42                 {rb64, []byte(`"Zm9v"`), []byte("foo")},
  43                 {rb64, []byte(`"RCEuM3M"`), []byte("D!.3s")},
  44                 // make sure url encoding!
  45                 {rb64, []byte(`"D4_a--w"`), []byte{0x0f, 0x8f, 0xda, 0xfb, 0xec}},
  46                 // these are errors
  47                 {rb64, []byte(`"D4/a++1"`), nil}, // non-url encoding
  48                 {rb64, []byte(`0123`), nil},      // not in quotes
  49                 {rb64, []byte(`"hey!"`), nil},    // invalid chars
  50                 {rb64, []byte(`"abc="`), nil},    // with padding
  51
  52         }
  53
  54         for _, tc := range cases {
  55                 var output []byte
  56                 err := tc.encoder.Unmarshal(&output, tc.input)
  57                 if tc.expected == nil {
  58                         assert.NotNil(err, tc.input)
  59                 } else if assert.Nil(err, "%s: %+v", tc.input, err) {
  60                         assert.Equal(tc.expected, output, tc.input)
  61                         rev, err := tc.encoder.Marshal(tc.expected)
  62                         if assert.Nil(err, tc.input) {
  63                                 assert.Equal(tc.input, rev)
  64                         }
  65                 }
  66         }
  67 }
  68
  69 func TestString(t *testing.T) {
  70         assert := assert.New(t)
  71
  72         hex := data.HexEncoder
  73         b64 := data.B64Encoder
  74         rb64 := data.RawB64Encoder
  75         cases := []struct {
  76                 encoder  data.ByteEncoder
  77                 expected string
  78                 input    []byte
  79         }{
  80                 // hexidecimal
  81                 {hex, "1A2B3C4D", []byte{0x1a, 0x2b, 0x3c, 0x4d}},
  82                 {hex, "DE14", []byte{0xde, 0x14}},
  83                 {b64, "RCEuM3M=", []byte("D!.3s")},
  84                 {rb64, "D4_a--w", []byte{0x0f, 0x8f, 0xda, 0xfb, 0xec}},
  85         }
  86         for _, tc := range cases {
  87                 data.Encoder = tc.encoder
  88                 b := data.Bytes(tc.input)
  89                 assert.Equal(tc.expected, b.String())
  90         }
  91 }
  92
  93 // BData can be encoded/decoded
  94 type BData struct {
  95         Count int
  96         Data  data.Bytes
  97 }
  98
  99 // BView is to unmarshall and check the encoding
 100 type BView struct {
 101         Count int
 102         Data  string
 103 }
 104
 105 func TestBytes(t *testing.T) {
 106         assert, require := assert.New(t), require.New(t)
 107
 108         cases := []struct {
 109                 encoder  data.ByteEncoder
 110                 data     data.Bytes
 111                 expected string
 112         }{
 113                 {data.HexEncoder, []byte{0x1a, 0x2b, 0x3c, 0x4d}, "1A2B3C4D"},
 114                 {data.B64Encoder, []byte("D!.3s"), "RCEuM3M="},
 115                 {data.RawB64Encoder, []byte("D!.3s"), "RCEuM3M"},
 116         }
 117
 118         for i, tc := range cases {
 119                 data.Encoder = tc.encoder
 120                 // encode the data
 121                 in := BData{Count: 15, Data: tc.data}
 122                 d, err := json.Marshal(in)
 123                 require.Nil(err, "%d: %+v", i, err)
 124                 // recover the data
 125                 out := BData{}
 126                 err = json.Unmarshal(d, &out)
 127                 require.Nil(err, "%d: %+v", i, err)
 128                 assert.Equal(in.Count, out.Count, "%d", i)
 129                 assert.Equal(in.Data, out.Data, "%d", i)
 130                 // check the encoding
 131                 view := BView{}
 132                 err = json.Unmarshal(d, &view)
 133                 require.Nil(err, "%d: %+v", i, err)
 134                 assert.Equal(tc.expected, view.Data)
 135         }
 136 }
 137
 138 /*** this is example code for the byte array ***/
 139
 140 type Dings [5]byte
 141
 142 func (d Dings) MarshalJSON() ([]byte, error) {
 143         return data.Encoder.Marshal(d[:])
 144 }
 145
 146 func (d *Dings) UnmarshalJSON(enc []byte) error {
 147         var ref []byte
 148         err := data.Encoder.Unmarshal(&ref, enc)
 149         copy(d[:], ref)
 150         return err
 151 }
 152
 153 func TestByteArray(t *testing.T) {
 154         assert, require := assert.New(t), require.New(t)
 155
 156         d := Dings{}
 157         copy(d[:], []byte("D!.3s"))
 158
 159         cases := []struct {
 160                 encoder  data.ByteEncoder
 161                 data     Dings
 162                 expected string
 163         }{
 164                 {data.HexEncoder, Dings{0x1a, 0x2b, 0x3c, 0x4d, 0x5e}, "1A2B3C4D5E"},
 165                 {data.B64Encoder, d, "RCEuM3M="},
 166                 {data.RawB64Encoder, d, "RCEuM3M"},
 167         }
 168
 169         for i, tc := range cases {
 170                 data.Encoder = tc.encoder
 171                 // encode the data
 172                 d, err := json.Marshal(tc.data)
 173                 require.Nil(err, "%d: %+v", i, err)
 174                 // recover the data
 175                 out := Dings{}
 176                 err = json.Unmarshal(d, &out)
 177                 require.Nil(err, "%d: %+v", i, err)
 178                 assert.Equal(tc.data, out, "%d", i)
 179                 // check the encoding
 180                 view := ""
 181                 err = json.Unmarshal(d, &view)
 182                 require.Nil(err, "%d: %+v", i, err)
 183                 assert.Equal(tc.expected, view)
 184         }
 185
 186         // Test invalid data
 187         invalid := []byte(`"food"`)
 188         data.Encoder = data.HexEncoder
 189         ding := Dings{1, 2, 3, 4, 5}
 190         parsed := ding
 191         require.Equal(ding, parsed)
 192         // on a failed parsing, we don't overwrite any data
 193         err := json.Unmarshal(invalid, &parsed)
 194         require.NotNil(err)
 195         assert.Equal(ding, parsed)
 196 }
 197
 198 // I guess this is "proper"?  Seems funny though...
 199 // echo -n "deadbQ==" | base64 -D | od -H
 200 // echo -n "deadb9==" | base64 -D | od -H
 201 // both ---> 6f9de675
 202 // func TestWTF(t *testing.T) {
 203 //      assert := assert.New(t)
 204 //      url := base64.URLEncoding
 205 //      std := base64.StdEncoding
 206
 207 //      cases := []struct {
 208 //              s string
 209 //              e *base64.Encoding
 210 //      }{
 211 //              // these fail...
 212 //              {"D4_a--1=", url},
 213 //              {"D4_a0-1=", url},
 214 //              {"D4_a__1=", url},
 215 //              {"D4/a++1=", std},
 216 //              {"D4_a0-9=", url},
 217 //              {"Finey-1=", url},
 218 //              {"Finey41=", url},
 219 //              {"Finey+1=", std},
 220 //              {"Finey+1+", std},
 221 //              {"Fineyo1=", url},
 222 //              // these work
 223 //              {"D4_a0-A=", url},
 224 //              {"D4_a0BA=", url},
 225 //              // more random ending in [1-9]=
 226 //              {"deadbe7=", url},
 227 //              {"deadb7==", url},
 228 //              {"deadbe==", url},
 229 //              // wait, 0= is safe...
 230 //              {"deadbe0=", url},
 231 //              {"deadAA2=", std},
 232 //              {"deadAA9=", std},
 233 //              {"deadaa9=", url},
 234 //      }
 235
 236 //      for _, tc := range cases {
 237 //              b, err := tc.e.DecodeString(tc.s)
 238 //              if assert.Nil(err, "%#v", err) {
 239 //                      s := tc.e.EncodeToString(b)
 240 //                      assert.Equal(tc.s, s)
 241 //              }
 242 //      }
 243 // }