Grand test fixup (#138)

* start fixing up tests

* fix up tests + automate with drone

* fiddle with linting

* messing about with drone.yml

* some more fiddling

* hmmm

* add cache

* add vendor directory

* verbose

* ci updates

* update some little things

* update sig

vendor/github.com/vmihailenco/msgpack/v5/intern.go

@@ -0,0 +1,238 @@
+package msgpack
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+
+	"github.com/vmihailenco/msgpack/v5/msgpcode"
+)
+
+const (
+	minInternedStringLen = 3
+	maxDictLen           = math.MaxUint16
+)
+
+var internedStringExtID = int8(math.MinInt8)
+
+func init() {
+	extTypes[internedStringExtID] = &extInfo{
+		Type:    stringType,
+		Decoder: decodeInternedStringExt,
+	}
+}
+
+func decodeInternedStringExt(d *Decoder, v reflect.Value, extLen int) error {
+	idx, err := d.decodeInternedStringIndex(extLen)
+	if err != nil {
+		return err
+	}
+
+	s, err := d.internedStringAtIndex(idx)
+	if err != nil {
+		return err
+	}
+
+	v.SetString(s)
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+func encodeInternedInterfaceValue(e *Encoder, v reflect.Value) error {
+	if v.IsNil() {
+		return e.EncodeNil()
+	}
+
+	v = v.Elem()
+	if v.Kind() == reflect.String {
+		return e.encodeInternedString(v.String(), true)
+	}
+	return e.EncodeValue(v)
+}
+
+func encodeInternedStringValue(e *Encoder, v reflect.Value) error {
+	return e.encodeInternedString(v.String(), true)
+}
+
+func (e *Encoder) encodeInternedString(s string, intern bool) error {
+	// Interned string takes at least 3 bytes. Plain string 1 byte + string len.
+	if len(s) >= minInternedStringLen {
+		if idx, ok := e.dict[s]; ok {
+			return e.encodeInternedStringIndex(idx)
+		}
+
+		if intern && len(e.dict) < maxDictLen {
+			if e.dict == nil {
+				e.dict = make(map[string]int)
+			}
+			idx := len(e.dict)
+			e.dict[s] = idx
+		}
+	}
+
+	return e.encodeNormalString(s)
+}
+
+func (e *Encoder) encodeInternedStringIndex(idx int) error {
+	if idx <= math.MaxUint8 {
+		if err := e.writeCode(msgpcode.FixExt1); err != nil {
+			return err
+		}
+		return e.write1(byte(internedStringExtID), uint8(idx))
+	}
+
+	if idx <= math.MaxUint16 {
+		if err := e.writeCode(msgpcode.FixExt2); err != nil {
+			return err
+		}
+		return e.write2(byte(internedStringExtID), uint16(idx))
+	}
+
+	if uint64(idx) <= math.MaxUint32 {
+		if err := e.writeCode(msgpcode.FixExt4); err != nil {
+			return err
+		}
+		return e.write4(byte(internedStringExtID), uint32(idx))
+	}
+
+	return fmt.Errorf("msgpack: interned string index=%d is too large", idx)
+}
+
+//------------------------------------------------------------------------------
+
+func decodeInternedInterfaceValue(d *Decoder, v reflect.Value) error {
+	s, err := d.decodeInternedString(true)
+	if err == nil {
+		v.Set(reflect.ValueOf(s))
+		return nil
+	}
+	if err != nil {
+		if _, ok := err.(unexpectedCodeError); !ok {
+			return err
+		}
+	}
+
+	if err := d.s.UnreadByte(); err != nil {
+		return err
+	}
+	return decodeInterfaceValue(d, v)
+}
+
+func decodeInternedStringValue(d *Decoder, v reflect.Value) error {
+	s, err := d.decodeInternedString(true)
+	if err != nil {
+		return err
+	}
+
+	v.SetString(s)
+	return nil
+}
+
+func (d *Decoder) decodeInternedString(intern bool) (string, error) {
+	c, err := d.readCode()
+	if err != nil {
+		return "", err
+	}
+
+	if msgpcode.IsFixedString(c) {
+		n := int(c & msgpcode.FixedStrMask)
+		return d.decodeInternedStringWithLen(n, intern)
+	}
+
+	switch c {
+	case msgpcode.Nil:
+		return "", nil
+	case msgpcode.FixExt1, msgpcode.FixExt2, msgpcode.FixExt4:
+		typeID, extLen, err := d.extHeader(c)
+		if err != nil {
+			return "", err
+		}
+		if typeID != internedStringExtID {
+			err := fmt.Errorf("msgpack: got ext type=%d, wanted %d",
+				typeID, internedStringExtID)
+			return "", err
+		}
+
+		idx, err := d.decodeInternedStringIndex(extLen)
+		if err != nil {
+			return "", err
+		}
+
+		return d.internedStringAtIndex(idx)
+	case msgpcode.Str8, msgpcode.Bin8:
+		n, err := d.uint8()
+		if err != nil {
+			return "", err
+		}
+		return d.decodeInternedStringWithLen(int(n), intern)
+	case msgpcode.Str16, msgpcode.Bin16:
+		n, err := d.uint16()
+		if err != nil {
+			return "", err
+		}
+		return d.decodeInternedStringWithLen(int(n), intern)
+	case msgpcode.Str32, msgpcode.Bin32:
+		n, err := d.uint32()
+		if err != nil {
+			return "", err
+		}
+		return d.decodeInternedStringWithLen(int(n), intern)
+	}
+
+	return "", unexpectedCodeError{
+		code: c,
+		hint: "interned string",
+	}
+}
+
+func (d *Decoder) decodeInternedStringIndex(extLen int) (int, error) {
+	switch extLen {
+	case 1:
+		n, err := d.uint8()
+		if err != nil {
+			return 0, err
+		}
+		return int(n), nil
+	case 2:
+		n, err := d.uint16()
+		if err != nil {
+			return 0, err
+		}
+		return int(n), nil
+	case 4:
+		n, err := d.uint32()
+		if err != nil {
+			return 0, err
+		}
+		return int(n), nil
+	}
+
+	err := fmt.Errorf("msgpack: unsupported ext len=%d decoding interned string", extLen)
+	return 0, err
+}
+
+func (d *Decoder) internedStringAtIndex(idx int) (string, error) {
+	if idx >= len(d.dict) {
+		err := fmt.Errorf("msgpack: interned string at index=%d does not exist", idx)
+		return "", err
+	}
+	return d.dict[idx], nil
+}
+
+func (d *Decoder) decodeInternedStringWithLen(n int, intern bool) (string, error) {
+	if n <= 0 {
+		return "", nil
+	}
+
+	s, err := d.stringWithLen(n)
+	if err != nil {
+		return "", err
+	}
+
+	if intern && len(s) >= minInternedStringLen && len(d.dict) < maxDictLen {
+		d.dict = append(d.dict, s)
+	}
+
+	return s, nil
+}