msgpack-go

Message Pack Encoder/Decoder for Golang
git clone git://git.lair.cx/msgpack-go
Log | Files | Refs | LICENSE

decode_test.go (3785B)

      1 package msgpack
      2 
      3 import (
      4 	"bytes"
      5 	"fmt"
      6 	"io"
      7 	"reflect"
      8 	"testing"
      9 	"time"
     10 )
     11 
     12 func TestRead(t *testing.T) {
     13 	var in = bytes.Repeat([]byte{'_'}, 256)
     14 
     15 	testfn := func(useReader bool) func(t *testing.T) {
     16 		var d *Decoder
     17 		if useReader {
     18 			d = NewDecoder(bytes.NewReader(in), make([]byte, 0, 128))
     19 		} else {
     20 			d = NewDecoder(nil, in)
     21 		}
     22 
     23 		return func(t *testing.T) {
     24 			// up to 16 bytes (total 136 bytes)
     25 			for i := 1; i <= 16; i++ {
     26 				buf := make([]byte, i)
     27 				n, err := d.read(buf)
     28 				if err != nil {
     29 					t.Errorf("d.read(%d bytes buffer) returns an error: %s", i, err.Error())
     30 					return
     31 				}
     32 				if n != i || !bytes.Equal(buf, bytes.Repeat([]byte{'_'}, i)) {
     33 					t.Errorf("d.read() returns %v, want: %v", buf, bytes.Repeat([]byte{'_'}, i))
     34 					return
     35 				}
     36 			}
     37 
     38 			// big buffer
     39 			buf := make([]byte, 256)
     40 			n, err := d.read(buf)
     41 			if err != nil {
     42 				t.Errorf("d.read() returns an error: %s", err.Error())
     43 				return
     44 			}
     45 			if n != 120 || !bytes.Equal(buf[:120], bytes.Repeat([]byte{'_'}, 120)) {
     46 				t.Errorf("d.read() returns %d, %v, want: %d, %v", n, buf, 120, bytes.Repeat([]byte{'_'}, 120))
     47 				return
     48 			}
     49 
     50 			_, err = d.read(buf)
     51 			if err != io.EOF {
     52 				t.Errorf("d.read() returns an error: %s, want: io.Nil", err.Error())
     53 				return
     54 			}
     55 		}
     56 	}
     57 
     58 	t.Run("buffer-only", testfn(false))
     59 	t.Run("with-reader", testfn(true))
     60 }
     61 
     62 func TestDecodeNil(t *testing.T) {
     63 	d := NewDecoder(nil, []byte{0xc0, '_'})
     64 
     65 	isNil, err := d.NextIsNil()
     66 	if err != nil {
     67 		t.Errorf("d.NextIsNil() returns an error: %s", err.Error())
     68 		return
     69 	}
     70 	if !isNil {
     71 		t.Errorf("d.NextIsNil() returns false, want: true")
     72 		return
     73 	}
     74 
     75 	if err := d.Nil(); err != nil {
     76 		t.Errorf("d.Nil() returns error: %s", err.Error())
     77 	}
     78 
     79 	var p = make([]byte, 1)
     80 	if err := d.Raw(p); err != nil {
     81 		t.Errorf("d.Raw() returns error: %s", err.Error())
     82 	}
     83 	if !bytes.Equal(p, []byte{'_'}) {
     84 		t.Errorf("d.Nil() does not skip nil byte")
     85 	}
     86 }
     87 
     88 func TestDecode(t *testing.T) {
     89 	d := NewDecoder(nil, []byte{' '})
     90 
     91 	for _, test := range testCases {
     92 		d.Reset(nil, test.encoded)
     93 
     94 		var err error
     95 		var got interface{}
     96 		switch test.decoded.(type) {
     97 		case bool:
     98 			var v bool
     99 			err = d.Bool(&v)
    100 			got = v
    101 		case int:
    102 			var v int
    103 			err = d.Int(&v)
    104 			got = v
    105 		case int8:
    106 			var v int8
    107 			err = d.Int8(&v)
    108 			got = v
    109 		case int16:
    110 			var v int16
    111 			err = d.Int16(&v)
    112 			got = v
    113 		case int32:
    114 			var v int32
    115 			err = d.Int32(&v)
    116 			got = v
    117 		case int64:
    118 			var v int64
    119 			err = d.Int64(&v)
    120 			got = v
    121 		case uint:
    122 			var v uint
    123 			err = d.Uint(&v)
    124 			got = v
    125 		case uint8:
    126 			var v uint8
    127 			err = d.Uint8(&v)
    128 			got = v
    129 		case uint16:
    130 			var v uint16
    131 			err = d.Uint16(&v)
    132 			got = v
    133 		case uint32:
    134 			var v uint32
    135 			err = d.Uint32(&v)
    136 			got = v
    137 		case uint64:
    138 			var v uint64
    139 			err = d.Uint64(&v)
    140 			got = v
    141 		case float32:
    142 			var v float32
    143 			err = d.Float32(&v)
    144 			got = v
    145 		case float64:
    146 			var v float64
    147 			err = d.Float64(&v)
    148 			got = v
    149 		case string:
    150 			var v string
    151 			err = d.String(&v)
    152 			got = v
    153 		case []byte:
    154 			var v []byte
    155 			err = d.Binary(&v)
    156 			got = v
    157 		case Array:
    158 			var v testArray
    159 			err = d.Array(&v)
    160 			got = &v
    161 		case Map:
    162 			var v testMap
    163 			err = d.Map(&v)
    164 			got = &v
    165 		case Extension:
    166 			var v testExt
    167 			err = d.Ext(&v)
    168 			got = &v
    169 		case time.Time:
    170 			var v Timestamp
    171 			err = d.Ext(&v)
    172 			got = (&v).Time()
    173 		default:
    174 			panic(fmt.Sprintf("invalid test input type: %s", reflect.TypeOf(test.decoded).Name()))
    175 		}
    176 
    177 		if err != nil {
    178 			t.Errorf("d.%s(%v) returns error: %s", reflect.TypeOf(test.decoded).Name(), test.encoded, err.Error())
    179 			t.FailNow()
    180 		}
    181 
    182 		if !reflect.DeepEqual(got, test.decoded) {
    183 			fmt.Println(test, got)
    184 			t.Errorf("d.%s(%v) returns %v, want: %v", reflect.TypeOf(test.decoded).Name(), test.encoded, got, test.decoded)
    185 			t.FailNow()
    186 		}
    187 	}
    188 }