// This test determines the behavior of codec with respect to advancing the
// Reader when decoding error scenarios. It seems that the codec advances
// the Reader if Decode fails, but sets its own state to expect a specific
// type for the next Decode, and thus is functionally the same as not
// advancing the Reader.
func TestCodec(t *testing.T) {
var buf bytes.Buffer
mh := &codec.MsgpackHandle{WriteExt: true}
enc := codec.NewEncoder(&buf, mh)
dec := codec.NewDecoder(&buf, mh)
var i int = math.MaxInt32
err := enc.Encode(i)
require.Nil(t, err, "expected encoding to succeed")
require.Equal(t, 5, len(buf.Bytes()), "expected buffer to contain bytes")
var targetInt int
err = dec.Decode(&targetInt)
require.Nil(t, err, "expected decoding to succeed")
require.Equal(t, math.MaxInt32, targetInt, "expected codec to successfully decode int")
require.Equal(t, 0, len(buf.Bytes()), "expected buffer to be empty")
var targetString string
enc.Encode(i)
require.Equal(t, 5, len(buf.Bytes()), "expected buffer to contain bytes")
err = dec.Decode(&targetString)
require.Error(t, err, "expected error while decoding")
require.Contains(t, err.Error(), "Unrecognized descriptor byte", "expected error while decoding")
require.Equal(t, 4, len(buf.Bytes()), "expected buffer to have bytes")
err = dec.Decode(&targetString)
require.Error(t, err, "expected error while decoding")
require.Contains(t, err.Error(), "Unrecognized descriptor byte", "expected error while decoding")
require.Equal(t, 4, len(buf.Bytes()), "expected buffer to have bytes")
targetInt = 0
err = dec.Decode(&targetInt)
require.Nil(t, err, "expected decoding to succeed")
require.Equal(t, math.MaxInt32, targetInt, "expected codec to successfully decode int")
require.Equal(t, 0, len(buf.Bytes()), "expected buffer to be empty")
}
func newPacketHandler(reader io.Reader, protocols *protocolHandler, calls *callContainer) *packetHandler {
return &packetHandler{
reader: reader,
dec: codec.NewDecoder(reader, newCodecMsgpackHandle()),
frameDecoder: newDecoderWrapper(),
protocols: protocols,
calls: calls,
}
}
func newConnDecoder(c net.Conn) *connDecoder {
br := bufio.NewReader(c)
mh := &codec.MsgpackHandle{WriteExt: true}
return &connDecoder{
Conn: c,
Reader: br,
decoder: codec.NewDecoder(br, mh),
}
}
// Decode data into out, but make sure that all bytes in data are
// used.
func MsgpackDecodeAll(data []byte, handle *codec.MsgpackHandle, out interface{}) error {
buf := bytes.NewBuffer(data)
err := codec.NewDecoder(buf, handle).Decode(out)
if err != nil {
return err
}
if buf.Len() > 0 {
return fmt.Errorf("Did not consume entire buffer: %d byte(s) left", buf.Len())
}
return nil
}
// DecodePacketsUnchecked decodes an array of packets from `reader`. It does *not*
// check that the stream was canonical msgpack.
func DecodePacketsUnchecked(reader io.Reader) (ret KeybasePackets, err error) {
ch := codecHandle()
if err = codec.NewDecoder(reader, ch).Decode(&ret); err != nil {
return
}
for _, p := range ret {
err = p.unpackBody(ch)
if err != nil {
return
}
}
return
}
// Test an output from objective C that was breaking the server
func TestObjcOutput(t *testing.T) {
dat, err := ioutil.ReadFile("objc_output.dat")
require.Nil(t, err, "an error occurred while reading dat file")
v, err := base64.StdEncoding.DecodeString(string(dat))
require.Nil(t, err, "an error occurred while decoding base64 dat file")
buf := bytes.NewBuffer(v)
var i int
mh := newCodecMsgpackHandle()
dec := codec.NewDecoder(buf, mh)
err = dec.Decode(&i)
require.Nil(t, err, "an error occurred while decoding an integer")
require.Equal(t, buf.Len(), i, "Bad frame")
var a interface{}
err = dec.Decode(&a)
require.Nil(t, err, "an error occurred while decoding object")
}
func TestMap(t *testing.T) {
var buf bytes.Buffer
mh := newCodecMsgpackHandle()
enc := codec.NewEncoder(&buf, mh)
dec := codec.NewDecoder(&buf, mh)
m := map[string]string{
"hello": "world",
"foo": "bar",
}
err := enc.Encode(m)
require.Nil(t, err, "expected encoding to succeed")
var targetMap map[string]string
err = dec.Decode(&targetMap)
require.Nil(t, err, "expected decoding to succeed")
require.Equal(t, m, targetMap)
var zeroMap map[string]string
var targetMapInterface interface{}
err = enc.Encode(zeroMap)
require.Nil(t, err, "expected encoding to succeed")
err = dec.Decode(&targetMapInterface)
require.Nil(t, err, "expected decoding to succeed")
require.Equal(t, 0, len(buf.Bytes()))
err = enc.Encode([]interface{}{"hello", "world", m})
require.Nil(t, err, "expected encoding to succeed")
var a string
var b string
var c map[string]string
i := []interface{}{&a, &b, &c}
err = dec.Decode(&i)
require.Nil(t, err, "expected decoding to succeed")
require.Equal(t, 0, len(buf.Bytes()))
require.Equal(t, "hello", a)
require.Equal(t, "world", b)
require.Equal(t, m, c)
}
func newMsgpackStream(r io.Reader) *msgpackStream {
return &msgpackStream{decoder: codec.NewDecoder(r, codecHandle())}
}
