7 "github.com/stretchr/testify/assert"
8 "github.com/stretchr/testify/require"
9 data "github.com/tendermint/go-wire/data"
12 func TestEncoders(t *testing.T) {
13 assert := assert.New(t)
15 hex := data.HexEncoder
16 b64 := data.B64Encoder
17 rb64 := data.RawB64Encoder
19 encoder data.ByteEncoder
20 input, expected []byte
23 {hex, []byte(`"1A2B3C4D"`), []byte{0x1a, 0x2b, 0x3c, 0x4d}},
24 {hex, []byte(`"DE14"`), []byte{0xde, 0x14}},
26 {hex, []byte(`0123`), nil}, // not in quotes
27 {hex, []byte(`"dewq12"`), nil}, // invalid chars
28 {hex, []byte(`"abc"`), nil}, // uneven length
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}},
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
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}},
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
54 for _, tc := range cases {
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)
69 func TestString(t *testing.T) {
70 assert := assert.New(t)
72 hex := data.HexEncoder
73 b64 := data.B64Encoder
74 rb64 := data.RawB64Encoder
76 encoder data.ByteEncoder
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}},
86 for _, tc := range cases {
87 data.Encoder = tc.encoder
88 b := data.Bytes(tc.input)
89 assert.Equal(tc.expected, b.String())
93 // BData can be encoded/decoded
99 // BView is to unmarshall and check the encoding
105 func TestBytes(t *testing.T) {
106 assert, require := assert.New(t), require.New(t)
109 encoder data.ByteEncoder
113 {data.HexEncoder, []byte{0x1a, 0x2b, 0x3c, 0x4d}, "1A2B3C4D"},
114 {data.B64Encoder, []byte("D!.3s"), "RCEuM3M="},
115 {data.RawB64Encoder, []byte("D!.3s"), "RCEuM3M"},
118 for i, tc := range cases {
119 data.Encoder = tc.encoder
121 in := BData{Count: 15, Data: tc.data}
122 d, err := json.Marshal(in)
123 require.Nil(err, "%d: %+v", i, err)
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
132 err = json.Unmarshal(d, &view)
133 require.Nil(err, "%d: %+v", i, err)
134 assert.Equal(tc.expected, view.Data)
138 /*** this is example code for the byte array ***/
142 func (d Dings) MarshalJSON() ([]byte, error) {
143 return data.Encoder.Marshal(d[:])
146 func (d *Dings) UnmarshalJSON(enc []byte) error {
148 err := data.Encoder.Unmarshal(&ref, enc)
153 func TestByteArray(t *testing.T) {
154 assert, require := assert.New(t), require.New(t)
157 copy(d[:], []byte("D!.3s"))
160 encoder data.ByteEncoder
164 {data.HexEncoder, Dings{0x1a, 0x2b, 0x3c, 0x4d, 0x5e}, "1A2B3C4D5E"},
165 {data.B64Encoder, d, "RCEuM3M="},
166 {data.RawB64Encoder, d, "RCEuM3M"},
169 for i, tc := range cases {
170 data.Encoder = tc.encoder
172 d, err := json.Marshal(tc.data)
173 require.Nil(err, "%d: %+v", i, err)
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
181 err = json.Unmarshal(d, &view)
182 require.Nil(err, "%d: %+v", i, err)
183 assert.Equal(tc.expected, view)
187 invalid := []byte(`"food"`)
188 data.Encoder = data.HexEncoder
189 ding := Dings{1, 2, 3, 4, 5}
191 require.Equal(ding, parsed)
192 // on a failed parsing, we don't overwrite any data
193 err := json.Unmarshal(invalid, &parsed)
195 assert.Equal(ding, parsed)
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
207 // cases := []struct {
209 // e *base64.Encoding
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},
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},
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)