added vendors

vendor/github.com/json-iterator/go/extra/binary_as_string_codec.go

@@ -0,0 +1,238 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/modern-go/reflect2"
+	"unicode/utf8"
+	"unsafe"
+)
+
+// safeSet holds the value true if the ASCII character with the given array
+// position can be represented inside a JSON string without any further
+// escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), and the backslash character ("\").
+var safeSet = [utf8.RuneSelf]bool{
+	' ':      true,
+	'!':      true,
+	'"':      false,
+	'#':      true,
+	'$':      true,
+	'%':      true,
+	'&':      true,
+	'\'':     true,
+	'(':      true,
+	')':      true,
+	'*':      true,
+	'+':      true,
+	',':      true,
+	'-':      true,
+	'.':      true,
+	'/':      true,
+	'0':      true,
+	'1':      true,
+	'2':      true,
+	'3':      true,
+	'4':      true,
+	'5':      true,
+	'6':      true,
+	'7':      true,
+	'8':      true,
+	'9':      true,
+	':':      true,
+	';':      true,
+	'<':      true,
+	'=':      true,
+	'>':      true,
+	'?':      true,
+	'@':      true,
+	'A':      true,
+	'B':      true,
+	'C':      true,
+	'D':      true,
+	'E':      true,
+	'F':      true,
+	'G':      true,
+	'H':      true,
+	'I':      true,
+	'J':      true,
+	'K':      true,
+	'L':      true,
+	'M':      true,
+	'N':      true,
+	'O':      true,
+	'P':      true,
+	'Q':      true,
+	'R':      true,
+	'S':      true,
+	'T':      true,
+	'U':      true,
+	'V':      true,
+	'W':      true,
+	'X':      true,
+	'Y':      true,
+	'Z':      true,
+	'[':      true,
+	'\\':     false,
+	']':      true,
+	'^':      true,
+	'_':      true,
+	'`':      true,
+	'a':      true,
+	'b':      true,
+	'c':      true,
+	'd':      true,
+	'e':      true,
+	'f':      true,
+	'g':      true,
+	'h':      true,
+	'i':      true,
+	'j':      true,
+	'k':      true,
+	'l':      true,
+	'm':      true,
+	'n':      true,
+	'o':      true,
+	'p':      true,
+	'q':      true,
+	'r':      true,
+	's':      true,
+	't':      true,
+	'u':      true,
+	'v':      true,
+	'w':      true,
+	'x':      true,
+	'y':      true,
+	'z':      true,
+	'{':      true,
+	'|':      true,
+	'}':      true,
+	'~':      true,
+	'\u007f': true,
+}
+
+var binaryType = reflect2.TypeOfPtr((*[]byte)(nil)).Elem()
+
+type BinaryAsStringExtension struct {
+	jsoniter.DummyExtension
+}
+
+func (extension *BinaryAsStringExtension) CreateEncoder(typ reflect2.Type) jsoniter.ValEncoder {
+	if typ == binaryType {
+		return &binaryAsStringCodec{}
+	}
+	return nil
+}
+
+func (extension *BinaryAsStringExtension) CreateDecoder(typ reflect2.Type) jsoniter.ValDecoder {
+	if typ == binaryType {
+		return &binaryAsStringCodec{}
+	}
+	return nil
+}
+
+type binaryAsStringCodec struct {
+}
+
+func (codec *binaryAsStringCodec) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	rawBytes := iter.ReadStringAsSlice()
+	bytes := make([]byte, 0, len(rawBytes))
+	for i := 0; i < len(rawBytes); i++ {
+		b := rawBytes[i]
+		if b == '\\' {
+			b2 := rawBytes[i+1]
+			if b2 != '\\' {
+				iter.ReportError("decode binary as string", `\\x is only supported escape`)
+				return
+			}
+			b3 := rawBytes[i+2]
+			if b3 != 'x' {
+				iter.ReportError("decode binary as string", `\\x is only supported escape`)
+				return
+			}
+			b4 := rawBytes[i+3]
+			b5 := rawBytes[i+4]
+			i = i + 4
+			b = readHex(iter, b4, b5)
+		}
+		bytes = append(bytes, b)
+	}
+	*(*[]byte)(ptr) = bytes
+}
+func (codec *binaryAsStringCodec) IsEmpty(ptr unsafe.Pointer) bool {
+	return len(*((*[]byte)(ptr))) == 0
+}
+func (codec *binaryAsStringCodec) Encode(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+	newBuffer := writeBytes(stream.Buffer(), *(*[]byte)(ptr))
+	stream.SetBuffer(newBuffer)
+}
+
+func readHex(iter *jsoniter.Iterator, b1, b2 byte) byte {
+	var ret byte
+	if b1 >= '0' && b1 <= '9' {
+		ret = b1 - '0'
+	} else if b1 >= 'a' && b1 <= 'f' {
+		ret = b1 - 'a' + 10
+	} else {
+		iter.ReportError("read hex", "expects 0~9 or a~f, but found "+string([]byte{b1}))
+		return 0
+	}
+	ret = ret * 16
+	if b2 >= '0' && b2 <= '9' {
+		ret = b2 - '0'
+	} else if b2 >= 'a' && b2 <= 'f' {
+		ret = b2 - 'a' + 10
+	} else {
+		iter.ReportError("read hex", "expects 0~9 or a~f, but found "+string([]byte{b2}))
+		return 0
+	}
+	return ret
+}
+
+var hex = "0123456789abcdef"
+
+func writeBytes(space []byte, s []byte) []byte {
+	space = append(space, '"')
+	// write string, the fast path, without utf8 and escape support
+	var i int
+	var c byte
+	for i, c = range s {
+		if c < utf8.RuneSelf && safeSet[c] {
+			space = append(space, c)
+		} else {
+			break
+		}
+	}
+	if i == len(s)-1 {
+		space = append(space, '"')
+		return space
+	}
+	return writeBytesSlowPath(space, s[i:])
+}
+
+func writeBytesSlowPath(space []byte, s []byte) []byte {
+	start := 0
+	// for the remaining parts, we process them char by char
+	var i int
+	var b byte
+	for i, b = range s {
+		if b >= utf8.RuneSelf {
+			space = append(space, '\\', '\\', 'x', hex[b>>4], hex[b&0xF])
+			start = i + 1
+			continue
+		}
+		if safeSet[b] {
+			continue
+		}
+		if start < i {
+			space = append(space, s[start:i]...)
+		}
+		space = append(space, '\\', '\\', 'x', hex[b>>4], hex[b&0xF])
+		start = i + 1
+	}
+	if start < len(s) {
+		space = append(space, s[start:]...)
+	}
+	return append(space, '"')
+}

vendor/github.com/json-iterator/go/extra/binary_as_string_codec_test.go

@@ -0,0 +1,32 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func init() {
+	jsoniter.RegisterExtension(&BinaryAsStringExtension{})
+}
+
+func TestBinaryAsStringCodec(t *testing.T) {
+	t.Run("safe set", func(t *testing.T) {
+		should := require.New(t)
+		output, err := jsoniter.Marshal([]byte("hello"))
+		should.NoError(err)
+		should.Equal(`"hello"`, string(output))
+		var val []byte
+		should.NoError(jsoniter.Unmarshal(output, &val))
+		should.Equal(`hello`, string(val))
+	})
+	t.Run("non safe set", func(t *testing.T) {
+		should := require.New(t)
+		output, err := jsoniter.Marshal([]byte{1, 2, 3, 15})
+		should.NoError(err)
+		should.Equal(`"\\x01\\x02\\x03\\x0f"`, string(output))
+		var val []byte
+		should.NoError(jsoniter.Unmarshal(output, &val))
+		should.Equal([]byte{1, 2, 3, 15}, val)
+	})
+}

vendor/github.com/json-iterator/go/extra/fuzzy_decoder.go

@@ -0,0 +1,294 @@
+package extra
+
+import (
+	"encoding/json"
+	"io"
+	"math"
+	"reflect"
+	"strings"
+	"unsafe"
+
+	"github.com/json-iterator/go"
+	"github.com/modern-go/reflect2"
+)
+
+const maxUint = ^uint(0)
+const maxInt = int(maxUint >> 1)
+const minInt = -maxInt - 1
+
+// RegisterFuzzyDecoders decode input from PHP with tolerance.
+// It will handle string/number auto conversation, and treat empty [] as empty struct.
+func RegisterFuzzyDecoders() {
+	jsoniter.RegisterExtension(&tolerateEmptyArrayExtension{})
+	jsoniter.RegisterTypeDecoder("string", &fuzzyStringDecoder{})
+	jsoniter.RegisterTypeDecoder("float32", &fuzzyFloat32Decoder{})
+	jsoniter.RegisterTypeDecoder("float64", &fuzzyFloat64Decoder{})
+	jsoniter.RegisterTypeDecoder("int", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(maxInt) || val < float64(minInt) {
+				iter.ReportError("fuzzy decode int", "exceed range")
+				return
+			}
+			*((*int)(ptr)) = int(val)
+		} else {
+			*((*int)(ptr)) = iter.ReadInt()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("uint", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(maxUint) || val < 0 {
+				iter.ReportError("fuzzy decode uint", "exceed range")
+				return
+			}
+			*((*uint)(ptr)) = uint(val)
+		} else {
+			*((*uint)(ptr)) = iter.ReadUint()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("int8", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxInt8) || val < float64(math.MinInt8) {
+				iter.ReportError("fuzzy decode int8", "exceed range")
+				return
+			}
+			*((*int8)(ptr)) = int8(val)
+		} else {
+			*((*int8)(ptr)) = iter.ReadInt8()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("uint8", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxUint8) || val < 0 {
+				iter.ReportError("fuzzy decode uint8", "exceed range")
+				return
+			}
+			*((*uint8)(ptr)) = uint8(val)
+		} else {
+			*((*uint8)(ptr)) = iter.ReadUint8()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("int16", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxInt16) || val < float64(math.MinInt16) {
+				iter.ReportError("fuzzy decode int16", "exceed range")
+				return
+			}
+			*((*int16)(ptr)) = int16(val)
+		} else {
+			*((*int16)(ptr)) = iter.ReadInt16()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("uint16", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxUint16) || val < 0 {
+				iter.ReportError("fuzzy decode uint16", "exceed range")
+				return
+			}
+			*((*uint16)(ptr)) = uint16(val)
+		} else {
+			*((*uint16)(ptr)) = iter.ReadUint16()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("int32", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxInt32) || val < float64(math.MinInt32) {
+				iter.ReportError("fuzzy decode int32", "exceed range")
+				return
+			}
+			*((*int32)(ptr)) = int32(val)
+		} else {
+			*((*int32)(ptr)) = iter.ReadInt32()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("uint32", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxUint32) || val < 0 {
+				iter.ReportError("fuzzy decode uint32", "exceed range")
+				return
+			}
+			*((*uint32)(ptr)) = uint32(val)
+		} else {
+			*((*uint32)(ptr)) = iter.ReadUint32()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("int64", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxInt64) || val < float64(math.MinInt64) {
+				iter.ReportError("fuzzy decode int64", "exceed range")
+				return
+			}
+			*((*int64)(ptr)) = int64(val)
+		} else {
+			*((*int64)(ptr)) = iter.ReadInt64()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("uint64", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxUint64) || val < 0 {
+				iter.ReportError("fuzzy decode uint64", "exceed range")
+				return
+			}
+			*((*uint64)(ptr)) = uint64(val)
+		} else {
+			*((*uint64)(ptr)) = iter.ReadUint64()
+		}
+	}})
+}
+
+type tolerateEmptyArrayExtension struct {
+	jsoniter.DummyExtension
+}
+
+func (extension *tolerateEmptyArrayExtension) DecorateDecoder(typ reflect2.Type, decoder jsoniter.ValDecoder) jsoniter.ValDecoder {
+	if typ.Kind() == reflect.Struct || typ.Kind() == reflect.Map {
+		return &tolerateEmptyArrayDecoder{decoder}
+	}
+	return decoder
+}
+
+type tolerateEmptyArrayDecoder struct {
+	valDecoder jsoniter.ValDecoder
+}
+
+func (decoder *tolerateEmptyArrayDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	if iter.WhatIsNext() == jsoniter.ArrayValue {
+		iter.Skip()
+		newIter := iter.Pool().BorrowIterator([]byte("{}"))
+		defer iter.Pool().ReturnIterator(newIter)
+		decoder.valDecoder.Decode(ptr, newIter)
+	} else {
+		decoder.valDecoder.Decode(ptr, iter)
+	}
+}
+
+type fuzzyStringDecoder struct {
+}
+
+func (decoder *fuzzyStringDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	valueType := iter.WhatIsNext()
+	switch valueType {
+	case jsoniter.NumberValue:
+		var number json.Number
+		iter.ReadVal(&number)
+		*((*string)(ptr)) = string(number)
+	case jsoniter.StringValue:
+		*((*string)(ptr)) = iter.ReadString()
+	case jsoniter.NilValue:
+		iter.Skip()
+		*((*string)(ptr)) = ""
+	default:
+		iter.ReportError("fuzzyStringDecoder", "not number or string")
+	}
+}
+
+type fuzzyIntegerDecoder struct {
+	fun func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator)
+}
+
+func (decoder *fuzzyIntegerDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	valueType := iter.WhatIsNext()
+	var str string
+	switch valueType {
+	case jsoniter.NumberValue:
+		var number json.Number
+		iter.ReadVal(&number)
+		str = string(number)
+	case jsoniter.StringValue:
+		str = iter.ReadString()
+	case jsoniter.BoolValue:
+		if iter.ReadBool() {
+			str = "1"
+		} else {
+			str = "0"
+		}
+	case jsoniter.NilValue:
+		iter.Skip()
+		str = "0"
+	default:
+		iter.ReportError("fuzzyIntegerDecoder", "not number or string")
+	}
+	if len(str) == 0 {
+		str = "0"
+	}
+	newIter := iter.Pool().BorrowIterator([]byte(str))
+	defer iter.Pool().ReturnIterator(newIter)
+	isFloat := strings.IndexByte(str, '.') != -1
+	decoder.fun(isFloat, ptr, newIter)
+	if newIter.Error != nil && newIter.Error != io.EOF {
+		iter.Error = newIter.Error
+	}
+}
+
+type fuzzyFloat32Decoder struct {
+}
+
+func (decoder *fuzzyFloat32Decoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	valueType := iter.WhatIsNext()
+	var str string
+	switch valueType {
+	case jsoniter.NumberValue:
+		*((*float32)(ptr)) = iter.ReadFloat32()
+	case jsoniter.StringValue:
+		str = iter.ReadString()
+		newIter := iter.Pool().BorrowIterator([]byte(str))
+		defer iter.Pool().ReturnIterator(newIter)
+		*((*float32)(ptr)) = newIter.ReadFloat32()
+		if newIter.Error != nil && newIter.Error != io.EOF {
+			iter.Error = newIter.Error
+		}
+	case jsoniter.BoolValue:
+		// support bool to float32
+		if iter.ReadBool() {
+			*((*float32)(ptr)) = 1
+		} else {
+			*((*float32)(ptr)) = 0
+		}
+	case jsoniter.NilValue:
+		iter.Skip()
+		*((*float32)(ptr)) = 0
+	default:
+		iter.ReportError("fuzzyFloat32Decoder", "not number or string")
+	}
+}
+
+type fuzzyFloat64Decoder struct {
+}
+
+func (decoder *fuzzyFloat64Decoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	valueType := iter.WhatIsNext()
+	var str string
+	switch valueType {
+	case jsoniter.NumberValue:
+		*((*float64)(ptr)) = iter.ReadFloat64()
+	case jsoniter.StringValue:
+		str = iter.ReadString()
+		newIter := iter.Pool().BorrowIterator([]byte(str))
+		defer iter.Pool().ReturnIterator(newIter)
+		*((*float64)(ptr)) = newIter.ReadFloat64()
+		if newIter.Error != nil && newIter.Error != io.EOF {
+			iter.Error = newIter.Error
+		}
+	case jsoniter.BoolValue:
+		// support bool to float64
+		if iter.ReadBool() {
+			*((*float64)(ptr)) = 1
+		} else {
+			*((*float64)(ptr)) = 0
+		}
+	case jsoniter.NilValue:
+		iter.Skip()
+		*((*float64)(ptr)) = 0
+	default:
+		iter.ReportError("fuzzyFloat64Decoder", "not number or string")
+	}
+}

vendor/github.com/json-iterator/go/extra/fuzzy_decoder_test.go

@@ -0,0 +1,393 @@
+package extra
+
+import (
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func init() {
+	RegisterFuzzyDecoders()
+}
+
+func Test_any_to_string(t *testing.T) {
+	should := require.New(t)
+	var val string
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal("100", val)
+	should.Nil(jsoniter.UnmarshalFromString("10", &val))
+	should.Equal("10", val)
+	should.Nil(jsoniter.UnmarshalFromString("10.1", &val))
+	should.Equal("10.1", val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal("10.1", val)
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+}
+func Test_any_to_int64(t *testing.T) {
+	should := require.New(t)
+	var val int64
+
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(int64(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(int64(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(int64(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(int64(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`""`, &val))
+	should.Equal(int64(0), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(int64(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(int64(1), val)
+
+	should.Nil(jsoniter.UnmarshalFromString(`-10`, &val))
+	should.Equal(int64(-10), val)
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_int(t *testing.T) {
+	should := require.New(t)
+	var val int
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(100, val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(10, val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(10, val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(10, val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(0, val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(1, val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_int16(t *testing.T) {
+	should := require.New(t)
+	var val int16
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(int16(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(int16(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(int16(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(int16(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(int16(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(int16(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_int32(t *testing.T) {
+	should := require.New(t)
+	var val int32
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(int32(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(int32(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(int32(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(int32(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(int32(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(int32(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_int8(t *testing.T) {
+	should := require.New(t)
+	var val int8
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(int8(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(int8(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(int8(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(int8(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(int8(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(int8(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_uint8(t *testing.T) {
+	should := require.New(t)
+	var val uint8
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(uint8(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(uint8(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(uint8(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(uint8(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(uint8(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(uint8(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_uint64(t *testing.T) {
+	should := require.New(t)
+	var val uint64
+
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(uint64(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(uint64(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(uint64(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(uint64(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(uint64(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(uint64(1), val)
+
+	// TODO fix?
+	should.NotNil(jsoniter.UnmarshalFromString(`-10`, &val))
+	should.Equal(uint64(0), val)
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+func Test_any_to_uint32(t *testing.T) {
+	should := require.New(t)
+	var val uint32
+
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(uint32(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(uint32(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(uint32(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(uint32(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(uint32(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(uint32(1), val)
+
+	// TODO fix?
+	should.NotNil(jsoniter.UnmarshalFromString(`-10`, &val))
+	should.Equal(uint32(0), val)
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+func Test_any_to_uint16(t *testing.T) {
+	should := require.New(t)
+	var val uint16
+
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(uint16(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(uint16(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(uint16(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(uint16(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(uint16(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(uint16(1), val)
+
+	// TODO fix?
+	should.NotNil(jsoniter.UnmarshalFromString(`-10`, &val))
+	should.Equal(uint16(0), val)
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+func Test_any_to_uint(t *testing.T) {
+	should := require.New(t)
+	var val uint
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(uint(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(uint(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(uint(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(uint(10), val)
+
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(uint(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(uint(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_float32(t *testing.T) {
+	should := require.New(t)
+	var val float32
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(float32(100), val)
+
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(float32(10.1), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(float32(10.1), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(float32(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(float32(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(float32(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+}
+
+func Test_any_to_float64(t *testing.T) {
+	should := require.New(t)
+	var val float64
+
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(float64(100), val)
+
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(float64(10.1), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(float64(10.1), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(float64(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(float64(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(float64(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+}
+
+func Test_empty_array_as_map(t *testing.T) {
+	should := require.New(t)
+	var val map[string]interface{}
+	should.Nil(jsoniter.UnmarshalFromString(`[]`, &val))
+	should.Equal(map[string]interface{}{}, val)
+}
+
+func Test_empty_array_as_object(t *testing.T) {
+	should := require.New(t)
+	var val struct{}
+	should.Nil(jsoniter.UnmarshalFromString(`[]`, &val))
+	should.Equal(struct{}{}, val)
+}
+
+func Test_bad_case(t *testing.T) {
+	var jsonstr = `
+{
+    "extra_type": 181760,
+    "combo_type": 0,
+    "trigger_time_ms": 1498800398000,
+    "_create_time": "2017-06-16 11:21:39",
+    "_msg_type": 41000
+}
+`
+
+	type OrderEventRequestParams struct {
+		ExtraType uint64 `json:"extra_type"`
+	}
+
+	var a OrderEventRequestParams
+	err := jsoniter.UnmarshalFromString(jsonstr, &a)
+	should := require.New(t)
+	should.Nil(err)
+}
+
+func Test_null_to_string(t *testing.T) {
+	should := require.New(t)
+	body := []byte(`null`)
+	var message string
+	err := jsoniter.Unmarshal(body, &message)
+	should.NoError(err)
+}
+
+func Test_null_to_int(t *testing.T) {
+	should := require.New(t)
+	body := []byte(`null`)
+	var message int
+	err := jsoniter.Unmarshal(body, &message)
+	should.NoError(err)
+}
+
+func Test_null_to_float32(t *testing.T) {
+	should := require.New(t)
+	body := []byte(`null`)
+	var message float32
+	err := jsoniter.Unmarshal(body, &message)
+	should.NoError(err)
+}
+
+func Test_null_to_float64(t *testing.T) {
+	should := require.New(t)
+	body := []byte(`null`)
+	var message float64
+	err := jsoniter.Unmarshal(body, &message)
+	should.NoError(err)
+}

vendor/github.com/json-iterator/go/extra/naming_strategy.go

@@ -0,0 +1,52 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"strings"
+	"unicode"
+)
+
+// SetNamingStrategy rename struct fields uniformly
+func SetNamingStrategy(translate func(string) string) {
+	jsoniter.RegisterExtension(&namingStrategyExtension{jsoniter.DummyExtension{}, translate})
+}
+
+type namingStrategyExtension struct {
+	jsoniter.DummyExtension
+	translate func(string) string
+}
+
+func (extension *namingStrategyExtension) UpdateStructDescriptor(structDescriptor *jsoniter.StructDescriptor) {
+	for _, binding := range structDescriptor.Fields {
+		tag, hastag := binding.Field.Tag().Lookup("json")
+		if hastag {
+			tagParts := strings.Split(tag, ",")
+			if tagParts[0] == "-" {
+				continue // hidden field
+			}
+			if tagParts[0] != "" {
+				continue // field explicitly named
+			}
+		}
+		binding.ToNames = []string{extension.translate(binding.Field.Name())}
+		binding.FromNames = []string{extension.translate(binding.Field.Name())}
+	}
+}
+
+// LowerCaseWithUnderscores one strategy to SetNamingStrategy for. It will change HelloWorld to hello_world.
+func LowerCaseWithUnderscores(name string) string {
+	newName := []rune{}
+	for i, c := range name {
+		if i == 0 {
+			newName = append(newName, unicode.ToLower(c))
+		} else {
+			if unicode.IsUpper(c) {
+				newName = append(newName, '_')
+				newName = append(newName, unicode.ToLower(c))
+			} else {
+				newName = append(newName, c)
+			}
+		}
+	}
+	return string(newName)
+}

vendor/github.com/json-iterator/go/extra/naming_strategy_test.go

@@ -0,0 +1,50 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func Test_lower_case_with_underscores(t *testing.T) {
+	should := require.New(t)
+	should.Equal("hello_world", LowerCaseWithUnderscores("helloWorld"))
+	should.Equal("hello_world", LowerCaseWithUnderscores("HelloWorld"))
+	SetNamingStrategy(LowerCaseWithUnderscores)
+	output, err := jsoniter.Marshal(struct {
+		UserName      string
+		FirstLanguage string
+	}{
+		UserName:      "taowen",
+		FirstLanguage: "Chinese",
+	})
+	should.Nil(err)
+	should.Equal(`{"user_name":"taowen","first_language":"Chinese"}`, string(output))
+}
+
+func Test_set_naming_strategy_with_overrides(t *testing.T) {
+	should := require.New(t)
+	SetNamingStrategy(LowerCaseWithUnderscores)
+	output, err := jsoniter.Marshal(struct {
+		UserName      string `json:"UserName"`
+		FirstLanguage string
+	}{
+		UserName:      "taowen",
+		FirstLanguage: "Chinese",
+	})
+	should.Nil(err)
+	should.Equal(`{"UserName":"taowen","first_language":"Chinese"}`, string(output))
+}
+
+func Test_set_naming_strategy_with_omitempty(t *testing.T) {
+	should := require.New(t)
+	SetNamingStrategy(LowerCaseWithUnderscores)
+	output, err := jsoniter.Marshal(struct {
+		UserName      string
+		FirstLanguage string `json:",omitempty"`
+	}{
+		UserName: "taowen",
+	})
+	should.Nil(err)
+	should.Equal(`{"user_name":"taowen"}`, string(output))
+}

vendor/github.com/json-iterator/go/extra/privat_fields.go

@@ -0,0 +1,54 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"strings"
+	"unicode"
+)
+
+// SupportPrivateFields include private fields when encoding/decoding
+func SupportPrivateFields() {
+	jsoniter.RegisterExtension(&privateFieldsExtension{})
+}
+
+type privateFieldsExtension struct {
+	jsoniter.DummyExtension
+}
+
+func (extension *privateFieldsExtension) UpdateStructDescriptor(structDescriptor *jsoniter.StructDescriptor) {
+	for _, binding := range structDescriptor.Fields {
+		isPrivate := unicode.IsLower(rune(binding.Field.Name()[0]))
+		if isPrivate {
+			tag, hastag := binding.Field.Tag().Lookup("json")
+			if !hastag {
+				binding.FromNames = []string{binding.Field.Name()}
+				binding.ToNames = []string{binding.Field.Name()}
+				continue
+			}
+			tagParts := strings.Split(tag, ",")
+			names := calcFieldNames(binding.Field.Name(), tagParts[0], tag)
+			binding.FromNames = names
+			binding.ToNames = names
+		}
+	}
+}
+
+func calcFieldNames(originalFieldName string, tagProvidedFieldName string, wholeTag string) []string {
+	// ignore?
+	if wholeTag == "-" {
+		return []string{}
+	}
+	// rename?
+	var fieldNames []string
+	if tagProvidedFieldName == "" {
+		fieldNames = []string{originalFieldName}
+	} else {
+		fieldNames = []string{tagProvidedFieldName}
+	}
+	// private?
+	isNotExported := unicode.IsLower(rune(originalFieldName[0]))
+	if isNotExported {
+		fieldNames = []string{}
+	}
+	return fieldNames
+}

vendor/github.com/json-iterator/go/extra/private_fields_test.go

@@ -0,0 +1,18 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func Test_private_fields(t *testing.T) {
+	type TestObject struct {
+		field1 string
+	}
+	SupportPrivateFields()
+	should := require.New(t)
+	obj := TestObject{}
+	should.Nil(jsoniter.UnmarshalFromString(`{"field1":"Hello"}`, &obj))
+	should.Equal("Hello", obj.field1)
+}

vendor/github.com/json-iterator/go/extra/time_as_int64_codec.go

@@ -0,0 +1,31 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"time"
+	"unsafe"
+)
+
+// RegisterTimeAsInt64Codec encode/decode time since number of unit since epoch. the precision is the unit.
+func RegisterTimeAsInt64Codec(precision time.Duration) {
+	jsoniter.RegisterTypeEncoder("time.Time", &timeAsInt64Codec{precision})
+	jsoniter.RegisterTypeDecoder("time.Time", &timeAsInt64Codec{precision})
+}
+
+type timeAsInt64Codec struct {
+	precision time.Duration
+}
+
+func (codec *timeAsInt64Codec) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	nanoseconds := iter.ReadInt64() * codec.precision.Nanoseconds()
+	*((*time.Time)(ptr)) = time.Unix(0, nanoseconds)
+}
+
+func (codec *timeAsInt64Codec) IsEmpty(ptr unsafe.Pointer) bool {
+	ts := *((*time.Time)(ptr))
+	return ts.UnixNano() == 0
+}
+func (codec *timeAsInt64Codec) Encode(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+	ts := *((*time.Time)(ptr))
+	stream.WriteInt64(ts.UnixNano() / codec.precision.Nanoseconds())
+}

vendor/github.com/json-iterator/go/extra/time_as_int64_codec_test.go

@@ -0,0 +1,31 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+	"time"
+)
+
+func Test_time_as_int64(t *testing.T) {
+	should := require.New(t)
+	RegisterTimeAsInt64Codec(time.Nanosecond)
+	output, err := jsoniter.Marshal(time.Unix(1497952257, 1002))
+	should.Nil(err)
+	should.Equal("1497952257000001002", string(output))
+	var val time.Time
+	should.Nil(jsoniter.Unmarshal(output, &val))
+	should.Equal(int64(1497952257000001002), val.UnixNano())
+}
+
+func Test_time_as_int64_keep_microsecond(t *testing.T) {
+	t.Skip("conflict")
+	should := require.New(t)
+	RegisterTimeAsInt64Codec(time.Microsecond)
+	output, err := jsoniter.Marshal(time.Unix(1, 1002))
+	should.Nil(err)
+	should.Equal("1000001", string(output))
+	var val time.Time
+	should.Nil(jsoniter.Unmarshal(output, &val))
+	should.Equal(int64(1000001000), val.UnixNano())
+}