+++ /dev/null
-package data_test
-
-import (
- "encoding/json"
- "testing"
-
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
- data "github.com/tendermint/go-wire/data"
-)
-
-func TestEncoders(t *testing.T) {
- assert := assert.New(t)
-
- hex := data.HexEncoder
- b64 := data.B64Encoder
- rb64 := data.RawB64Encoder
- cases := []struct {
- encoder data.ByteEncoder
- input, expected []byte
- }{
- // hexidecimal
- {hex, []byte(`"1A2B3C4D"`), []byte{0x1a, 0x2b, 0x3c, 0x4d}},
- {hex, []byte(`"DE14"`), []byte{0xde, 0x14}},
- // these are errors
- {hex, []byte(`0123`), nil}, // not in quotes
- {hex, []byte(`"dewq12"`), nil}, // invalid chars
- {hex, []byte(`"abc"`), nil}, // uneven length
-
- // base64
- {b64, []byte(`"Zm9v"`), []byte("foo")},
- {b64, []byte(`"RCEuM3M="`), []byte("D!.3s")},
- // make sure url encoding!
- {b64, []byte(`"D4_a--w="`), []byte{0x0f, 0x8f, 0xda, 0xfb, 0xec}},
- // these are errors
- {b64, []byte(`"D4/a++1="`), nil}, // non-url encoding
- {b64, []byte(`0123`), nil}, // not in quotes
- {b64, []byte(`"hey!"`), nil}, // invalid chars
- {b64, []byte(`"abc"`), nil}, // length%4 != 0
-
- // raw base64
- {rb64, []byte(`"Zm9v"`), []byte("foo")},
- {rb64, []byte(`"RCEuM3M"`), []byte("D!.3s")},
- // make sure url encoding!
- {rb64, []byte(`"D4_a--w"`), []byte{0x0f, 0x8f, 0xda, 0xfb, 0xec}},
- // these are errors
- {rb64, []byte(`"D4/a++1"`), nil}, // non-url encoding
- {rb64, []byte(`0123`), nil}, // not in quotes
- {rb64, []byte(`"hey!"`), nil}, // invalid chars
- {rb64, []byte(`"abc="`), nil}, // with padding
-
- }
-
- for _, tc := range cases {
- var output []byte
- err := tc.encoder.Unmarshal(&output, tc.input)
- if tc.expected == nil {
- assert.NotNil(err, tc.input)
- } else if assert.Nil(err, "%s: %+v", tc.input, err) {
- assert.Equal(tc.expected, output, tc.input)
- rev, err := tc.encoder.Marshal(tc.expected)
- if assert.Nil(err, tc.input) {
- assert.Equal(tc.input, rev)
- }
- }
- }
-}
-
-func TestString(t *testing.T) {
- assert := assert.New(t)
-
- hex := data.HexEncoder
- b64 := data.B64Encoder
- rb64 := data.RawB64Encoder
- cases := []struct {
- encoder data.ByteEncoder
- expected string
- input []byte
- }{
- // hexidecimal
- {hex, "1A2B3C4D", []byte{0x1a, 0x2b, 0x3c, 0x4d}},
- {hex, "DE14", []byte{0xde, 0x14}},
- {b64, "RCEuM3M=", []byte("D!.3s")},
- {rb64, "D4_a--w", []byte{0x0f, 0x8f, 0xda, 0xfb, 0xec}},
- }
- for _, tc := range cases {
- data.Encoder = tc.encoder
- b := data.Bytes(tc.input)
- assert.Equal(tc.expected, b.String())
- }
-}
-
-// BData can be encoded/decoded
-type BData struct {
- Count int
- Data data.Bytes
-}
-
-// BView is to unmarshall and check the encoding
-type BView struct {
- Count int
- Data string
-}
-
-func TestBytes(t *testing.T) {
- assert, require := assert.New(t), require.New(t)
-
- cases := []struct {
- encoder data.ByteEncoder
- data data.Bytes
- expected string
- }{
- {data.HexEncoder, []byte{0x1a, 0x2b, 0x3c, 0x4d}, "1A2B3C4D"},
- {data.B64Encoder, []byte("D!.3s"), "RCEuM3M="},
- {data.RawB64Encoder, []byte("D!.3s"), "RCEuM3M"},
- }
-
- for i, tc := range cases {
- data.Encoder = tc.encoder
- // encode the data
- in := BData{Count: 15, Data: tc.data}
- d, err := json.Marshal(in)
- require.Nil(err, "%d: %+v", i, err)
- // recover the data
- out := BData{}
- err = json.Unmarshal(d, &out)
- require.Nil(err, "%d: %+v", i, err)
- assert.Equal(in.Count, out.Count, "%d", i)
- assert.Equal(in.Data, out.Data, "%d", i)
- // check the encoding
- view := BView{}
- err = json.Unmarshal(d, &view)
- require.Nil(err, "%d: %+v", i, err)
- assert.Equal(tc.expected, view.Data)
- }
-}
-
-/*** this is example code for the byte array ***/
-
-type Dings [5]byte
-
-func (d Dings) MarshalJSON() ([]byte, error) {
- return data.Encoder.Marshal(d[:])
-}
-
-func (d *Dings) UnmarshalJSON(enc []byte) error {
- var ref []byte
- err := data.Encoder.Unmarshal(&ref, enc)
- copy(d[:], ref)
- return err
-}
-
-func TestByteArray(t *testing.T) {
- assert, require := assert.New(t), require.New(t)
-
- d := Dings{}
- copy(d[:], []byte("D!.3s"))
-
- cases := []struct {
- encoder data.ByteEncoder
- data Dings
- expected string
- }{
- {data.HexEncoder, Dings{0x1a, 0x2b, 0x3c, 0x4d, 0x5e}, "1A2B3C4D5E"},
- {data.B64Encoder, d, "RCEuM3M="},
- {data.RawB64Encoder, d, "RCEuM3M"},
- }
-
- for i, tc := range cases {
- data.Encoder = tc.encoder
- // encode the data
- d, err := json.Marshal(tc.data)
- require.Nil(err, "%d: %+v", i, err)
- // recover the data
- out := Dings{}
- err = json.Unmarshal(d, &out)
- require.Nil(err, "%d: %+v", i, err)
- assert.Equal(tc.data, out, "%d", i)
- // check the encoding
- view := ""
- err = json.Unmarshal(d, &view)
- require.Nil(err, "%d: %+v", i, err)
- assert.Equal(tc.expected, view)
- }
-
- // Test invalid data
- invalid := []byte(`"food"`)
- data.Encoder = data.HexEncoder
- ding := Dings{1, 2, 3, 4, 5}
- parsed := ding
- require.Equal(ding, parsed)
- // on a failed parsing, we don't overwrite any data
- err := json.Unmarshal(invalid, &parsed)
- require.NotNil(err)
- assert.Equal(ding, parsed)
-}
-
-// I guess this is "proper"? Seems funny though...
-// echo -n "deadbQ==" | base64 -D | od -H
-// echo -n "deadb9==" | base64 -D | od -H
-// both ---> 6f9de675
-// func TestWTF(t *testing.T) {
-// assert := assert.New(t)
-// url := base64.URLEncoding
-// std := base64.StdEncoding
-
-// cases := []struct {
-// s string
-// e *base64.Encoding
-// }{
-// // these fail...
-// {"D4_a--1=", url},
-// {"D4_a0-1=", url},
-// {"D4_a__1=", url},
-// {"D4/a++1=", std},
-// {"D4_a0-9=", url},
-// {"Finey-1=", url},
-// {"Finey41=", url},
-// {"Finey+1=", std},
-// {"Finey+1+", std},
-// {"Fineyo1=", url},
-// // these work
-// {"D4_a0-A=", url},
-// {"D4_a0BA=", url},
-// // more random ending in [1-9]=
-// {"deadbe7=", url},
-// {"deadb7==", url},
-// {"deadbe==", url},
-// // wait, 0= is safe...
-// {"deadbe0=", url},
-// {"deadAA2=", std},
-// {"deadAA9=", std},
-// {"deadaa9=", url},
-// }
-
-// for _, tc := range cases {
-// b, err := tc.e.DecodeString(tc.s)
-// if assert.Nil(err, "%#v", err) {
-// s := tc.e.EncodeToString(b)
-// assert.Equal(tc.s, s)
-// }
-// }
-// }
OSDN Git Service
