package msgpack_test

import (
	"bufio"
	"bytes"
	"encoding/binary"
	"encoding/csv"
	"encoding/gob"
	"encoding/json"
	"io"
	"math"
	"strconv"
	"testing"
	"time"

	"git.bit5.ru/backend/msgpack"

	//msgpack2 "github.com/ugorji/go-msgpack"
	"github.com/ugorji/go/codec"
	. "launchpad.net/gocheck"
)

type nameStruct struct {
	Name string
}

func Test(t *testing.T) { TestingT(t) }

type MsgpackTest struct {
	buf *bytes.Buffer
	enc *msgpack.Encoder
	dec *msgpack.Decoder
}

var _ = Suite(&MsgpackTest{})

func (t *MsgpackTest) SetUpTest(c *C) {
	t.buf = &bytes.Buffer{}
	t.enc = msgpack.NewEncoder(t.buf)
	t.dec = msgpack.NewDecoder(bufio.NewReader(t.buf))
}

func (t *MsgpackTest) TestUint(c *C) {
	table := []struct {
		v uint
		b []byte
	}{
		{0, []byte{0x00}},
		{1, []byte{0x01}},
		{2, []byte{0x02}},
		{125, []byte{0x7d}},
		{126, []byte{0x7e}},
		{127, []byte{0x7f}},
		{128, []byte{0xcc, 0x80}},
		{253, []byte{0xcc, 0xfd}},
		{254, []byte{0xcc, 0xfe}},
		{255, []byte{0xcc, 0xff}},
		{256, []byte{0xcd, 0x01, 0x00}},
		{65533, []byte{0xcd, 0xff, 0xfd}},
		{65534, []byte{0xcd, 0xff, 0xfe}},
		{65535, []byte{0xcd, 0xff, 0xff}},
		{65536, []byte{0xce, 0x00, 0x01, 0x00, 0x00}},
		{4294967293, []byte{0xce, 0xff, 0xff, 0xff, 0xfd}},
		{4294967294, []byte{0xce, 0xff, 0xff, 0xff, 0xfe}},
		{4294967295, []byte{0xce, 0xff, 0xff, 0xff, 0xff}},
		{4294967296, []byte{0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}},
		{18446744073709551613, []byte{0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd}},
		{18446744073709551614, []byte{0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
		{18446744073709551615, []byte{0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
	}
	for _, r := range table {
		c.Assert(t.enc.Encode(r.v), IsNil)
		c.Assert(t.buf.Bytes(), DeepEquals, r.b, Commentf("err encoding %v", r.v))
		var v uint
		c.Assert(t.dec.Decode(&v), IsNil)
		c.Assert(v, Equals, r.v)
	}
}

func (t *MsgpackTest) TestInt(c *C) {
	table := []struct {
		v int
		b []byte
	}{
		{-9223372036854775808, []byte{0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
		{-9223372036854775807, []byte{0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}},
		{-9223372036854775806, []byte{0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}},
		{-2147483651, []byte{0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xfd}},
		{-2147483650, []byte{0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xfe}},
		{-2147483649, []byte{0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff}},
		{-2147483648, []byte{0xd2, 0x80, 0x00, 0x00, 0x00}},
		{-2147483647, []byte{0xd2, 0x80, 0x00, 0x00, 0x01}},
		{-2147483646, []byte{0xd2, 0x80, 0x00, 0x00, 0x002}},
		{-32771, []byte{0xd2, 0xff, 0xff, 0x7f, 0xfd}},
		{-32770, []byte{0xd2, 0xff, 0xff, 0x7f, 0xfe}},
		{-32769, []byte{0xd2, 0xff, 0xff, 0x7f, 0xff}},
		{-32768, []byte{0xd1, 0x80, 0x00}},
		{-32767, []byte{0xd1, 0x80, 0x01}},
		{-131, []byte{0xd1, 0xff, 0x7d}},
		{-130, []byte{0xd1, 0xff, 0x7e}},
		{-129, []byte{0xd1, 0xff, 0x7f}},
		{-128, []byte{0xd0, 0x80}},
		{-127, []byte{0xd0, 0x81}},
		{-34, []byte{0xd0, 0xde}},
		{-33, []byte{0xd0, 0xdf}},
		{-32, []byte{0xe0}},
		{-31, []byte{0xe1}},
		{0, []byte{0x00}},
		{1, []byte{0x01}},
		{126, []byte{0x7e}},
		{127, []byte{0x7f}},
		{128, []byte{0xd1, 0x00, 0x80}},
		{129, []byte{0xd1, 0x00, 0x81}},
		{130, []byte{0xd1, 0x00, 0x82}},
		{32765, []byte{0xd1, 0x7f, 0xfd}},
		{32766, []byte{0xd1, 0x7f, 0xfe}},
		{32767, []byte{0xd1, 0x7f, 0xff}},
		{32768, []byte{0xd2, 0x00, 0x00, 0x80, 0x00}},
		{32769, []byte{0xd2, 0x00, 0x00, 0x80, 0x01}},
		{32770, []byte{0xd2, 0x00, 0x00, 0x80, 0x02}},
		{2147483645, []byte{0xd2, 0x7f, 0xff, 0xff, 0xfd}},
		{2147483646, []byte{0xd2, 0x7f, 0xff, 0xff, 0xfe}},
		{2147483647, []byte{0xd2, 0x7f, 0xff, 0xff, 0xff}},
		{2147483648, []byte{0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00}},
		{2147483649, []byte{0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x01}},
		{2147483650, []byte{0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x02}},
		{4294967296, []byte{0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}},
		{4294967297, []byte{0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01}},
		{4294967298, []byte{0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02}},
	}
	for _, r := range table {
		c.Assert(t.enc.Encode(r.v), IsNil)
		c.Assert(t.buf.Bytes(), DeepEquals, r.b, Commentf("err encoding %v", r.v))
		var v int
		c.Assert(t.dec.Decode(&v), IsNil)
		c.Assert(v, Equals, r.v)
	}
}

func (t *MsgpackTest) TestFloat32(c *C) {
	table := []struct {
		v float32
		b []byte
	}{
		{.1, []byte{0xca, 0x3d, 0xcc, 0xcc, 0xcd}},
		{.2, []byte{0xca, 0x3e, 0x4c, 0xcc, 0xcd}},
		{-.1, []byte{0xca, 0xbd, 0xcc, 0xcc, 0xcd}},
		{-.2, []byte{0xca, 0xbe, 0x4c, 0xcc, 0xcd}},
		{float32(math.Inf(1)), []byte{0xca, 0x7f, 0x80, 0x00, 0x00}},
		{float32(math.Inf(-1)), []byte{0xca, 0xff, 0x80, 0x00, 0x00}},
		{math.MaxFloat32, []byte{0xca, 0x7f, 0x7f, 0xff, 0xff}},
		{math.SmallestNonzeroFloat32, []byte{0xca, 0x0, 0x0, 0x0, 0x1}},
	}
	for _, r := range table {
		c.Assert(t.enc.Encode(r.v), IsNil)
		c.Assert(t.buf.Bytes(), DeepEquals, r.b, Commentf("err encoding %v", r.v))
		var v float32
		c.Assert(t.dec.Decode(&v), IsNil)
		c.Assert(v, Equals, r.v)
	}

	in := float32(math.NaN())
	c.Assert(t.enc.Encode(in), IsNil)
	var out float32
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(math.IsNaN(float64(out)), Equals, true)
}

func (t *MsgpackTest) TestFloat64(c *C) {
	table := []struct {
		v float64
		b []byte
	}{
		{.1, []byte{0xcb, 0x3f, 0xb9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a}},
		{.2, []byte{0xcb, 0x3f, 0xc9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a}},
		{-.1, []byte{0xcb, 0xbf, 0xb9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a}},
		{-.2, []byte{0xcb, 0xbf, 0xc9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a}},
		{math.Inf(1), []byte{0xcb, 0x7f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}},
		{math.Inf(-1), []byte{0xcb, 0xff, 0xf0, 0x00, 0x00, 0x0, 0x0, 0x0, 0x0}},
		{math.MaxFloat64, []byte{0xcb, 0x7f, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
		{math.SmallestNonzeroFloat64, []byte{0xcb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1}},
	}
	for _, r := range table {
		c.Assert(t.enc.Encode(r.v), IsNil)
		c.Assert(t.buf.Bytes(), DeepEquals, r.b, Commentf("err encoding %v", r.v))
		var v float64
		c.Assert(t.dec.Decode(&v), IsNil)
		c.Assert(v, Equals, r.v)
	}

	in := math.NaN()
	c.Assert(t.enc.Encode(in), IsNil)
	var out float64
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(math.IsNaN(out), Equals, true)
}

func (t *MsgpackTest) TestBool(c *C) {
	table := []struct {
		v bool
		b []byte
	}{
		{false, []byte{0xc2}},
		{true, []byte{0xc3}},
	}
	for _, r := range table {
		c.Assert(t.enc.Encode(r.v), IsNil)
		c.Assert(t.buf.Bytes(), DeepEquals, r.b, Commentf("err encoding %v", r.v))
		var v bool
		c.Assert(t.dec.Decode(&v), IsNil)
		c.Assert(v, Equals, r.v)
	}
}

func (t *MsgpackTest) TestNil(c *C) {
	table := []interface{}{
		(*string)(nil),
		(*[]byte)(nil),
		(*int)(nil),
		(*int8)(nil),
		(*int16)(nil),
		(*int32)(nil),
		(*int64)(nil),
		(*uint)(nil),
		(*uint8)(nil),
		(*uint16)(nil),
		(*uint32)(nil),
		(*uint64)(nil),
		(*bool)(nil),
		(*float32)(nil),
		(*float64)(nil),
		(*[]string)(nil),
		(*map[string]string)(nil),
		(*time.Duration)(nil),
		(*time.Time)(nil),
		(*struct{})(nil),
	}
	for _, dst := range table {
		c.Assert(t.enc.Encode(nil), IsNil)
		c.Assert(t.buf.Bytes(), DeepEquals, []byte{0xC0})
		c.Assert(t.dec.Decode(dst), IsNil)
		c.Assert(dst, IsNil)
	}
}

func (t *MsgpackTest) TestDecodeNil(c *C) {
	c.Assert(t.dec.Decode(nil), NotNil)
}

func (t *MsgpackTest) TestTime(c *C) {
	in := time.Now()
	var out time.Time
	c.Assert(t.enc.Encode(in), IsNil)
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(out.Equal(in), Equals, true)

	var zero time.Time
	c.Assert(t.enc.Encode(zero), IsNil)
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(out.Equal(zero), Equals, true)
	c.Assert(out.IsZero(), Equals, true)
}

func (t *MsgpackTest) TestSliceOfInts(c *C) {
	for _, i := range []struct {
		src []int
		b   []byte
	}{
		{nil, []byte{0xc0}},
		{[]int{}, []byte{0x90}},
		{[]int{0}, []byte{0x91, 0x0}},
	} {
		c.Assert(t.enc.Encode(i.src), IsNil)
		c.Assert(t.buf.Bytes(), DeepEquals, i.b)
		var dst []int
		c.Assert(t.dec.Decode(&dst), IsNil)
		c.Assert(dst, DeepEquals, i.src)
	}
}

func (t *MsgpackTest) TestArrayOfInts(c *C) {
	src := [3]int{1, 2, 3}
	c.Assert(t.enc.Encode(src), IsNil)
	var dst [3]int
	c.Assert(t.dec.Decode(&dst), IsNil)
	c.Assert(dst, DeepEquals, src)
}

func (t *MsgpackTest) TestSliceOfStrings(c *C) {
	for _, i := range []struct {
		src []string
		b   []byte
	}{
		{nil, []byte{0xc0}},
		{[]string{}, []byte{0x90}},
		{[]string{"foo", "bar"}, []byte{0x92, 0xa3, 'f', 'o', 'o', 0xa3, 'b', 'a', 'r'}},
	} {
		c.Assert(t.enc.Encode(i.src), IsNil)
		c.Assert(t.buf.Bytes(), DeepEquals, i.b)
		var dst []string
		c.Assert(t.dec.Decode(&dst), IsNil)
		c.Assert(dst, DeepEquals, i.src)
	}
}

func (t *MsgpackTest) TestArrayOfStrings(c *C) {
	src := [2]string{"hello", "world"}
	c.Assert(t.enc.Encode(src), IsNil)
	var dst [2]string
	c.Assert(t.dec.Decode(&dst), IsNil)
	c.Assert(dst, DeepEquals, src)
}

func (t *MsgpackTest) TestString(c *C) {
	for _, i := range []struct {
		src string
		b   []byte
	}{
		{"", []byte{0xa0}},
		{"a", []byte{0xa1, 'a'}},
		{"hello", append([]byte{0xa5}, "hello"...)},
		{
			"world world world",
			append([]byte{0xb1}, "world world world"...),
		},
		{
			"world world world world world world",
			append([]byte{0xda, 0x0, 0x23}, "world world world world world world"...),
		},
	} {
		c.Assert(t.enc.Encode(i.src), IsNil)
		c.Assert(t.buf.Bytes(), DeepEquals, i.b)
		var dst string
		c.Assert(t.dec.Decode(&dst), IsNil)
		c.Assert(dst, Equals, i.src)
	}
}

func (t *MsgpackTest) TestBytes(c *C) {
	for _, i := range []struct {
		src []byte
		b   []byte
	}{
		{nil, []byte{0xc0}},
		{[]byte{}, []byte{0xa0}},
		{[]byte("a"), []byte{0xa1, 'a'}},
		{[]byte("hello"), append([]byte{0xa5}, "hello"...)},
		{
			[]byte("world world world"),
			append([]byte{0xb1}, "world world world"...),
		},
		{
			[]byte("world world world world world world"),
			append([]byte{0xda, 0x0, 0x23}, "world world world world world world"...),
		},
	} {
		c.Assert(t.enc.Encode(i.src), IsNil)
		c.Assert(t.buf.Bytes(), DeepEquals, i.b)
		var dst []byte
		c.Assert(t.dec.Decode(&dst), IsNil)
		c.Assert(dst, DeepEquals, i.src)
	}
}

func (t *MsgpackTest) TestLargeBytes(c *C) {
	N := int(1e6)

	src := bytes.Repeat([]byte{'1'}, N)
	c.Assert(t.enc.Encode(src), IsNil)
	var dst []byte
	c.Assert(t.dec.Decode(&dst), IsNil)
	c.Assert(dst, DeepEquals, src)
}

func (t *MsgpackTest) TestLargeString(c *C) {
	N := int(1e6)

	src := string(bytes.Repeat([]byte{'1'}, N))
	c.Assert(t.enc.Encode(src), IsNil)
	var dst string
	c.Assert(t.dec.Decode(&dst), IsNil)
	c.Assert(dst, Equals, src)
}

func (t *MsgpackTest) TestSliceOfStructs(c *C) {
	in := []*nameStruct{&nameStruct{"hello"}}
	var out []*nameStruct
	c.Assert(t.enc.Encode(in), IsNil)
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(out, DeepEquals, in)
}

func (t *MsgpackTest) TestMap(c *C) {
	for _, i := range []struct {
		m map[string]string
		b []byte
	}{
		{map[string]string{}, []byte{0x80}},
		{map[string]string{"hello": "world"}, []byte{0x81, 0xa5, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xa5, 0x77, 0x6f, 0x72, 0x6c, 0x64}},
	} {
		c.Assert(t.enc.Encode(i.m), IsNil)
		c.Assert(t.buf.Bytes(), DeepEquals, i.b, Commentf("err encoding %v", i.m))
		var m map[string]string
		c.Assert(t.dec.Decode(&m), IsNil)
		c.Assert(m, DeepEquals, i.m)
	}
}

func (t *MsgpackTest) TestStructNil(c *C) {
	var dst *nameStruct

	c.Assert(t.enc.Encode(nameStruct{Name: "foo"}), IsNil)
	c.Assert(t.dec.Decode(&dst), IsNil)
	c.Assert(dst, Not(IsNil))
	c.Assert(dst.Name, Equals, "foo")
}

type testStruct struct {
	Name   string
	Tm     time.Time
	Data   []byte
	Colors []string
}

func (t *MsgpackTest) TestStruct(c *C) {
	in := &testStruct{
		Name:   "hello world",
		Tm:     time.Now(),
		Data:   []byte{1, 2, 3},
		Colors: []string{"red", "orange", "yellow", "green", "blue", "violet"},
	}
	var out testStruct
	c.Assert(t.enc.Encode(in), IsNil)
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(out.Name, Equals, "hello world")
	c.Assert(out.Tm.Equal(in.Tm), Equals, true)
	c.Assert(out.Data, DeepEquals, []byte{1, 2, 3})
	c.Assert(
		out.Colors,
		DeepEquals,
		[]string{"red", "orange", "yellow", "green", "blue", "violet"},
	)
}

func (t *MsgpackTest) TestStructUnknownField(c *C) {
	in := struct {
		Field1 string
		Field2 string
		Field3 string
	}{
		Field1: "value1",
		Field2: "value2",
		Field3: "value3",
	}
	c.Assert(t.enc.Encode(in), IsNil)

	out := struct {
		Field2 string
	}{}
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(out.Field2, Equals, "value2")
}

//------------------------------------------------------------------------------

type coderStruct struct {
	name string
}

func (s *coderStruct) Name() string {
	return s.name
}

func (s *coderStruct) EncodeMsgpack(w io.Writer) error {
	return msgpack.NewEncoder(w).Encode(s.name)
}

func (s *coderStruct) DecodeMsgpack(r io.Reader) error {
	return msgpack.NewDecoder(r).Decode(&s.name)
}

var _ msgpack.Coder = &coderStruct{}

func (t *MsgpackTest) TestCoder(c *C) {
	in := &coderStruct{name: "hello"}
	var out coderStruct
	c.Assert(t.enc.Encode(in), IsNil)
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(out.Name(), Equals, "hello")
}

func (t *MsgpackTest) TestNilCoder(c *C) {
	in := &coderStruct{name: "hello"}
	var out *coderStruct
	c.Assert(t.enc.Encode(in), IsNil)
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(out.Name(), Equals, "hello")
}

// func (t *MsgpackTest) TestNilCoderValue(c *C) {
// 	in := &coderStruct{name: "hello"}
// 	var out *coderStruct
// 	v := reflect.ValueOf(out)
// 	c.Assert(t.enc.Encode(in), IsNil)
// 	c.Assert(t.dec.DecodeValue(v), IsNil)
// 	c.Assert(out.Name(), Equals, "hello")
// }

func (t *MsgpackTest) TestPtrToCoder(c *C) {
	in := &coderStruct{name: "hello"}
	var out coderStruct
	out2 := &out
	c.Assert(t.enc.Encode(in), IsNil)
	c.Assert(t.dec.Decode(&out2), IsNil)
	c.Assert(out.Name(), Equals, "hello")
}

//------------------------------------------------------------------------------

type struct2 struct {
	Name string
}

type struct1 struct {
	Name    string
	Struct2 struct2
}

func (t *MsgpackTest) TestNestedStructs(c *C) {
	in := &struct1{Name: "hello", Struct2: struct2{Name: "world"}}
	var out struct1
	c.Assert(t.enc.Encode(in), IsNil)
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(out.Name, Equals, in.Name)
	c.Assert(out.Struct2.Name, Equals, in.Struct2.Name)
}

type Struct4 struct {
	Name2 string
}

type Struct3 struct {
	Struct4
	Name1 string
}

func (t *MsgpackTest) TestEmbedding(c *C) {
	in := &Struct3{
		Name1: "hello",
		Struct4: Struct4{
			Name2: "world",
		},
	}
	var out Struct3
	c.Assert(t.enc.Encode(in), IsNil)
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(out.Name1, Equals, in.Name1)
	c.Assert(out.Name2, Equals, in.Name2)
}

func (t *MsgpackTest) TestSliceInterface(c *C) {
	in := []interface{}{1, "hello"}
	var out []interface{}

	c.Assert(t.enc.Encode(in), IsNil)
	c.Assert(t.dec.Decode(&out), IsNil)

	c.Assert(out, HasLen, 2)
	c.Assert(out[0], Equals, int64(1))
	c.Assert(out[1], Equals, "hello")
}

func (t *MsgpackTest) TestSliceNil(c *C) {
	in := [][]*int{nil}
	var out [][]*int

	c.Assert(t.enc.Encode(in), IsNil)
	c.Assert(t.dec.Decode(&out), IsNil)
	c.Assert(out, DeepEquals, in)
}

//------------------------------------------------------------------------------

func (t *MsgpackTest) TestMapStringInterface(c *C) {
	in := map[string]interface{}{
		"foo": "bar",
		"hello": map[string]interface{}{
			"foo": "bar",
		},
	}
	var out map[string]interface{}

	c.Assert(t.enc.Encode(in), IsNil)
	c.Assert(t.dec.Decode(&out), IsNil)

	c.Assert(out["foo"], Equals, "bar")
	mm := out["hello"].(map[interface{}]interface{})
	c.Assert(mm["foo"], Equals, "bar")
}

func (t *MsgpackTest) TestMapStringInterface2(c *C) {
	buf := &bytes.Buffer{}
	enc := msgpack.NewEncoder(buf)
	dec := msgpack.NewDecoder(buf)
	dec.DecodeMapFunc = func(d *msgpack.Decoder) (interface{}, error) {
		n, err := d.DecodeMapLen()
		if err != nil {
			return nil, err
		}

		m := make(map[string]interface{}, n)
		for i := 0; i < n; i++ {
			mk, err := d.DecodeString()
			if err != nil {
				return nil, err
			}

			mv, err := d.DecodeInterface()
			if err != nil {
				return nil, err
			}

			m[mk] = mv
		}
		return m, nil
	}

	in := map[string]interface{}{
		"foo": "bar",
		"hello": map[string]interface{}{
			"foo": "bar",
		},
	}
	var out map[string]interface{}

	c.Assert(enc.Encode(in), IsNil)
	c.Assert(dec.Decode(&out), IsNil)

	c.Assert(out["foo"], Equals, "bar")
	mm := out["hello"].(map[string]interface{})
	c.Assert(mm["foo"], Equals, "bar")
}

//------------------------------------------------------------------------------

func (t *MsgpackTest) BenchmarkBool(c *C) {
	var v bool
	for i := 0; i < c.N; i++ {
		t.enc.Encode(true)
		t.dec.Decode(&v)
	}
	c.Assert(t.buf.Len(), Equals, 0)
}

func (t *MsgpackTest) BenchmarkInt(c *C) {
	var v int
	for i := 0; i < c.N; i++ {
		if err := t.enc.Encode(1); err != nil {
			panic(err)
		}
		if err := t.dec.Decode(&v); err != nil {
			panic(err)
		}
	}
	c.Assert(t.buf.Len(), Equals, 0)
}

func (t *MsgpackTest) BenchmarkIntBinary(c *C) {
	buf := &bytes.Buffer{}

	var out int32
	for i := 0; i < c.N; i++ {
		if err := binary.Write(buf, binary.BigEndian, int32(1)); err != nil {
			panic(err)
		}
		if err := binary.Read(buf, binary.BigEndian, &out); err != nil {
			panic(err)
		}
	}
	c.Assert(buf.Len(), Equals, 0)
}

/*
func (t *MsgpackTest) BenchmarkIntMsgpack2(c *C) {
	buf := &bytes.Buffer{}
	dec := msgpack2.NewDecoder(buf, nil)
	enc := msgpack2.NewEncoder(buf)

	var out int
	for i := 0; i < c.N; i++ {
		if err := enc.Encode(1); err != nil {
			panic(err)
		}
		if err := dec.Decode(&out); err != nil {
			panic(err)
		}
	}
	c.Assert(t.buf.Len(), Equals, 0)
}
*/

func (t *MsgpackTest) BenchmarkIntMsgpack3(c *C) {
	buf := &bytes.Buffer{}
	enc := codec.NewEncoder(buf, &codec.MsgpackHandle{})
	dec := codec.NewDecoder(buf, &codec.MsgpackHandle{})

	var out int
	for i := 0; i < c.N; i++ {
		if err := enc.Encode(1); err != nil {
			panic(err)
		}
		if err := dec.Decode(&out); err != nil {
			panic(err)
		}
	}
	c.Assert(t.buf.Len(), Equals, 0)
}

func (t *MsgpackTest) BenchmarkTime(c *C) {
	in := time.Now()
	var out time.Time
	for i := 0; i < c.N; i++ {
		if err := t.enc.Encode(in); err != nil {
			panic(err)
		}
		if err := t.dec.Decode(&out); err != nil {
			panic(err)
		}
	}
	c.Assert(t.buf.Len(), Equals, 0)
}

func (t *MsgpackTest) BenchmarkDuration(c *C) {
	in := time.Hour
	var out time.Duration
	for i := 0; i < c.N; i++ {
		if err := t.enc.Encode(in); err != nil {
			panic(err)
		}
		if err := t.dec.Decode(&out); err != nil {
			panic(err)
		}
	}
	c.Assert(t.buf.Len(), Equals, 0)
}

func (t *MsgpackTest) BenchmarkBytes(c *C) {
	in := make([]byte, 1024)
	var out []byte
	for i := 0; i < c.N; i++ {
		if err := t.enc.Encode(in); err != nil {
			panic(err)
		}
		if err := t.dec.Decode(&out); err != nil {
			panic(err)
		}
	}
	c.Assert(t.buf.Len(), Equals, 0)
}

func (t *MsgpackTest) BenchmarkMapStringString(c *C) {
	in := map[string]string{
		"hello": "world",
		"foo":   "bar",
	}
	var out map[string]string

	for i := 0; i < c.N; i++ {
		if err := t.enc.Encode(in); err != nil {
			panic(err)
		}
		if err := t.dec.Decode(&out); err != nil {
			panic(err)
		}
	}

	c.Assert(t.buf.Len(), Equals, 0)
}

func (t *MsgpackTest) BenchmarkMapStringStringPtr(c *C) {
	in := map[string]string{
		"hello": "world",
		"foo":   "bar",
	}
	var out map[string]string
	out2 := &out

	for i := 0; i < c.N; i++ {
		if err := t.enc.Encode(&in); err != nil {
			panic(err)
		}
		if err := t.dec.Decode(&out2); err != nil {
			panic(err)
		}
	}

	c.Assert(t.buf.Len(), Equals, 0)
}

func (t *MsgpackTest) BenchmarkMapIntInt(c *C) {
	in := map[int]int{
		1: 10,
		2: 20,
	}
	var out map[int]int

	for i := 0; i < c.N; i++ {
		if err := t.enc.Encode(in); err != nil {
			panic(err)
		}
		if err := t.dec.Decode(&out); err != nil {
			panic(err)
		}
	}

	c.Assert(t.buf.Len(), Equals, 0)
}

func (t *MsgpackTest) BenchmarkStringSlice(c *C) {
	in := []string{"hello", "world"}
	var out []string

	for i := 0; i < c.N; i++ {
		if err := t.enc.Encode(in); err != nil {
			panic(err)
		}
		if err := t.dec.Decode(&out); err != nil {
			panic(err)
		}
	}

	c.Assert(t.buf.Len(), Equals, 0)
}

func (t *MsgpackTest) BenchmarkStringSlicePtr(c *C) {
	in := []string{"hello", "world"}
	var out []string
	out2 := &out

	for i := 0; i < c.N; i++ {
		if err := t.enc.Encode(&in); err != nil {
			panic(err)
		}
		if err := t.dec.Decode(&out2); err != nil {
			panic(err)
		}
	}

	c.Assert(t.buf.Len(), Equals, 0)
}

type benchmarkStruct struct {
	Name      string
	Colors    []string
	Age       int
	Data      []byte
	CreatedAt time.Time
	UpdatedAt time.Time
}

type benchmarkStruct2 struct {
	Name      string
	Colors    []string
	Age       int
	Data      []byte
	CreatedAt time.Time
	UpdatedAt time.Time
}

func (s *benchmarkStruct2) EncodeMsgpack(w io.Writer) error {
	enc := msgpack.NewEncoder(w)
	return enc.Encode(
		s.Name,
		s.Colors,
		s.Age,
		s.Data,
		s.CreatedAt,
		s.UpdatedAt,
	)
}

func (s *benchmarkStruct2) DecodeMsgpack(r io.Reader) error {
	dec := msgpack.NewDecoder(r)
	return dec.Decode(
		&s.Name,
		&s.Colors,
		&s.Age,
		&s.Data,
		&s.CreatedAt,
		&s.UpdatedAt,
	)
}

var _ msgpack.Coder = &benchmarkStruct2{}

func (t *MsgpackTest) structForBenchmark() *benchmarkStruct {
	return &benchmarkStruct{
		Name:      "Hello World",
		Colors:    []string{"red", "orange", "yellow", "green", "blue", "violet"},
		Age:       math.MaxInt32,
		Data:      make([]byte, 1024),
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}
}

func (t *MsgpackTest) structForBenchmark2() *benchmarkStruct2 {
	return &benchmarkStruct2{
		Name:      "Hello World",
		Colors:    []string{"red", "orange", "yellow", "green", "blue", "violet"},
		Age:       math.MaxInt32,
		Data:      make([]byte, 1024),
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}
}

func (t *MsgpackTest) BenchmarkStruct(c *C) {
	in := t.structForBenchmark()
	out := &benchmarkStruct{}
	for i := 0; i < c.N; i++ {
		b, err := msgpack.Marshal(in)
		if err != nil {
			panic(err)
		}
		err = msgpack.Unmarshal(b, out)
		if err != nil {
			panic(err)
		}
	}
}

func (t *MsgpackTest) BenchmarkStructManual(c *C) {
	in := t.structForBenchmark2()
	out := &benchmarkStruct2{}
	for i := 0; i < c.N; i++ {
		b, err := msgpack.Marshal(in)
		if err != nil {
			panic(err)
		}
		err = msgpack.Unmarshal(b, out)
		if err != nil {
			panic(err)
		}
	}
}

/*
func (t *MsgpackTest) BenchmarkStructMsgpack2(c *C) {
	in := t.structForBenchmark()
	out := &benchmarkStruct{}
	for i := 0; i < c.N; i++ {
		b, err := msgpack2.Marshal(in)
		if err != nil {
			panic(err)
		}
		err = msgpack2.Unmarshal(b, out, nil)
		if err != nil {
			panic(err)
		}
	}
}
*/

func (t *MsgpackTest) BenchmarkStructMsgpack3(c *C) {
	in := t.structForBenchmark()
	out := &benchmarkStruct{}
	for i := 0; i < c.N; i++ {
		buf := &bytes.Buffer{}
		enc := codec.NewEncoder(buf, &codec.MsgpackHandle{})
		dec := codec.NewDecoder(buf, &codec.MsgpackHandle{})

		if err := enc.Encode(in); err != nil {
			panic(err)
		}
		if err := dec.Decode(out); err != nil {
			panic(err)
		}
	}
}

func (t *MsgpackTest) BenchmarkStructJSON(c *C) {
	in := t.structForBenchmark()
	out := &benchmarkStruct{}
	for i := 0; i < c.N; i++ {
		b, err := json.Marshal(in)
		if err != nil {
			panic(err)
		}
		err = json.Unmarshal(b, out)
		if err != nil {
			panic(err)
		}
	}
}

func (t *MsgpackTest) BenchmarkStructGOB(c *C) {
	in := t.structForBenchmark()
	out := &benchmarkStruct{}
	for i := 0; i < c.N; i++ {
		buf := &bytes.Buffer{}
		enc := gob.NewEncoder(buf)
		dec := gob.NewDecoder(buf)

		if err := enc.Encode(in); err != nil {
			panic(err)
		}
		if err := dec.Decode(out); err != nil {
			panic(err)
		}
	}
}

func (t *MsgpackTest) BenchmarkCSV(c *C) {
	for i := 0; i < c.N; i++ {
		record := []string{strconv.FormatInt(int64(1), 10), "hello", "world"}

		buf := &bytes.Buffer{}
		r := csv.NewReader(buf)
		w := csv.NewWriter(buf)

		if err := w.Write(record); err != nil {
			panic(err)
		}
		w.Flush()
		if _, err := r.Read(); err != nil {
			panic(err)
		}
	}
}

func (t *MsgpackTest) BenchmarkCSVMsgpack(c *C) {
	for i := 0; i < c.N; i++ {
		var num int
		var hello, world string

		buf := &bytes.Buffer{}
		enc := msgpack.NewEncoder(buf)
		dec := msgpack.NewDecoder(buf)

		if err := enc.Encode(1, "hello", "world"); err != nil {
			panic(err)
		}
		if err := dec.Decode(&num, &hello, &world); err != nil {
			panic(err)
		}
	}
}