plugin/etcdv3: Add etcd v3 plugin (#1702)

* Update dependencies and add etcdv3 client

* Update etcd plugin to support etcd v3 clients

Fixes #341

76 files changed, 7311 insertions, 0 deletions

diff --git a/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_array_test.go b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_array_test.go
new file mode 100644
index 000000000..a28bd8d38
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_array_test.go
@@ -0,0 +1,123 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_read_empty_array_as_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[]"))
+	should.Equal(jsoniter.ArrayValue, any.Get().ValueType())
+	should.Equal(jsoniter.InvalidValue, any.Get(0.3).ValueType())
+	should.Equal(0, any.Size())
+	should.Equal(jsoniter.ArrayValue, any.ValueType())
+	should.Nil(any.LastError())
+	should.Equal(0, any.ToInt())
+	should.Equal(int32(0), any.ToInt32())
+	should.Equal(int64(0), any.ToInt64())
+	should.Equal(uint(0), any.ToUint())
+	should.Equal(uint32(0), any.ToUint32())
+	should.Equal(uint64(0), any.ToUint64())
+	should.Equal(float32(0), any.ToFloat32())
+	should.Equal(float64(0), any.ToFloat64())
+}
+
+func Test_read_one_element_array_as_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[1]"))
+	should.Equal(1, any.Size())
+}
+
+func Test_read_two_element_array_as_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[1,2]"))
+	should.Equal(1, any.Get(0).ToInt())
+	should.Equal(2, any.Size())
+	should.True(any.ToBool())
+	should.Equal(1, any.ToInt())
+	should.Equal([]interface{}{float64(1), float64(2)}, any.GetInterface())
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("[1,2]", string(stream.Buffer()))
+	arr := []int{}
+	any.ToVal(&arr)
+	should.Equal([]int{1, 2}, arr)
+}
+
+func Test_wrap_array_and_convert_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Wrap([]int{1, 2, 3})
+	any2 := jsoniter.Wrap([]int{})
+
+	should.Equal("[1,2,3]", any.ToString())
+	should.True(any.ToBool())
+	should.False(any2.ToBool())
+
+	should.Equal(1, any.ToInt())
+	should.Equal(0, any2.ToInt())
+	should.Equal(int32(1), any.ToInt32())
+	should.Equal(int32(0), any2.ToInt32())
+	should.Equal(int64(1), any.ToInt64())
+	should.Equal(int64(0), any2.ToInt64())
+	should.Equal(uint(1), any.ToUint())
+	should.Equal(uint(0), any2.ToUint())
+	should.Equal(uint32(1), any.ToUint32())
+	should.Equal(uint32(0), any2.ToUint32())
+	should.Equal(uint64(1), any.ToUint64())
+	should.Equal(uint64(0), any2.ToUint64())
+	should.Equal(float32(1), any.ToFloat32())
+	should.Equal(float32(0), any2.ToFloat32())
+	should.Equal(float64(1), any.ToFloat64())
+	should.Equal(float64(0), any2.ToFloat64())
+	should.Equal(3, any.Size())
+	should.Equal(0, any2.Size())
+
+	var i interface{} = []int{1, 2, 3}
+	should.Equal(i, any.GetInterface())
+}
+
+func Test_array_lazy_any_get(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[1,[2,3],4]"))
+	should.Equal(3, any.Get(1, 1).ToInt())
+	should.Equal("[1,[2,3],4]", any.ToString())
+}
+
+func Test_array_lazy_any_get_all(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[[1],[2],[3,4]]"))
+	should.Equal("[1,2,3]", any.Get('*', 0).ToString())
+	any = jsoniter.Get([]byte("[[[1],[2],[3,4]]]"), 0, '*', 0)
+	should.Equal("[1,2,3]", any.ToString())
+}
+
+func Test_array_wrapper_any_get_all(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Wrap([][]int{
+		{1, 2},
+		{3, 4},
+		{5, 6},
+	})
+	should.Equal("[1,3,5]", any.Get('*', 0).ToString())
+	should.Equal(jsoniter.ArrayValue, any.ValueType())
+	should.True(any.ToBool())
+	should.Equal(1, any.Get(0, 0).ToInt())
+}
+
+func Test_array_lazy_any_get_invalid(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[]"))
+	should.Equal(jsoniter.InvalidValue, any.Get(1, 1).ValueType())
+	should.NotNil(any.Get(1, 1).LastError())
+	should.Equal(jsoniter.InvalidValue, any.Get("1").ValueType())
+	should.NotNil(any.Get("1").LastError())
+}
+
+func Test_invalid_array(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("["), 0)
+	should.Equal(jsoniter.InvalidValue, any.ValueType())
+}
diff --git a/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_bool_test.go b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_bool_test.go
new file mode 100644
index 000000000..045671f28
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_bool_test.go
@@ -0,0 +1,65 @@
+package any_tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+var boolConvertMap = map[string]bool{
+	"null":  false,
+	"true":  true,
+	"false": false,
+
+	`"true"`:  true,
+	`"false"`: true,
+
+	"123":   true,
+	`"123"`: true,
+	"0":     false,
+	`"0"`:   false,
+	"-1":    true,
+	`"-1"`:  true,
+
+	"1.1":       true,
+	"0.0":       false,
+	"-1.1":      true,
+	`""`:        false,
+	"[1,2]":     true,
+	"[]":        false,
+	"{}":        true,
+	`{"abc":1}`: true,
+}
+
+func Test_read_bool_as_any(t *testing.T) {
+	should := require.New(t)
+
+	var any jsoniter.Any
+	for k, v := range boolConvertMap {
+		any = jsoniter.Get([]byte(k))
+		if v {
+			should.True(any.ToBool(), fmt.Sprintf("origin val is %v", k))
+		} else {
+			should.False(any.ToBool(), fmt.Sprintf("origin val is %v", k))
+		}
+	}
+
+}
+
+func Test_write_bool_to_stream(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("true"))
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("true", string(stream.Buffer()))
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
+
+	any = jsoniter.Get([]byte("false"))
+	stream = jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("false", string(stream.Buffer()))
+
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
+}
diff --git a/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_float_test.go b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_float_test.go
new file mode 100644
index 000000000..4426e35af
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_float_test.go
@@ -0,0 +1,103 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+var floatConvertMap = map[string]float64{
+	"null":  0,
+	"true":  1,
+	"false": 0,
+
+	`"true"`:  0,
+	`"false"`: 0,
+
+	"1e1":  10,
+	"1e+1": 10,
+	"1e-1": .1,
+	"1E1":  10,
+	"1E+1": 10,
+	"1E-1": .1,
+
+	"-1e1":  -10,
+	"-1e+1": -10,
+	"-1e-1": -.1,
+	"-1E1":  -10,
+	"-1E+1": -10,
+	"-1E-1": -.1,
+
+	`"1e1"`:  10,
+	`"1e+1"`: 10,
+	`"1e-1"`: .1,
+	`"1E1"`:  10,
+	`"1E+1"`: 10,
+	`"1E-1"`: .1,
+
+	`"-1e1"`:  -10,
+	`"-1e+1"`: -10,
+	`"-1e-1"`: -.1,
+	`"-1E1"`:  -10,
+	`"-1E+1"`: -10,
+	`"-1E-1"`: -.1,
+
+	"123":       123,
+	`"123true"`: 123,
+	`"+"`:       0,
+	`"-"`:       0,
+
+	`"-123true"`:  -123,
+	`"-99.9true"`: -99.9,
+	"0":           0,
+	`"0"`:         0,
+	"-1":          -1,
+
+	"1.1":       1.1,
+	"0.0":       0,
+	"-1.1":      -1.1,
+	`"+1.1"`:    1.1,
+	`""`:        0,
+	"[1,2]":     1,
+	"[]":        0,
+	"{}":        0,
+	`{"abc":1}`: 0,
+}
+
+func Test_read_any_to_float(t *testing.T) {
+	should := require.New(t)
+	for k, v := range floatConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(float64(v), any.ToFloat64(), "the original val is "+k)
+	}
+
+	for k, v := range floatConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(float32(v), any.ToFloat32(), "the original val is "+k)
+	}
+}
+
+func Test_read_float_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.WrapFloat64(12.3)
+	anyFloat64 := float64(12.3)
+	//negaAnyFloat64 := float64(-1.1)
+	any2 := jsoniter.WrapFloat64(-1.1)
+	should.Equal(float64(12.3), any.ToFloat64())
+	//should.Equal("12.3", any.ToString())
+	should.True(any.ToBool())
+	should.Equal(float32(anyFloat64), any.ToFloat32())
+	should.Equal(int(anyFloat64), any.ToInt())
+	should.Equal(int32(anyFloat64), any.ToInt32())
+	should.Equal(int64(anyFloat64), any.ToInt64())
+	should.Equal(uint(anyFloat64), any.ToUint())
+	should.Equal(uint32(anyFloat64), any.ToUint32())
+	should.Equal(uint64(anyFloat64), any.ToUint64())
+	should.Equal(uint(0), any2.ToUint())
+	should.Equal(uint32(0), any2.ToUint32())
+	should.Equal(uint64(0), any2.ToUint64())
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+
+	should.Equal("1.23E+01", any.ToString())
+}
diff --git a/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_int_test.go b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_int_test.go
new file mode 100644
index 000000000..c5a3d4260
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_int_test.go
@@ -0,0 +1,198 @@
+package any_tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+var intConvertMap = map[string]int{
+	"null":       0,
+	"321.1":      321,
+	"-321.1":     -321,
+	`"1.1"`:      1,
+	`"-321.1"`:   -321,
+	"0.0":        0,
+	"0":          0,
+	`"0"`:        0,
+	`"0.0"`:      0,
+	"-1.1":       -1,
+	"true":       1,
+	"false":      0,
+	`"true"`:     0,
+	`"false"`:    0,
+	`"true123"`:  0,
+	`"123true"`:  123,
+	`"-123true"`: -123,
+	`"1.2332e6"`: 1,
+	`""`:         0,
+	"+":          0,
+	"-":          0,
+	"[]":         0,
+	"[1,2]":      1,
+	`["1","2"]`:  1,
+	// object in php cannot convert to int
+	"{}": 0,
+}
+
+func Test_read_any_to_int(t *testing.T) {
+	should := require.New(t)
+
+	// int
+	for k, v := range intConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(v, any.ToInt(), fmt.Sprintf("origin val %v", k))
+	}
+
+	// int32
+	for k, v := range intConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(int32(v), any.ToInt32(), fmt.Sprintf("original val is %v", k))
+	}
+
+	// int64
+	for k, v := range intConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(int64(v), any.ToInt64(), fmt.Sprintf("original val is %v", k))
+	}
+
+}
+
+var uintConvertMap = map[string]int{
+	"null":       0,
+	"321.1":      321,
+	`"1.1"`:      1,
+	`"-123.1"`:   0,
+	"0.0":        0,
+	"0":          0,
+	`"0"`:        0,
+	`"0.0"`:      0,
+	`"00.0"`:     0,
+	"true":       1,
+	"false":      0,
+	`"true"`:     0,
+	`"false"`:    0,
+	`"true123"`:  0,
+	`"+1"`:       1,
+	`"123true"`:  123,
+	`"-123true"`: 0,
+	`"1.2332e6"`: 1,
+	`""`:         0,
+	"+":          0,
+	"-":          0,
+	".":          0,
+	"[]":         0,
+	"[1,2]":      1,
+	"{}":         0,
+	"{1,2}":      0,
+	"-1.1":       0,
+	"-321.1":     0,
+}
+
+func Test_read_any_to_uint(t *testing.T) {
+	should := require.New(t)
+
+	for k, v := range uintConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(uint64(v), any.ToUint64(), fmt.Sprintf("origin val %v", k))
+	}
+
+	for k, v := range uintConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(uint32(v), any.ToUint32(), fmt.Sprintf("origin val %v", k))
+	}
+
+	for k, v := range uintConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(uint(v), any.ToUint(), fmt.Sprintf("origin val %v", k))
+	}
+
+}
+
+func Test_read_int64_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.WrapInt64(12345)
+	should.Equal(12345, any.ToInt())
+	should.Equal(int32(12345), any.ToInt32())
+	should.Equal(int64(12345), any.ToInt64())
+	should.Equal(uint(12345), any.ToUint())
+	should.Equal(uint32(12345), any.ToUint32())
+	should.Equal(uint64(12345), any.ToUint64())
+	should.Equal(float32(12345), any.ToFloat32())
+	should.Equal(float64(12345), any.ToFloat64())
+	should.Equal("12345", any.ToString())
+	should.Equal(true, any.ToBool())
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("12345", string(stream.Buffer()))
+}
+func Test_read_int32_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.WrapInt32(12345)
+	should.Equal(12345, any.ToInt())
+	should.Equal(int32(12345), any.ToInt32())
+	should.Equal(int64(12345), any.ToInt64())
+	should.Equal(uint(12345), any.ToUint())
+	should.Equal(uint32(12345), any.ToUint32())
+	should.Equal(uint64(12345), any.ToUint64())
+	should.Equal(float32(12345), any.ToFloat32())
+	should.Equal(float64(12345), any.ToFloat64())
+	should.Equal("12345", any.ToString())
+	should.Equal(true, any.ToBool())
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("12345", string(stream.Buffer()))
+}
+
+func Test_read_uint32_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.WrapUint32(12345)
+	should.Equal(12345, any.ToInt())
+	should.Equal(int32(12345), any.ToInt32())
+	should.Equal(int64(12345), any.ToInt64())
+	should.Equal(uint(12345), any.ToUint())
+	should.Equal(uint32(12345), any.ToUint32())
+	should.Equal(uint64(12345), any.ToUint64())
+	should.Equal(float32(12345), any.ToFloat32())
+	should.Equal(float64(12345), any.ToFloat64())
+	should.Equal("12345", any.ToString())
+	should.Equal(true, any.ToBool())
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("12345", string(stream.Buffer()))
+}
+
+func Test_read_uint64_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.WrapUint64(12345)
+	should.Equal(12345, any.ToInt())
+	should.Equal(int32(12345), any.ToInt32())
+	should.Equal(int64(12345), any.ToInt64())
+	should.Equal(uint(12345), any.ToUint())
+	should.Equal(uint32(12345), any.ToUint32())
+	should.Equal(uint64(12345), any.ToUint64())
+	should.Equal(float32(12345), any.ToFloat32())
+	should.Equal(float64(12345), any.ToFloat64())
+	should.Equal("12345", any.ToString())
+	should.Equal(true, any.ToBool())
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("12345", string(stream.Buffer()))
+	stream = jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	stream.WriteUint(uint(123))
+	should.Equal("123", string(stream.Buffer()))
+}
+
+func Test_int_lazy_any_get(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("1234"))
+	// panic!!
+	//should.Equal(any.LastError(), io.EOF)
+	should.Equal(jsoniter.InvalidValue, any.Get(1, "2").ValueType())
+}
diff --git a/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_map_test.go b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_map_test.go
new file mode 100644
index 000000000..c5f2e6fea
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_map_test.go
@@ -0,0 +1,28 @@
+package any_tests
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func Test_wrap_map(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Wrap(map[string]string{"Field1": "hello"})
+	should.Equal("hello", any.Get("Field1").ToString())
+	any = jsoniter.Wrap(map[string]string{"Field1": "hello"})
+	should.Equal(1, any.Size())
+}
+
+func Test_map_wrapper_any_get_all(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Wrap(map[string][]int{"Field1": {1, 2}})
+	should.Equal(`{"Field1":1}`, any.Get('*', 0).ToString())
+	should.Contains(any.Keys(), "Field1")
+
+	// map write to
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 0)
+	any.WriteTo(stream)
+	// TODO cannot pass
+	//should.Equal(string(stream.buf), "")
+}
diff --git a/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_null_test.go b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_null_test.go
new file mode 100644
index 000000000..a86625e9a
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_null_test.go
@@ -0,0 +1,16 @@
+package any_tests
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func Test_read_null_as_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte(`null`))
+	should.Equal(0, any.ToInt())
+	should.Equal(float64(0), any.ToFloat64())
+	should.Equal("", any.ToString())
+	should.False(any.ToBool())
+}
diff --git a/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_object_test.go b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_object_test.go
new file mode 100644
index 000000000..a36f6cae1
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_object_test.go
@@ -0,0 +1,123 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_read_object_as_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte(`{"a":"stream","c":"d"}`))
+	should.Equal(`{"a":"stream","c":"d"}`, any.ToString())
+	// partial parse
+	should.Equal("stream", any.Get("a").ToString())
+	should.Equal("d", any.Get("c").ToString())
+	should.Equal(2, len(any.Keys()))
+	any = jsoniter.Get([]byte(`{"a":"stream","c":"d"}`))
+	// full parse
+	should.Equal(2, len(any.Keys()))
+	should.Equal(2, any.Size())
+	should.True(any.ToBool())
+	should.Equal(0, any.ToInt())
+	should.Equal(jsoniter.ObjectValue, any.ValueType())
+	should.Nil(any.LastError())
+	obj := struct {
+		A string
+	}{}
+	any.ToVal(&obj)
+	should.Equal("stream", obj.A)
+}
+
+func Test_object_lazy_any_get(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte(`{"a":{"stream":{"c":"d"}}}`))
+	should.Equal("d", any.Get("a", "stream", "c").ToString())
+}
+
+func Test_object_lazy_any_get_all(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte(`{"a":[0],"stream":[1]}`))
+	should.Contains(any.Get('*', 0).ToString(), `"a":0`)
+}
+
+func Test_object_lazy_any_get_invalid(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte(`{}`))
+	should.Equal(jsoniter.InvalidValue, any.Get("a", "stream", "c").ValueType())
+	should.Equal(jsoniter.InvalidValue, any.Get(1).ValueType())
+}
+
+func Test_wrap_map_and_convert_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Wrap(map[string]interface{}{"a": 1})
+	should.True(any.ToBool())
+	should.Equal(0, any.ToInt())
+	should.Equal(int32(0), any.ToInt32())
+	should.Equal(int64(0), any.ToInt64())
+	should.Equal(float32(0), any.ToFloat32())
+	should.Equal(float64(0), any.ToFloat64())
+	should.Equal(uint(0), any.ToUint())
+	should.Equal(uint32(0), any.ToUint32())
+	should.Equal(uint64(0), any.ToUint64())
+}
+
+func Test_wrap_object_and_convert_to_any(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct {
+		Field1 string
+		field2 string
+	}
+	any := jsoniter.Wrap(TestObject{"hello", "world"})
+	should.Equal("hello", any.Get("Field1").ToString())
+	any = jsoniter.Wrap(TestObject{"hello", "world"})
+	should.Equal(2, any.Size())
+	should.Equal(`{"Field1":"hello"}`, any.Get('*').ToString())
+
+	should.Equal(0, any.ToInt())
+	should.Equal(int32(0), any.ToInt32())
+	should.Equal(int64(0), any.ToInt64())
+	should.Equal(float32(0), any.ToFloat32())
+	should.Equal(float64(0), any.ToFloat64())
+	should.Equal(uint(0), any.ToUint())
+	should.Equal(uint32(0), any.ToUint32())
+	should.Equal(uint64(0), any.ToUint64())
+	should.True(any.ToBool())
+	should.Equal(`{"Field1":"hello"}`, any.ToString())
+
+	// cannot pass!
+	//stream := NewStream(ConfigDefault, nil, 32)
+	//any.WriteTo(stream)
+	//should.Equal(`{"Field1":"hello"}`, string(stream.Buffer()))
+	// cannot pass!
+
+}
+
+func Test_any_within_struct(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct {
+		Field1 jsoniter.Any
+		Field2 jsoniter.Any
+	}
+	obj := TestObject{}
+	err := jsoniter.UnmarshalFromString(`{"Field1": "hello", "Field2": [1,2,3]}`, &obj)
+	should.Nil(err)
+	should.Equal("hello", obj.Field1.ToString())
+	should.Equal("[1,2,3]", obj.Field2.ToString())
+}
+
+func Test_object_wrapper_any_get_all(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct {
+		Field1 []int
+		Field2 []int
+	}
+	any := jsoniter.Wrap(TestObject{[]int{1, 2}, []int{3, 4}})
+	should.Contains(any.Get('*', 0).ToString(), `"Field2":3`)
+	should.Contains(any.Keys(), "Field1")
+	should.Contains(any.Keys(), "Field2")
+	should.NotContains(any.Keys(), "Field3")
+
+	//should.Contains(any.GetObject()["Field1"].GetArray()[0], 1)
+}
diff --git a/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_string_test.go b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_string_test.go
new file mode 100644
index 000000000..3cd324689
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_tests/jsoniter_any_string_test.go
@@ -0,0 +1,58 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+var stringConvertMap = map[string]string{
+	"null":      "",
+	"321.1":     "321.1",
+	`"1.1"`:     "1.1",
+	`"-123.1"`:  "-123.1",
+	"0.0":       "0.0",
+	"0":         "0",
+	`"0"`:       "0",
+	`"0.0"`:     "0.0",
+	`"00.0"`:    "00.0",
+	"true":      "true",
+	"false":     "false",
+	`"true"`:    "true",
+	`"false"`:   "false",
+	`"true123"`: "true123",
+	`"+1"`:      "+1",
+	"[]":        "[]",
+	"[1,2]":     "[1,2]",
+	"{}":        "{}",
+	`{"a":1, "stream":true}`: `{"a":1, "stream":true}`,
+}
+
+func Test_read_any_to_string(t *testing.T) {
+	should := require.New(t)
+	for k, v := range stringConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(v, any.ToString(), "original val "+k)
+	}
+}
+
+func Test_read_string_as_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte(`"hello"`))
+	should.Equal("hello", any.ToString())
+	should.True(any.ToBool())
+	any = jsoniter.Get([]byte(`" "`))
+	should.False(any.ToBool())
+	any = jsoniter.Get([]byte(`"false"`))
+	should.True(any.ToBool())
+	any = jsoniter.Get([]byte(`"123"`))
+	should.Equal(123, any.ToInt())
+}
+
+func Test_wrap_string(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("-32000")).MustBeValid()
+	should.Equal(-32000, any.ToInt())
+	should.NoError(any.LastError())
+}
diff --git a/vendor/github.com/json-iterator/go/any_tests/jsoniter_must_be_valid_test.go b/vendor/github.com/json-iterator/go/any_tests/jsoniter_must_be_valid_test.go
new file mode 100644
index 000000000..8974eb7f7
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_tests/jsoniter_must_be_valid_test.go
@@ -0,0 +1,72 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+// if must be valid is useless, just drop this test
+func Test_must_be_valid(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("123"))
+	should.Equal(any.MustBeValid().ToInt(), 123)
+
+	any = jsoniter.Wrap(int8(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(int16(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(int32(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(int64(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(uint(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(uint8(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(uint16(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(uint32(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(uint64(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(float32(10))
+	should.Equal(any.MustBeValid().ToFloat64(), float64(10))
+
+	any = jsoniter.Wrap(float64(10))
+	should.Equal(any.MustBeValid().ToFloat64(), float64(10))
+
+	any = jsoniter.Wrap(true)
+	should.Equal(any.MustBeValid().ToFloat64(), float64(1))
+
+	any = jsoniter.Wrap(false)
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap(nil)
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap(struct{ age int }{age: 1})
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap(map[string]interface{}{"abc": 1})
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap("abc")
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap([]int{})
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap([]int{1, 2})
+	should.Equal(any.MustBeValid().ToFloat64(), float64(1))
+}
diff --git a/vendor/github.com/json-iterator/go/any_tests/jsoniter_wrap_test.go b/vendor/github.com/json-iterator/go/any_tests/jsoniter_wrap_test.go
new file mode 100644
index 000000000..480985ffa
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_tests/jsoniter_wrap_test.go
@@ -0,0 +1,119 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_wrap_and_valuetype_everything(t *testing.T) {
+	should := require.New(t)
+	var i interface{}
+	any := jsoniter.Get([]byte("123"))
+	// default of number type is float64
+	i = float64(123)
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(int8(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	//  get interface is not int8 interface
+	// i = int8(10)
+	// should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(int16(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	//i = int16(10)
+	//should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(int32(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	i = int32(10)
+	should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(int64(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	i = int64(10)
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(uint(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	// not equal
+	//i = uint(10)
+	//should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(uint8(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	// not equal
+	// i = uint8(10)
+	// should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(uint16(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	any = jsoniter.Wrap(uint32(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	i = uint32(10)
+	should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(uint64(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	i = uint64(10)
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(float32(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	// not equal
+	//i = float32(10)
+	//should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(float64(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	i = float64(10)
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(true)
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
+	should.Equal(any.LastError(), nil)
+	i = true
+	should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(false)
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
+	should.Equal(any.LastError(), nil)
+	i = false
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(nil)
+	should.Equal(any.ValueType(), jsoniter.NilValue)
+	should.Equal(any.LastError(), nil)
+	i = nil
+	should.Equal(i, any.GetInterface())
+
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("null", string(stream.Buffer()))
+	should.Equal(any.LastError(), nil)
+
+	any = jsoniter.Wrap(struct{ age int }{age: 1})
+	should.Equal(any.ValueType(), jsoniter.ObjectValue)
+	should.Equal(any.LastError(), nil)
+	i = struct{ age int }{age: 1}
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(map[string]interface{}{"abc": 1})
+	should.Equal(any.ValueType(), jsoniter.ObjectValue)
+	should.Equal(any.LastError(), nil)
+	i = map[string]interface{}{"abc": 1}
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap("abc")
+	i = "abc"
+	should.Equal(i, any.GetInterface())
+	should.Equal(nil, any.LastError())
+
+}
diff --git a/vendor/github.com/json-iterator/go/api_tests/config_test.go b/vendor/github.com/json-iterator/go/api_tests/config_test.go
new file mode 100644
index 000000000..d3e93e5c6
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/api_tests/config_test.go
@@ -0,0 +1,47 @@
+package test
+
+import (
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func Test_use_number_for_unmarshal(t *testing.T) {
+	should := require.New(t)
+	api := jsoniter.Config{UseNumber: true}.Froze()
+	var obj interface{}
+	should.Nil(api.UnmarshalFromString("123", &obj))
+	should.Equal(json.Number("123"), obj)
+}
+
+func Test_customize_float_marshal(t *testing.T) {
+	should := require.New(t)
+	json := jsoniter.Config{MarshalFloatWith6Digits: true}.Froze()
+	str, err := json.MarshalToString(float32(1.23456789))
+	should.Nil(err)
+	should.Equal("1.234568", str)
+}
+
+func Test_customize_tag_key(t *testing.T) {
+
+	type TestObject struct {
+		Field string `orm:"field"`
+	}
+
+	should := require.New(t)
+	json := jsoniter.Config{TagKey: "orm"}.Froze()
+	str, err := json.MarshalToString(TestObject{"hello"})
+	should.Nil(err)
+	should.Equal(`{"field":"hello"}`, str)
+}
+
+func Test_read_large_number_as_interface(t *testing.T) {
+	should := require.New(t)
+	var val interface{}
+	err := jsoniter.Config{UseNumber: true}.Froze().UnmarshalFromString(`123456789123456789123456789`, &val)
+	should.Nil(err)
+	output, err := jsoniter.MarshalToString(val)
+	should.Nil(err)
+	should.Equal(`123456789123456789123456789`, output)
+}
diff --git a/vendor/github.com/json-iterator/go/api_tests/decoder_test.go b/vendor/github.com/json-iterator/go/api_tests/decoder_test.go
new file mode 100644
index 000000000..eecfddbc8
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/api_tests/decoder_test.go
@@ -0,0 +1,58 @@
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"io/ioutil"
+	"testing"
+)
+
+func Test_disallowUnknownFields(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct{}
+	var obj TestObject
+	decoder := jsoniter.NewDecoder(bytes.NewBufferString(`{"field1":100}`))
+	decoder.DisallowUnknownFields()
+	should.Error(decoder.Decode(&obj))
+}
+
+func Test_new_decoder(t *testing.T) {
+	should := require.New(t)
+	decoder1 := json.NewDecoder(bytes.NewBufferString(`[1][2]`))
+	decoder2 := jsoniter.NewDecoder(bytes.NewBufferString(`[1][2]`))
+	arr1 := []int{}
+	should.Nil(decoder1.Decode(&arr1))
+	should.Equal([]int{1}, arr1)
+	arr2 := []int{}
+	should.True(decoder1.More())
+	buffered, _ := ioutil.ReadAll(decoder1.Buffered())
+	should.Equal("[2]", string(buffered))
+	should.Nil(decoder2.Decode(&arr2))
+	should.Equal([]int{1}, arr2)
+	should.True(decoder2.More())
+	buffered, _ = ioutil.ReadAll(decoder2.Buffered())
+	should.Equal("[2]", string(buffered))
+
+	should.Nil(decoder1.Decode(&arr1))
+	should.Equal([]int{2}, arr1)
+	should.False(decoder1.More())
+	should.Nil(decoder2.Decode(&arr2))
+	should.Equal([]int{2}, arr2)
+	should.False(decoder2.More())
+}
+
+func Test_use_number(t *testing.T) {
+	should := require.New(t)
+	decoder1 := json.NewDecoder(bytes.NewBufferString(`123`))
+	decoder1.UseNumber()
+	decoder2 := jsoniter.NewDecoder(bytes.NewBufferString(`123`))
+	decoder2.UseNumber()
+	var obj1 interface{}
+	should.Nil(decoder1.Decode(&obj1))
+	should.Equal(json.Number("123"), obj1)
+	var obj2 interface{}
+	should.Nil(decoder2.Decode(&obj2))
+	should.Equal(json.Number("123"), obj2)
+}
diff --git a/vendor/github.com/json-iterator/go/api_tests/encoder_18_test.go b/vendor/github.com/json-iterator/go/api_tests/encoder_18_test.go
new file mode 100644
index 000000000..3c159b58d
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/api_tests/encoder_18_test.go
@@ -0,0 +1,46 @@
+//+build go1.8
+
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+	"unicode/utf8"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_new_encoder(t *testing.T) {
+	should := require.New(t)
+	buf1 := &bytes.Buffer{}
+	encoder1 := json.NewEncoder(buf1)
+	encoder1.SetEscapeHTML(false)
+	encoder1.Encode([]int{1})
+	should.Equal("[1]\n", buf1.String())
+	buf2 := &bytes.Buffer{}
+	encoder2 := jsoniter.NewEncoder(buf2)
+	encoder2.SetEscapeHTML(false)
+	encoder2.Encode([]int{1})
+	should.Equal("[1]\n", buf2.String())
+}
+
+func Test_string_encode_with_std_without_html_escape(t *testing.T) {
+	api := jsoniter.Config{EscapeHTML: false}.Froze()
+	should := require.New(t)
+	for i := 0; i < utf8.RuneSelf; i++ {
+		input := string([]byte{byte(i)})
+		buf := &bytes.Buffer{}
+		encoder := json.NewEncoder(buf)
+		encoder.SetEscapeHTML(false)
+		err := encoder.Encode(input)
+		should.Nil(err)
+		stdOutput := buf.String()
+		stdOutput = stdOutput[:len(stdOutput)-1]
+		jsoniterOutputBytes, err := api.Marshal(input)
+		should.Nil(err)
+		jsoniterOutput := string(jsoniterOutputBytes)
+		should.Equal(stdOutput, jsoniterOutput)
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/api_tests/encoder_test.go b/vendor/github.com/json-iterator/go/api_tests/encoder_test.go
new file mode 100644
index 000000000..7b9202cf0
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/api_tests/encoder_test.go
@@ -0,0 +1,20 @@
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+// Standard Encoder has trailing newline.
+func TestEncoderHasTrailingNewline(t *testing.T) {
+	should := require.New(t)
+	var buf, stdbuf bytes.Buffer
+	enc := jsoniter.ConfigCompatibleWithStandardLibrary.NewEncoder(&buf)
+	enc.Encode(1)
+	stdenc := json.NewEncoder(&stdbuf)
+	stdenc.Encode(1)
+	should.Equal(stdbuf.Bytes(), buf.Bytes())
+}
diff --git a/vendor/github.com/json-iterator/go/api_tests/marshal_indent_test.go b/vendor/github.com/json-iterator/go/api_tests/marshal_indent_test.go
new file mode 100644
index 000000000..926931a80
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/api_tests/marshal_indent_test.go
@@ -0,0 +1,36 @@
+package test
+
+import (
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func Test_marshal_indent(t *testing.T) {
+	should := require.New(t)
+	obj := struct {
+		F1 int
+		F2 []int
+	}{1, []int{2, 3, 4}}
+	output, err := json.MarshalIndent(obj, "", "  ")
+	should.Nil(err)
+	should.Equal("{\n  \"F1\": 1,\n  \"F2\": [\n    2,\n    3,\n    4\n  ]\n}", string(output))
+	output, err = jsoniter.MarshalIndent(obj, "", "  ")
+	should.Nil(err)
+	should.Equal("{\n  \"F1\": 1,\n  \"F2\": [\n    2,\n    3,\n    4\n  ]\n}", string(output))
+}
+
+func Test_marshal_indent_map(t *testing.T) {
+	should := require.New(t)
+	obj := map[int]int{1: 2}
+	output, err := json.MarshalIndent(obj, "", "  ")
+	should.Nil(err)
+	should.Equal("{\n  \"1\": 2\n}", string(output))
+	output, err = jsoniter.MarshalIndent(obj, "", "  ")
+	should.Nil(err)
+	should.Equal("{\n  \"1\": 2\n}", string(output))
+	output, err = jsoniter.ConfigCompatibleWithStandardLibrary.MarshalIndent(obj, "", "  ")
+	should.Nil(err)
+	should.Equal("{\n  \"1\": 2\n}", string(output))
+}
diff --git a/vendor/github.com/json-iterator/go/benchmarks/encode_string_test.go b/vendor/github.com/json-iterator/go/benchmarks/encode_string_test.go
new file mode 100644
index 000000000..c1cb1afb0
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/benchmarks/encode_string_test.go
@@ -0,0 +1,25 @@
+package test
+
+import (
+	"bytes"
+	"github.com/json-iterator/go"
+	"testing"
+)
+
+func Benchmark_encode_string_with_SetEscapeHTML(b *testing.B) {
+	type V struct {
+		S string
+		B bool
+		I int
+	}
+	var json = jsoniter.ConfigCompatibleWithStandardLibrary
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		buf := &bytes.Buffer{}
+		enc := json.NewEncoder(buf)
+		enc.SetEscapeHTML(true)
+		if err := enc.Encode(V{S: "s", B: true, I: 233}); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/benchmarks/jsoniter_large_file_test.go b/vendor/github.com/json-iterator/go/benchmarks/jsoniter_large_file_test.go
new file mode 100644
index 000000000..465eaec91
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/benchmarks/jsoniter_large_file_test.go
@@ -0,0 +1,158 @@
+package test
+
+import (
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+//func Test_large_file(t *testing.T) {
+//	file, err := os.Open("/tmp/large-file.json")
+//	if err != nil {
+//		t.Fatal(err)
+//	}
+//	iter := Parse(file, 4096)
+//	count := 0
+//	for iter.ReadArray() {
+//		iter.Skip()
+//		count++
+//	}
+//	if count != 11351 {
+//		t.Fatal(count)
+//	}
+//}
+
+func init() {
+	ioutil.WriteFile("/tmp/large-file.json", []byte(`[{
+  "person": {
+    "id": "d50887ca-a6ce-4e59-b89f-14f0b5d03b03",
+    "name": {
+      "fullName": "Leonid Bugaev",
+      "givenName": "Leonid",
+      "familyName": "Bugaev"
+    },
+    "email": "leonsbox@gmail.com",
+    "gender": "male",
+    "location": "Saint Petersburg, Saint Petersburg, RU",
+    "geo": {
+      "city": "Saint Petersburg",
+      "state": "Saint Petersburg",
+      "country": "Russia",
+      "lat": 59.9342802,
+      "lng": 30.3350986
+    },
+    "bio": "Senior engineer at Granify.com",
+    "site": "http://flickfaver.com",
+    "avatar": "https://d1ts43dypk8bqh.cloudfront.net/v1/avatars/d50887ca-a6ce-4e59-b89f-14f0b5d03b03",
+    "employment": {
+      "name": "www.latera.ru",
+      "title": "Software Engineer",
+      "domain": "gmail.com"
+    },
+    "facebook": {
+      "handle": "leonid.bugaev"
+    },
+    "github": {
+      "handle": "buger",
+      "id": 14009,
+      "avatar": "https://avatars.githubusercontent.com/u/14009?v=3",
+      "company": "Granify",
+      "blog": "http://leonsbox.com",
+      "followers": 95,
+      "following": 10
+    },
+    "twitter": {
+      "handle": "flickfaver",
+      "id": 77004410,
+      "bio": null,
+      "followers": 2,
+      "following": 1,
+      "statuses": 5,
+      "favorites": 0,
+      "location": "",
+      "site": "http://flickfaver.com",
+      "avatar": null
+    },
+    "linkedin": {
+      "handle": "in/leonidbugaev"
+    },
+    "googleplus": {
+      "handle": null
+    },
+    "angellist": {
+      "handle": "leonid-bugaev",
+      "id": 61541,
+      "bio": "Senior engineer at Granify.com",
+      "blog": "http://buger.github.com",
+      "site": "http://buger.github.com",
+      "followers": 41,
+      "avatar": "https://d1qb2nb5cznatu.cloudfront.net/users/61541-medium_jpg?1405474390"
+    },
+    "klout": {
+      "handle": null,
+      "score": null
+    },
+    "foursquare": {
+      "handle": null
+    },
+    "aboutme": {
+      "handle": "leonid.bugaev",
+      "bio": null,
+      "avatar": null
+    },
+    "gravatar": {
+      "handle": "buger",
+      "urls": [
+      ],
+      "avatar": "http://1.gravatar.com/avatar/f7c8edd577d13b8930d5522f28123510",
+      "avatars": [
+        {
+          "url": "http://1.gravatar.com/avatar/f7c8edd577d13b8930d5522f28123510",
+          "type": "thumbnail"
+        }
+      ]
+    },
+    "fuzzy": false
+  },
+  "company": "hello"
+}]`), 0666)
+}
+
+/*
+200000	      8886 ns/op	    4336 B/op	       6 allocs/op
+50000	     34244 ns/op	    6744 B/op	      14 allocs/op
+*/
+func Benchmark_jsoniter_large_file(b *testing.B) {
+	b.ReportAllocs()
+	for n := 0; n < b.N; n++ {
+		file, _ := os.Open("/tmp/large-file.json")
+		iter := jsoniter.Parse(jsoniter.ConfigDefault, file, 4096)
+		count := 0
+		iter.ReadArrayCB(func(iter *jsoniter.Iterator) bool {
+			// Skip() is strict by default, use --tags jsoniter-sloppy to skip without validation
+			iter.Skip()
+			count++
+			return true
+		})
+		file.Close()
+		if iter.Error != nil {
+			b.Error(iter.Error)
+		}
+	}
+}
+
+func Benchmark_json_large_file(b *testing.B) {
+	b.ReportAllocs()
+	for n := 0; n < b.N; n++ {
+		file, _ := os.Open("/tmp/large-file.json")
+		bytes, _ := ioutil.ReadAll(file)
+		file.Close()
+		result := []struct{}{}
+		err := json.Unmarshal(bytes, &result)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/extension_tests/decoder_test.go b/vendor/github.com/json-iterator/go/extension_tests/decoder_test.go
new file mode 100644
index 000000000..db253d885
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/extension_tests/decoder_test.go
@@ -0,0 +1,100 @@
+package test
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"strconv"
+	"testing"
+	"time"
+	"unsafe"
+)
+
+func Test_customize_type_decoder(t *testing.T) {
+	t.Skip()
+	jsoniter.RegisterTypeDecoderFunc("time.Time", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		t, err := time.ParseInLocation("2006-01-02 15:04:05", iter.ReadString(), time.UTC)
+		if err != nil {
+			iter.Error = err
+			return
+		}
+		*((*time.Time)(ptr)) = t
+	})
+	//defer jsoniter.ConfigDefault.(*frozenConfig).cleanDecoders()
+	val := time.Time{}
+	err := jsoniter.Unmarshal([]byte(`"2016-12-05 08:43:28"`), &val)
+	if err != nil {
+		t.Fatal(err)
+	}
+	year, month, day := val.Date()
+	if year != 2016 || month != 12 || day != 5 {
+		t.Fatal(val)
+	}
+}
+
+func Test_customize_byte_array_encoder(t *testing.T) {
+	t.Skip()
+	//jsoniter.ConfigDefault.(*frozenConfig).cleanEncoders()
+	should := require.New(t)
+	jsoniter.RegisterTypeEncoderFunc("[]uint8", func(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+		t := *((*[]byte)(ptr))
+		stream.WriteString(string(t))
+	}, nil)
+	//defer jsoniter.ConfigDefault.(*frozenConfig).cleanEncoders()
+	val := []byte("abc")
+	str, err := jsoniter.MarshalToString(val)
+	should.Nil(err)
+	should.Equal(`"abc"`, str)
+}
+
+func Test_customize_field_decoder(t *testing.T) {
+	type Tom struct {
+		field1 string
+	}
+	jsoniter.RegisterFieldDecoderFunc("jsoniter.Tom", "field1", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		*((*string)(ptr)) = strconv.Itoa(iter.ReadInt())
+	})
+	//defer jsoniter.ConfigDefault.(*frozenConfig).cleanDecoders()
+	tom := Tom{}
+	err := jsoniter.Unmarshal([]byte(`{"field1": 100}`), &tom)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func Test_recursive_empty_interface_customization(t *testing.T) {
+	t.Skip()
+	var obj interface{}
+	jsoniter.RegisterTypeDecoderFunc("interface {}", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		switch iter.WhatIsNext() {
+		case jsoniter.NumberValue:
+			*(*interface{})(ptr) = iter.ReadInt64()
+		default:
+			*(*interface{})(ptr) = iter.Read()
+		}
+	})
+	should := require.New(t)
+	jsoniter.Unmarshal([]byte("[100]"), &obj)
+	should.Equal([]interface{}{int64(100)}, obj)
+}
+
+type MyInterface interface {
+	Hello() string
+}
+
+type MyString string
+
+func (ms MyString) Hello() string {
+	return string(ms)
+}
+
+func Test_read_custom_interface(t *testing.T) {
+	t.Skip()
+	should := require.New(t)
+	var val MyInterface
+	jsoniter.RegisterTypeDecoderFunc("jsoniter.MyInterface", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		*((*MyInterface)(ptr)) = MyString(iter.ReadString())
+	})
+	err := jsoniter.UnmarshalFromString(`"hello"`, &val)
+	should.Nil(err)
+	should.Equal("hello", val.Hello())
+}
diff --git a/vendor/github.com/json-iterator/go/extension_tests/extension_test.go b/vendor/github.com/json-iterator/go/extension_tests/extension_test.go
new file mode 100644
index 000000000..836db5bc0
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/extension_tests/extension_test.go
@@ -0,0 +1,120 @@
+package test
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/modern-go/reflect2"
+	"github.com/stretchr/testify/require"
+	"reflect"
+	"strconv"
+	"testing"
+	"unsafe"
+)
+
+type TestObject1 struct {
+	Field1 string
+}
+
+type testExtension struct {
+	jsoniter.DummyExtension
+}
+
+func (extension *testExtension) UpdateStructDescriptor(structDescriptor *jsoniter.StructDescriptor) {
+	if structDescriptor.Type.String() != "test.TestObject1" {
+		return
+	}
+	binding := structDescriptor.GetField("Field1")
+	binding.Encoder = &funcEncoder{fun: func(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+		str := *((*string)(ptr))
+		val, _ := strconv.Atoi(str)
+		stream.WriteInt(val)
+	}}
+	binding.Decoder = &funcDecoder{func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		*((*string)(ptr)) = strconv.Itoa(iter.ReadInt())
+	}}
+	binding.ToNames = []string{"field-1"}
+	binding.FromNames = []string{"field-1"}
+}
+
+func Test_customize_field_by_extension(t *testing.T) {
+	should := require.New(t)
+	cfg := jsoniter.Config{}.Froze()
+	cfg.RegisterExtension(&testExtension{})
+	obj := TestObject1{}
+	err := cfg.UnmarshalFromString(`{"field-1": 100}`, &obj)
+	should.Nil(err)
+	should.Equal("100", obj.Field1)
+	str, err := cfg.MarshalToString(obj)
+	should.Nil(err)
+	should.Equal(`{"field-1":100}`, str)
+}
+
+func Test_customize_map_key_encoder(t *testing.T) {
+	should := require.New(t)
+	cfg := jsoniter.Config{}.Froze()
+	cfg.RegisterExtension(&testMapKeyExtension{})
+	m := map[int]int{1: 2}
+	output, err := cfg.MarshalToString(m)
+	should.NoError(err)
+	should.Equal(`{"2":2}`, output)
+	m = map[int]int{}
+	should.NoError(cfg.UnmarshalFromString(output, &m))
+	should.Equal(map[int]int{1: 2}, m)
+}
+
+type testMapKeyExtension struct {
+	jsoniter.DummyExtension
+}
+
+func (extension *testMapKeyExtension) CreateMapKeyEncoder(typ reflect2.Type) jsoniter.ValEncoder {
+	if typ.Kind() == reflect.Int {
+		return &funcEncoder{
+			fun: func(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+				stream.WriteRaw(`"`)
+				stream.WriteInt(*(*int)(ptr) + 1)
+				stream.WriteRaw(`"`)
+			},
+		}
+	}
+	return nil
+}
+
+func (extension *testMapKeyExtension) CreateMapKeyDecoder(typ reflect2.Type) jsoniter.ValDecoder {
+	if typ.Kind() == reflect.Int {
+		return &funcDecoder{
+			fun: func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+				i, err := strconv.Atoi(iter.ReadString())
+				if err != nil {
+					iter.ReportError("read map key", err.Error())
+					return
+				}
+				i--
+				*(*int)(ptr) = i
+			},
+		}
+	}
+	return nil
+}
+
+type funcDecoder struct {
+	fun jsoniter.DecoderFunc
+}
+
+func (decoder *funcDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	decoder.fun(ptr, iter)
+}
+
+type funcEncoder struct {
+	fun         jsoniter.EncoderFunc
+	isEmptyFunc func(ptr unsafe.Pointer) bool
+}
+
+func (encoder *funcEncoder) Encode(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+	encoder.fun(ptr, stream)
+}
+
+func (encoder *funcEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+	if encoder.isEmptyFunc == nil {
+		return false
+	}
+	return encoder.isEmptyFunc(ptr)
+}
diff --git a/vendor/github.com/json-iterator/go/extra/binary_as_string_codec.go b/vendor/github.com/json-iterator/go/extra/binary_as_string_codec.go
new file mode 100644
index 000000000..543895bef
--- /dev/null
+++ b/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, '"')
+}
diff --git a/vendor/github.com/json-iterator/go/extra/binary_as_string_codec_test.go b/vendor/github.com/json-iterator/go/extra/binary_as_string_codec_test.go
new file mode 100644
index 000000000..a00479e6c
--- /dev/null
+++ b/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)
+	})
+}
diff --git a/vendor/github.com/json-iterator/go/extra/fuzzy_decoder.go b/vendor/github.com/json-iterator/go/extra/fuzzy_decoder.go
new file mode 100644
index 000000000..8ff1cc3db
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/extra/fuzzy_decoder.go
@@ -0,0 +1,291 @@
+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")
+	}
+	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")
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/extra/fuzzy_decoder_test.go b/vendor/github.com/json-iterator/go/extra/fuzzy_decoder_test.go
new file mode 100644
index 000000000..3490e3a23
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/extra/fuzzy_decoder_test.go
@@ -0,0 +1,391 @@
+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)
+
+	// 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)
+}
diff --git a/vendor/github.com/json-iterator/go/extra/naming_strategy.go b/vendor/github.com/json-iterator/go/extra/naming_strategy.go
new file mode 100644
index 000000000..671e4951b
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/extra/naming_strategy.go
@@ -0,0 +1,41 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"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 {
+		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)
+}
diff --git a/vendor/github.com/json-iterator/go/extra/naming_strategy_test.go b/vendor/github.com/json-iterator/go/extra/naming_strategy_test.go
new file mode 100644
index 000000000..d15608126
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/extra/naming_strategy_test.go
@@ -0,0 +1,23 @@
+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))
+}
diff --git a/vendor/github.com/json-iterator/go/extra/privat_fields.go b/vendor/github.com/json-iterator/go/extra/privat_fields.go
new file mode 100644
index 000000000..ac7096ff4
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/extra/privat_fields.go
@@ -0,0 +1,25 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"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 {
+			binding.FromNames = []string{binding.Field.Name()}
+			binding.ToNames = []string{binding.Field.Name()}
+		}
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/extra/private_fields_test.go b/vendor/github.com/json-iterator/go/extra/private_fields_test.go
new file mode 100644
index 000000000..d3bc40dac
--- /dev/null
+++ b/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)
+}
diff --git a/vendor/github.com/json-iterator/go/extra/time_as_int64_codec.go b/vendor/github.com/json-iterator/go/extra/time_as_int64_codec.go
new file mode 100644
index 000000000..9893872a0
--- /dev/null
+++ b/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())
+}
diff --git a/vendor/github.com/json-iterator/go/extra/time_as_int64_codec_test.go b/vendor/github.com/json-iterator/go/extra/time_as_int64_codec_test.go
new file mode 100644
index 000000000..b27220f18
--- /dev/null
+++ b/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())
+}
diff --git a/vendor/github.com/json-iterator/go/misc_tests/jsoniter_array_test.go b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_array_test.go
new file mode 100644
index 000000000..ef467d184
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_array_test.go
@@ -0,0 +1,214 @@
+package misc_tests
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func Test_empty_array(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[]`)
+	cont := iter.ReadArray()
+	should.False(cont)
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `[]`)
+	iter.ReadArrayCB(func(iter *jsoniter.Iterator) bool {
+		should.FailNow("should not call")
+		return true
+	})
+}
+
+func Test_one_element(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[1]`)
+	should.True(iter.ReadArray())
+	should.Equal(1, iter.ReadInt())
+	should.False(iter.ReadArray())
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `[1]`)
+	iter.ReadArrayCB(func(iter *jsoniter.Iterator) bool {
+		should.Equal(1, iter.ReadInt())
+		return true
+	})
+}
+
+func Test_two_elements(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[1,2]`)
+	should.True(iter.ReadArray())
+	should.Equal(int64(1), iter.ReadInt64())
+	should.True(iter.ReadArray())
+	should.Equal(int64(2), iter.ReadInt64())
+	should.False(iter.ReadArray())
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `[1,2]`)
+	should.Equal([]interface{}{float64(1), float64(2)}, iter.Read())
+}
+
+func Test_whitespace_in_head(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, ` [1]`)
+	cont := iter.ReadArray()
+	if cont != true {
+		t.FailNow()
+	}
+	if iter.ReadUint64() != 1 {
+		t.FailNow()
+	}
+}
+
+func Test_whitespace_after_array_start(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[ 1]`)
+	cont := iter.ReadArray()
+	if cont != true {
+		t.FailNow()
+	}
+	if iter.ReadUint64() != 1 {
+		t.FailNow()
+	}
+}
+
+func Test_whitespace_before_array_end(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[1 ]`)
+	cont := iter.ReadArray()
+	if cont != true {
+		t.FailNow()
+	}
+	if iter.ReadUint64() != 1 {
+		t.FailNow()
+	}
+	cont = iter.ReadArray()
+	if cont != false {
+		t.FailNow()
+	}
+}
+
+func Test_whitespace_before_comma(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[1 ,2]`)
+	cont := iter.ReadArray()
+	if cont != true {
+		t.FailNow()
+	}
+	if iter.ReadUint64() != 1 {
+		t.FailNow()
+	}
+	cont = iter.ReadArray()
+	if cont != true {
+		t.FailNow()
+	}
+	if iter.ReadUint64() != 2 {
+		t.FailNow()
+	}
+	cont = iter.ReadArray()
+	if cont != false {
+		t.FailNow()
+	}
+}
+
+func Test_write_array(t *testing.T) {
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.Config{IndentionStep: 2}.Froze(), buf, 4096)
+	stream.WriteArrayStart()
+	stream.WriteInt(1)
+	stream.WriteMore()
+	stream.WriteInt(2)
+	stream.WriteArrayEnd()
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("[\n  1,\n  2\n]", buf.String())
+}
+
+func Test_write_val_array(t *testing.T) {
+	should := require.New(t)
+	val := []int{1, 2, 3}
+	str, err := jsoniter.MarshalToString(&val)
+	should.Nil(err)
+	should.Equal("[1,2,3]", str)
+}
+
+func Test_write_val_empty_array(t *testing.T) {
+	should := require.New(t)
+	val := []int{}
+	str, err := jsoniter.MarshalToString(val)
+	should.Nil(err)
+	should.Equal("[]", str)
+}
+
+func Test_write_array_of_interface_in_struct(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct {
+		Field  []interface{}
+		Field2 string
+	}
+	val := TestObject{[]interface{}{1, 2}, ""}
+	str, err := jsoniter.MarshalToString(val)
+	should.Nil(err)
+	should.Contains(str, `"Field":[1,2]`)
+	should.Contains(str, `"Field2":""`)
+}
+
+func Test_encode_byte_array(t *testing.T) {
+	should := require.New(t)
+	bytes, err := json.Marshal([]byte{1, 2, 3})
+	should.Nil(err)
+	should.Equal(`"AQID"`, string(bytes))
+	bytes, err = jsoniter.Marshal([]byte{1, 2, 3})
+	should.Nil(err)
+	should.Equal(`"AQID"`, string(bytes))
+}
+
+func Test_decode_byte_array_from_base64(t *testing.T) {
+	should := require.New(t)
+	data := []byte{}
+	err := json.Unmarshal([]byte(`"AQID"`), &data)
+	should.Nil(err)
+	should.Equal([]byte{1, 2, 3}, data)
+	err = jsoniter.Unmarshal([]byte(`"AQID"`), &data)
+	should.Nil(err)
+	should.Equal([]byte{1, 2, 3}, data)
+}
+
+func Test_decode_byte_array_from_array(t *testing.T) {
+	should := require.New(t)
+	data := []byte{}
+	err := json.Unmarshal([]byte(`[1,2,3]`), &data)
+	should.Nil(err)
+	should.Equal([]byte{1, 2, 3}, data)
+	err = jsoniter.Unmarshal([]byte(`[1,2,3]`), &data)
+	should.Nil(err)
+	should.Equal([]byte{1, 2, 3}, data)
+}
+
+func Test_decode_slice(t *testing.T) {
+	should := require.New(t)
+	slice := make([]string, 0, 5)
+	jsoniter.UnmarshalFromString(`["hello", "world"]`, &slice)
+	should.Equal([]string{"hello", "world"}, slice)
+}
+
+func Test_decode_large_slice(t *testing.T) {
+	should := require.New(t)
+	slice := make([]int, 0, 1)
+	jsoniter.UnmarshalFromString(`[1,2,3,4,5,6,7,8,9]`, &slice)
+	should.Equal([]int{1, 2, 3, 4, 5, 6, 7, 8, 9}, slice)
+}
+
+func Benchmark_jsoniter_array(b *testing.B) {
+	b.ReportAllocs()
+	input := []byte(`[1,2,3,4,5,6,7,8,9]`)
+	iter := jsoniter.ParseBytes(jsoniter.ConfigDefault, input)
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		iter.ResetBytes(input)
+		for iter.ReadArray() {
+			iter.ReadUint64()
+		}
+	}
+}
+
+func Benchmark_json_array(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		result := []interface{}{}
+		json.Unmarshal([]byte(`[1,2,3]`), &result)
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/misc_tests/jsoniter_bool_test.go b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_bool_test.go
new file mode 100644
index 000000000..8353d19b4
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_bool_test.go
@@ -0,0 +1,47 @@
+package misc_tests
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_true(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `true`)
+	should.True(iter.ReadBool())
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `true`)
+	should.Equal(true, iter.Read())
+}
+
+func Test_false(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `false`)
+	should.False(iter.ReadBool())
+}
+
+func Test_write_true_false(t *testing.T) {
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+	stream.WriteTrue()
+	stream.WriteFalse()
+	stream.WriteBool(false)
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("truefalsefalse", buf.String())
+}
+
+func Test_write_val_bool(t *testing.T) {
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+	stream.WriteVal(true)
+	should.Equal(stream.Buffered(), 4)
+	stream.Flush()
+	should.Equal(stream.Buffered(), 0)
+	should.Nil(stream.Error)
+	should.Equal("true", buf.String())
+}
diff --git a/vendor/github.com/json-iterator/go/misc_tests/jsoniter_float_test.go b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_float_test.go
new file mode 100644
index 000000000..de7bc965e
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_float_test.go
@@ -0,0 +1,95 @@
+package misc_tests
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_read_big_float(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `12.3`)
+	val := iter.ReadBigFloat()
+	val64, _ := val.Float64()
+	should.Equal(12.3, val64)
+}
+
+func Test_read_big_int(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `92233720368547758079223372036854775807`)
+	val := iter.ReadBigInt()
+	should.NotNil(val)
+	should.Equal(`92233720368547758079223372036854775807`, val.String())
+}
+
+func Test_read_float_as_interface(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `12.3`)
+	should.Equal(float64(12.3), iter.Read())
+}
+
+func Test_wrap_float(t *testing.T) {
+	should := require.New(t)
+	str, err := jsoniter.MarshalToString(jsoniter.WrapFloat64(12.3))
+	should.Nil(err)
+	should.Equal("12.3", str)
+}
+
+func Test_read_float64_cursor(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, "[1.23456789\n,2,3]")
+	should.True(iter.ReadArray())
+	should.Equal(1.23456789, iter.Read())
+	should.True(iter.ReadArray())
+	should.Equal(float64(2), iter.Read())
+}
+
+func Test_read_float_scientific(t *testing.T) {
+	should := require.New(t)
+	var obj interface{}
+	should.NoError(jsoniter.UnmarshalFromString(`1e1`, &obj))
+	should.Equal(float64(10), obj)
+	should.NoError(json.Unmarshal([]byte(`1e1`), &obj))
+	should.Equal(float64(10), obj)
+	should.NoError(jsoniter.UnmarshalFromString(`1.0e1`, &obj))
+	should.Equal(float64(10), obj)
+	should.NoError(json.Unmarshal([]byte(`1.0e1`), &obj))
+	should.Equal(float64(10), obj)
+}
+
+func Test_lossy_float_marshal(t *testing.T) {
+	should := require.New(t)
+	api := jsoniter.Config{MarshalFloatWith6Digits: true}.Froze()
+	output, err := api.MarshalToString(float64(0.1234567))
+	should.Nil(err)
+	should.Equal("0.123457", output)
+	output, err = api.MarshalToString(float32(0.1234567))
+	should.Nil(err)
+	should.Equal("0.123457", output)
+}
+
+func Test_read_number(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `92233720368547758079223372036854775807`)
+	val := iter.ReadNumber()
+	should.Equal(`92233720368547758079223372036854775807`, string(val))
+}
+
+func Benchmark_jsoniter_float(b *testing.B) {
+	b.ReportAllocs()
+	input := []byte(`1.1123,`)
+	iter := jsoniter.NewIterator(jsoniter.ConfigDefault)
+	for n := 0; n < b.N; n++ {
+		iter.ResetBytes(input)
+		iter.ReadFloat64()
+	}
+}
+
+func Benchmark_json_float(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		result := float64(0)
+		json.Unmarshal([]byte(`1.1`), &result)
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/misc_tests/jsoniter_int_test.go b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_int_test.go
new file mode 100644
index 000000000..a730f6986
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_int_test.go
@@ -0,0 +1,101 @@
+// +build go1.8
+
+package misc_tests
+
+import (
+	"bytes"
+	"encoding/json"
+	"io/ioutil"
+	"strconv"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_read_uint64_invalid(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, ",")
+	iter.ReadUint64()
+	should.NotNil(iter.Error)
+}
+
+func Test_read_int32_array(t *testing.T) {
+	should := require.New(t)
+	input := `[123,456,789]`
+	val := make([]int32, 0)
+	jsoniter.UnmarshalFromString(input, &val)
+	should.Equal(3, len(val))
+}
+
+func Test_read_int64_array(t *testing.T) {
+	should := require.New(t)
+	input := `[123,456,789]`
+	val := make([]int64, 0)
+	jsoniter.UnmarshalFromString(input, &val)
+	should.Equal(3, len(val))
+}
+
+func Test_wrap_int(t *testing.T) {
+	should := require.New(t)
+	str, err := jsoniter.MarshalToString(jsoniter.WrapInt64(100))
+	should.Nil(err)
+	should.Equal("100", str)
+}
+
+func Test_write_val_int(t *testing.T) {
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+	stream.WriteVal(1001)
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("1001", buf.String())
+}
+
+func Test_write_val_int_ptr(t *testing.T) {
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+	val := 1001
+	stream.WriteVal(&val)
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("1001", buf.String())
+}
+
+func Test_float_as_int(t *testing.T) {
+	should := require.New(t)
+	var i int
+	should.NotNil(jsoniter.Unmarshal([]byte(`1.1`), &i))
+}
+
+func Benchmark_jsoniter_encode_int(b *testing.B) {
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, ioutil.Discard, 64)
+	for n := 0; n < b.N; n++ {
+		stream.Reset(nil)
+		stream.WriteUint64(0xffffffff)
+	}
+}
+
+func Benchmark_itoa(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		strconv.FormatInt(0xffffffff, 10)
+	}
+}
+
+func Benchmark_jsoniter_int(b *testing.B) {
+	iter := jsoniter.NewIterator(jsoniter.ConfigDefault)
+	input := []byte(`100`)
+	for n := 0; n < b.N; n++ {
+		iter.ResetBytes(input)
+		iter.ReadInt64()
+	}
+}
+
+func Benchmark_json_int(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		result := int64(0)
+		json.Unmarshal([]byte(`-100`), &result)
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/misc_tests/jsoniter_interface_test.go b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_interface_test.go
new file mode 100644
index 000000000..38af1e5c8
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_interface_test.go
@@ -0,0 +1,178 @@
+package misc_tests
+
+import (
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"io"
+	"testing"
+)
+
+func Test_nil_non_empty_interface(t *testing.T) {
+	type TestObject struct {
+		Field []io.Closer
+	}
+	should := require.New(t)
+	obj := TestObject{}
+	b := []byte(`{"Field":["AAA"]}`)
+	should.NotNil(json.Unmarshal(b, &obj))
+	should.NotNil(jsoniter.Unmarshal(b, &obj))
+}
+
+func Test_nil_out_null_interface(t *testing.T) {
+	type TestData struct {
+		Field interface{} `json:"field"`
+	}
+	should := require.New(t)
+
+	var boolVar bool
+	obj := TestData{
+		Field: &boolVar,
+	}
+
+	data1 := []byte(`{"field": true}`)
+
+	err := jsoniter.Unmarshal(data1, &obj)
+	should.NoError(err)
+	should.Equal(true, *(obj.Field.(*bool)))
+
+	data2 := []byte(`{"field": null}`)
+
+	err = jsoniter.Unmarshal(data2, &obj)
+	should.NoError(err)
+	should.Nil(obj.Field)
+
+	// Checking stdlib behavior matches.
+	obj2 := TestData{
+		Field: &boolVar,
+	}
+
+	err = json.Unmarshal(data1, &obj2)
+	should.NoError(err)
+	should.Equal(true, *(obj2.Field.(*bool)))
+
+	err = json.Unmarshal(data2, &obj2)
+	should.NoError(err)
+	should.Equal(nil, obj2.Field)
+}
+
+func Test_overwrite_interface_ptr_value_with_nil(t *testing.T) {
+	type Wrapper struct {
+		Payload interface{} `json:"payload,omitempty"`
+	}
+	type Payload struct {
+		Value int `json:"val,omitempty"`
+	}
+
+	should := require.New(t)
+
+	payload := &Payload{}
+	wrapper := &Wrapper{
+		Payload: &payload,
+	}
+
+	err := json.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.NoError(err)
+	should.Equal(&payload, wrapper.Payload)
+	should.Equal(42, (*(wrapper.Payload.(**Payload))).Value)
+
+	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.NoError(err)
+	should.Equal(&payload, wrapper.Payload)
+	should.Equal((*Payload)(nil), payload)
+
+	payload = &Payload{}
+	wrapper = &Wrapper{
+		Payload: &payload,
+	}
+
+	err = jsoniter.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.Equal(nil, err)
+	should.Equal(&payload, wrapper.Payload)
+	should.Equal(42, (*(wrapper.Payload.(**Payload))).Value)
+
+	err = jsoniter.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.NoError(err)
+	should.Equal(&payload, wrapper.Payload)
+	should.Equal((*Payload)(nil), payload)
+}
+
+func Test_overwrite_interface_value_with_nil(t *testing.T) {
+	type Wrapper struct {
+		Payload interface{} `json:"payload,omitempty"`
+	}
+	type Payload struct {
+		Value int `json:"val,omitempty"`
+	}
+
+	should := require.New(t)
+
+	payload := &Payload{}
+	wrapper := &Wrapper{
+		Payload: payload,
+	}
+
+	err := json.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.NoError(err)
+	should.Equal(42, (*(wrapper.Payload.(*Payload))).Value)
+
+	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.NoError(err)
+	should.Equal(nil, wrapper.Payload)
+	should.Equal(42, payload.Value)
+
+	payload = &Payload{}
+	wrapper = &Wrapper{
+		Payload: payload,
+	}
+
+	err = jsoniter.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.Equal(nil, err)
+	should.Equal(42, (*(wrapper.Payload.(*Payload))).Value)
+
+	err = jsoniter.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.Equal(nil, err)
+	should.Equal(nil, wrapper.Payload)
+	should.Equal(42, payload.Value)
+}
+
+func Test_unmarshal_into_nil(t *testing.T) {
+	type Payload struct {
+		Value int `json:"val,omitempty"`
+	}
+	type Wrapper struct {
+		Payload interface{} `json:"payload,omitempty"`
+	}
+
+	should := require.New(t)
+
+	var payload *Payload
+	wrapper := &Wrapper{
+		Payload: payload,
+	}
+
+	err := json.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.NoError(err)
+	should.NotNil(wrapper.Payload)
+	should.Nil(payload)
+
+	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.NoError(err)
+	should.Nil(wrapper.Payload)
+	should.Nil(payload)
+
+	payload = nil
+	wrapper = &Wrapper{
+		Payload: payload,
+	}
+
+	err = jsoniter.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.NoError(err)
+	should.NotNil(wrapper.Payload)
+	should.Nil(payload)
+
+	err = jsoniter.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.NoError(err)
+	should.Nil(wrapper.Payload)
+	should.Nil(payload)
+}
diff --git a/vendor/github.com/json-iterator/go/misc_tests/jsoniter_iterator_test.go b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_iterator_test.go
new file mode 100644
index 000000000..d75d01a51
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_iterator_test.go
@@ -0,0 +1,67 @@
+package misc_tests
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_bad_case(t *testing.T) {
+	// field := *(*string)(unsafe.Pointer(&str))
+	// caused this issue
+	iter := jsoniter.Parse(jsoniter.ConfigDefault, bytes.NewBufferString(`{"Info":{"InfoHash":"4lzhP/fwlVLRgalC31YbfBSiqwo=","InfoHashstr":"E25CE13FF7F09552D181A942DF561B7C14A2AB0A","AnnounceList":["http://tracker.nwps.ws:6969/announce","http://tracker.nwps.ws:6969/announce","http://tracker.winglai.com/announce","http://fr33dom.h33t.com:3310/announce","http://exodus.desync.com:6969/announce","http://torrent.gresille.org/announce","http://tracker.trackerfix.com/announce","udp://tracker.btzoo.eu:80/announce","http://tracker.windsormetalbattery.com/announce","udp://10.rarbg.me:80/announce","udp://ipv4.tracker.harry.lu:80/announce","udp://tracker.ilibr.org:6969/announce","udp://tracker.zond.org:80/announce","http://torrent-tracker.ru/announce.php","http://bigfoot1942.sektori.org:6969/announce","http://tracker.best-torrents.net:6969/announce","http://announce.torrentsmd.com:6969/announce","udp://tracker.token.ro:80/announce","udp://tracker.coppersurfer.tk:80","http://tracker.thepiratebay.org/announce","udp://9.rarbg.com:2710/announce","udp://open.demonii.com:1337/announce","udp://tracker.ccc.de:80/announce","udp://tracker.istole.it:80/announce","udp://tracker.publicbt.com:80/announce","udp://tracker.openbittorrent.com:80/announce","udp://tracker.istole.it:80/announce","http://tracker.istole.it/announce","udp://tracker.publicbt.com:80/announce","http://tracker.publicbt.com/announce","udp://open.demonii.com:1337/announce"],"Length":2434793890,"PieceSize":524288,"PieceNum":4645},"InfoHashstr":"E25CE13FF7F09552D181A942DF561B7C14A2AB0A","SectionNum":32,"PieceNum":4645,"PieceSize":16384,"Finished":false,"SparseSize":104857600,"Bit":[{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="},{"Size":4645,"EndIndex":580,"EndMask":248,"Good":0,"Flush":false,"Bit":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="}]}`), 4096)
+	count := 0
+	for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
+		if field == "Bit" {
+			for iter.ReadArray() {
+				for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
+					if field == "Bit" {
+						iter.ReadStringAsSlice()
+					} else {
+						if field != "Size" && field != "EndIndex" && field != "EndMask" && field != "Good" && field != "Flush" {
+							t.Fatal(field)
+						}
+						iter.Skip()
+					}
+				}
+				count++
+			}
+		} else {
+			iter.Skip()
+		}
+	}
+	if count != 32 {
+		t.Fatal(count)
+	}
+}
+
+func Test_iterator_use_number(t *testing.T) {
+	// Test UseNumber with iterator Read()
+	inputs := []string{`2147483647`, `-2147483648`}
+	for _, input := range inputs {
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.ParseString(jsoniter.Config{UseNumber: true}.Froze(), input)
+			expected := json.Number(input)
+			should.Equal(expected, iter.Read())
+		})
+	}
+}
+
+func Test_iterator_without_number(t *testing.T) {
+	inputs := []string{`2147483647`, `-2147483648`}
+	for _, input := range inputs {
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.ParseString(jsoniter.ConfigDefault, input)
+			expected, err := strconv.ParseInt(input, 10, 32)
+			should.Nil(err)
+			should.Equal(float64(expected), iter.Read())
+		})
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/misc_tests/jsoniter_map_test.go b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_map_test.go
new file mode 100644
index 000000000..b0dde94cf
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_map_test.go
@@ -0,0 +1,44 @@
+package misc_tests
+
+import (
+	"encoding/json"
+	"math/big"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"strings"
+)
+
+func Test_decode_TextMarshaler_key_map(t *testing.T) {
+	should := require.New(t)
+	var val map[*big.Float]string
+	should.Nil(jsoniter.UnmarshalFromString(`{"1":"2"}`, &val))
+	str, err := jsoniter.MarshalToString(val)
+	should.Nil(err)
+	should.Equal(`{"1":"2"}`, str)
+}
+
+func Test_read_map_with_reader(t *testing.T) {
+	should := require.New(t)
+	input := `{"branch":"beta","change_log":"add the rows{10}","channel":"fros","create_time":"2017-06-13 16:39:08","firmware_list":"","md5":"80dee2bf7305bcf179582088e29fd7b9","note":{"CoreServices":{"md5":"d26975c0a8c7369f70ed699f2855cc2e","package_name":"CoreServices","version_code":"76","version_name":"1.0.76"},"FrDaemon":{"md5":"6b1f0626673200bc2157422cd2103f5d","package_name":"FrDaemon","version_code":"390","version_name":"1.0.390"},"FrGallery":{"md5":"90d767f0f31bcd3c1d27281ec979ba65","package_name":"FrGallery","version_code":"349","version_name":"1.0.349"},"FrLocal":{"md5":"f15a215b2c070a80a01f07bde4f219eb","package_name":"FrLocal","version_code":"791","version_name":"1.0.791"}},"pack_region_urls":{"CN":"https://s3.cn-north-1.amazonaws.com.cn/xxx-os/ttt_xxx_android_1.5.3.344.393.zip","default":"http://192.168.8.78/ttt_xxx_android_1.5.3.344.393.zip","local":"http://192.168.8.78/ttt_xxx_android_1.5.3.344.393.zip"},"pack_version":"1.5.3.344.393","pack_version_code":393,"region":"all","release_flag":0,"revision":62,"size":38966875,"status":3}`
+	reader := strings.NewReader(input)
+	decoder := jsoniter.ConfigCompatibleWithStandardLibrary.NewDecoder(reader)
+	m1 := map[string]interface{}{}
+	should.Nil(decoder.Decode(&m1))
+	m2 := map[string]interface{}{}
+	should.Nil(json.Unmarshal([]byte(input), &m2))
+	should.Equal(m2, m1)
+	should.Equal("1.0.76", m1["note"].(map[string]interface{})["CoreServices"].(map[string]interface{})["version_name"])
+}
+
+func Test_map_eface_of_eface(t *testing.T) {
+	should := require.New(t)
+	json := jsoniter.ConfigCompatibleWithStandardLibrary
+	output, err := json.MarshalToString(map[interface{}]interface{}{
+		"1": 2,
+		3:   "4",
+	})
+	should.NoError(err)
+	should.Equal(`{"1":2,"3":"4"}`, output)
+}
diff --git a/vendor/github.com/json-iterator/go/misc_tests/jsoniter_nested_test.go b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_nested_test.go
new file mode 100644
index 000000000..1e4994a13
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_nested_test.go
@@ -0,0 +1,89 @@
+package misc_tests
+
+import (
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"reflect"
+	"testing"
+)
+
+type Level1 struct {
+	Hello []Level2
+}
+
+type Level2 struct {
+	World string
+}
+
+func Test_nested(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
+	l1 := Level1{}
+	for l1Field := iter.ReadObject(); l1Field != ""; l1Field = iter.ReadObject() {
+		switch l1Field {
+		case "hello":
+			l2Array := []Level2{}
+			for iter.ReadArray() {
+				l2 := Level2{}
+				for l2Field := iter.ReadObject(); l2Field != ""; l2Field = iter.ReadObject() {
+					switch l2Field {
+					case "world":
+						l2.World = iter.ReadString()
+					default:
+						iter.ReportError("bind l2", "unexpected field: "+l2Field)
+					}
+				}
+				l2Array = append(l2Array, l2)
+			}
+			l1.Hello = l2Array
+		default:
+			iter.ReportError("bind l1", "unexpected field: "+l1Field)
+		}
+	}
+	if !reflect.DeepEqual(l1, Level1{
+		Hello: []Level2{
+			{World: "value1"},
+			{World: "value2"},
+		},
+	}) {
+		t.Fatal(l1)
+	}
+}
+
+func Benchmark_jsoniter_nested(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		iter := jsoniter.ParseString(jsoniter.ConfigDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
+		l1 := Level1{}
+		for l1Field := iter.ReadObject(); l1Field != ""; l1Field = iter.ReadObject() {
+			switch l1Field {
+			case "hello":
+				l1.Hello = readLevel1Hello(iter)
+			default:
+				iter.Skip()
+			}
+		}
+	}
+}
+
+func readLevel1Hello(iter *jsoniter.Iterator) []Level2 {
+	l2Array := make([]Level2, 0, 2)
+	for iter.ReadArray() {
+		l2 := Level2{}
+		for l2Field := iter.ReadObject(); l2Field != ""; l2Field = iter.ReadObject() {
+			switch l2Field {
+			case "world":
+				l2.World = iter.ReadString()
+			default:
+				iter.Skip()
+			}
+		}
+		l2Array = append(l2Array, l2)
+	}
+	return l2Array
+}
+
+func Benchmark_json_nested(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		l1 := Level1{}
+		json.Unmarshal([]byte(`{"hello": [{"world": "value1"}, {"world": "value2"}]}`), &l1)
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/misc_tests/jsoniter_null_test.go b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_null_test.go
new file mode 100644
index 000000000..4fd2a2c13
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_null_test.go
@@ -0,0 +1,81 @@
+package misc_tests
+
+import (
+	"bytes"
+	"io"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_read_null(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `null`)
+	should.True(iter.ReadNil())
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `null`)
+	should.Nil(iter.Read())
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `navy`)
+	iter.Read()
+	should.True(iter.Error != nil && iter.Error != io.EOF)
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `navy`)
+	iter.ReadNil()
+	should.True(iter.Error != nil && iter.Error != io.EOF)
+}
+
+func Test_write_null(t *testing.T) {
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+	stream.WriteNil()
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("null", buf.String())
+}
+
+func Test_decode_null_object_field(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[null,"a"]`)
+	iter.ReadArray()
+	if iter.ReadObject() != "" {
+		t.FailNow()
+	}
+	iter.ReadArray()
+	if iter.ReadString() != "a" {
+		t.FailNow()
+	}
+	type TestObject struct {
+		Field string
+	}
+	objs := []TestObject{}
+	should.Nil(jsoniter.UnmarshalFromString("[null]", &objs))
+	should.Len(objs, 1)
+}
+
+func Test_decode_null_array_element(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[null,"a"]`)
+	should.True(iter.ReadArray())
+	should.True(iter.ReadNil())
+	should.True(iter.ReadArray())
+	should.Equal("a", iter.ReadString())
+}
+
+func Test_decode_null_string(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[null,"a"]`)
+	should.True(iter.ReadArray())
+	should.Equal("", iter.ReadString())
+	should.True(iter.ReadArray())
+	should.Equal("a", iter.ReadString())
+}
+
+func Test_decode_null_skip(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[null,"a"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "a" {
+		t.FailNow()
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/misc_tests/jsoniter_object_test.go b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_object_test.go
new file mode 100644
index 000000000..e44b66f05
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_object_test.go
@@ -0,0 +1,149 @@
+package misc_tests
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"strings"
+	"time"
+)
+
+func Test_empty_object(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `{}`)
+	field := iter.ReadObject()
+	should.Equal("", field)
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `{}`)
+	iter.ReadObjectCB(func(iter *jsoniter.Iterator, field string) bool {
+		should.FailNow("should not call")
+		return true
+	})
+}
+
+func Test_one_field(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `{"a": "stream"}`)
+	field := iter.ReadObject()
+	should.Equal("a", field)
+	value := iter.ReadString()
+	should.Equal("stream", value)
+	field = iter.ReadObject()
+	should.Equal("", field)
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `{"a": "stream"}`)
+	should.True(iter.ReadObjectCB(func(iter *jsoniter.Iterator, field string) bool {
+		should.Equal("a", field)
+		iter.Skip()
+		return true
+	}))
+
+}
+
+func Test_two_field(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `{ "a": "stream" , "c": "d" }`)
+	field := iter.ReadObject()
+	should.Equal("a", field)
+	value := iter.ReadString()
+	should.Equal("stream", value)
+	field = iter.ReadObject()
+	should.Equal("c", field)
+	value = iter.ReadString()
+	should.Equal("d", value)
+	field = iter.ReadObject()
+	should.Equal("", field)
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `{"field1": "1", "field2": 2}`)
+	for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
+		switch field {
+		case "field1":
+			iter.ReadString()
+		case "field2":
+			iter.ReadInt64()
+		default:
+			iter.ReportError("bind object", "unexpected field")
+		}
+	}
+}
+
+func Test_write_object(t *testing.T) {
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.Config{IndentionStep: 2}.Froze(), buf, 4096)
+	stream.WriteObjectStart()
+	stream.WriteObjectField("hello")
+	stream.WriteInt(1)
+	stream.WriteMore()
+	stream.WriteObjectField("world")
+	stream.WriteInt(2)
+	stream.WriteObjectEnd()
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("{\n  \"hello\": 1,\n  \"world\": 2\n}", buf.String())
+}
+
+func Test_reader_and_load_more(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct {
+		CreatedAt time.Time
+	}
+	reader := strings.NewReader(`
+{
+	"agency": null,
+	"candidateId": 0,
+	"candidate": "Blah Blah",
+	"bookingId": 0,
+	"shiftId": 1,
+	"shiftTypeId": 0,
+	"shift": "Standard",
+	"bonus": 0,
+	"bonusNI": 0,
+	"days": [],
+	"totalHours": 27,
+	"expenses": [],
+	"weekEndingDateSystem": "2016-10-09",
+	"weekEndingDateClient": "2016-10-09",
+	"submittedAt": null,
+	"submittedById": null,
+	"approvedAt": "2016-10-10T18:38:04Z",
+	"approvedById": 0,
+	"authorisedAt": "2016-10-10T18:38:04Z",
+	"authorisedById": 0,
+	"invoicedAt": "2016-10-10T20:00:00Z",
+	"revokedAt": null,
+	"revokedById": null,
+	"revokeReason": null,
+	"rejectedAt": null,
+	"rejectedById": null,
+	"rejectReasonCode": null,
+	"rejectReason": null,
+	"createdAt": "2016-10-03T00:00:00Z",
+	"updatedAt": "2016-11-09T10:26:13Z",
+	"updatedById": null,
+	"overrides": [],
+	"bookingApproverId": null,
+	"bookingApprover": null,
+	"status": "approved"
+}
+	`)
+	decoder := jsoniter.ConfigCompatibleWithStandardLibrary.NewDecoder(reader)
+	obj := TestObject{}
+	should.Nil(decoder.Decode(&obj))
+}
+
+func Test_unmarshal_into_existing_value(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct {
+		Field1 int
+		Field2 interface{}
+	}
+	var obj TestObject
+	m := map[string]interface{}{}
+	obj.Field2 = &m
+	cfg := jsoniter.Config{UseNumber: true}.Froze()
+	err := cfg.Unmarshal([]byte(`{"Field1":1,"Field2":{"k":"v"}}`), &obj)
+	should.NoError(err)
+	should.Equal(map[string]interface{}{
+		"k": "v",
+	}, m)
+}
diff --git a/vendor/github.com/json-iterator/go/misc_tests/jsoniter_raw_message_test.go b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_raw_message_test.go
new file mode 100644
index 000000000..9af7cd73b
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/misc_tests/jsoniter_raw_message_test.go
@@ -0,0 +1,68 @@
+package misc_tests
+
+import (
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"strings"
+	"testing"
+)
+
+func Test_jsoniter_RawMessage(t *testing.T) {
+	should := require.New(t)
+	var data jsoniter.RawMessage
+	should.Nil(jsoniter.Unmarshal([]byte(`[1,2,3]`), &data))
+	should.Equal(`[1,2,3]`, string(data))
+	str, err := jsoniter.MarshalToString(data)
+	should.Nil(err)
+	should.Equal(`[1,2,3]`, str)
+}
+
+func Test_encode_map_of_jsoniter_raw_message(t *testing.T) {
+	should := require.New(t)
+	type RawMap map[string]*jsoniter.RawMessage
+	value := jsoniter.RawMessage("[]")
+	rawMap := RawMap{"hello": &value}
+	output, err := jsoniter.MarshalToString(rawMap)
+	should.Nil(err)
+	should.Equal(`{"hello":[]}`, output)
+}
+
+func Test_marshal_invalid_json_raw_message(t *testing.T) {
+	type A struct {
+		Raw json.RawMessage `json:"raw"`
+	}
+	message := []byte(`{}`)
+
+	a := A{}
+	should := require.New(t)
+	should.Nil(jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(message, &a))
+	aout, aouterr := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(&a)
+	should.Equal(`{"raw":null}`, string(aout))
+	should.Nil(aouterr)
+}
+
+func Test_raw_message_memory_not_copied_issue(t *testing.T) {
+	jsonStream := `{"name":"xxxxx","bundle_id":"com.zonst.majiang","app_platform":"ios","app_category":"100103", "budget_day":1000,"bidding_min":1,"bidding_max":2,"bidding_type":"CPM", "freq":{"open":true,"type":"day","num":100},"speed":1, "targeting":{"vendor":{"open":true,"list":["zonst"]}, "geo_code":{"open":true,"list":["156110100"]},"app_category":{"open":true,"list":["100101"]}, "day_parting":{"open":true,"list":["100409","100410"]},"device_type":{"open":true,"list":["ipad"]}, "os_version":{"open":true,"list":[10]},"carrier":{"open":true,"list":["mobile"]}, "network":{"open":true,"list":["4G"]}},"url":{"tracking_imp_url":"http://www.baidu.com", "tracking_clk_url":"http://www.baidu.com","jump_url":"http://www.baidu.com","deep_link_url":"http://www.baidu.com"}}`
+	type IteratorObject struct {
+		Name        *string              `json:"name"`
+		BundleId    *string              `json:"bundle_id"`
+		AppCategory *string              `json:"app_category"`
+		AppPlatform *string              `json:"app_platform"`
+		BudgetDay   *float32             `json:"budget_day"`
+		BiddingMax  *float32             `json:"bidding_max"`
+		BiddingMin  *float32             `json:"bidding_min"`
+		BiddingType *string              `json:"bidding_type"`
+		Freq        *jsoniter.RawMessage `json:"freq"`
+		Targeting   *jsoniter.RawMessage `json:"targeting"`
+		Url         *jsoniter.RawMessage `json:"url"`
+		Speed       *int                 `json:"speed" db:"speed"`
+	}
+
+	obj := &IteratorObject{}
+	decoder := jsoniter.NewDecoder(strings.NewReader(jsonStream))
+	err := decoder.Decode(obj)
+	should := require.New(t)
+	should.Nil(err)
+	should.Equal(`{"open":true,"type":"day","num":100}`, string(*obj.Freq))
+}
diff --git a/vendor/github.com/json-iterator/go/skip_tests/array_test.go b/vendor/github.com/json-iterator/go/skip_tests/array_test.go
new file mode 100644
index 000000000..12e42a13a
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/skip_tests/array_test.go
@@ -0,0 +1,15 @@
+package skip_tests
+
+func init() {
+	testCases = append(testCases, testCase{
+		ptr: (*[]interface{})(nil),
+		inputs: []string{
+			`[]`,             // valid
+			`[1]`,            // valid
+			`[  1, "hello"]`, // valid
+			`[abc]`,          // invalid
+			`[`,              // invalid
+			`[[]`,            // invalid
+		},
+	})
+}
diff --git a/vendor/github.com/json-iterator/go/skip_tests/float64_test.go b/vendor/github.com/json-iterator/go/skip_tests/float64_test.go
new file mode 100644
index 000000000..bc90f24f5
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/skip_tests/float64_test.go
@@ -0,0 +1,20 @@
+package skip_tests
+
+func init() {
+	testCases = append(testCases, testCase{
+		ptr: (*float64)(nil),
+		inputs: []string{
+			"+1",    // invalid
+			"-a",    // invalid
+			"-\x00", // invalid, zero byte
+			"0.1",   // valid
+			"0..1",  // invalid, more dot
+			"1e+1",  // valid
+			"1+1",   // invalid
+			"1E1",   // valid, e or E
+			"1ee1",  // invalid
+			"100a",  // invalid
+			"10.",   // invalid
+		},
+	})
+}
diff --git a/vendor/github.com/json-iterator/go/skip_tests/jsoniter_skip_test.go b/vendor/github.com/json-iterator/go/skip_tests/jsoniter_skip_test.go
new file mode 100644
index 000000000..bf054d1c3
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/skip_tests/jsoniter_skip_test.go
@@ -0,0 +1,185 @@
+package skip_tests
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_skip_number_in_array(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[-0.12, "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	should.Nil(iter.Error)
+	should.Equal("stream", iter.ReadString())
+}
+
+func Test_skip_string_in_array(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `["hello", "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	should.Nil(iter.Error)
+	should.Equal("stream", iter.ReadString())
+}
+
+func Test_skip_null(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[null , "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_true(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[true , "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_false(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[false , "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_array(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[[1, [2, [3], 4]], "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_empty_array(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[ [ ], "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_nested(t *testing.T) {
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`)
+	iter.ReadArray()
+	iter.Skip()
+	iter.ReadArray()
+	if iter.ReadString() != "stream" {
+		t.FailNow()
+	}
+}
+
+func Test_skip_and_return_bytes(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`)
+	iter.ReadArray()
+	skipped := iter.SkipAndReturnBytes()
+	should.Equal(`{"a" : [{"stream": "c"}], "d": 102 }`, string(skipped))
+}
+
+func Test_skip_and_return_bytes_with_reader(t *testing.T) {
+	should := require.New(t)
+	iter := jsoniter.Parse(jsoniter.ConfigDefault, bytes.NewBufferString(`[ {"a" : [{"stream": "c"}], "d": 102 }, "stream"]`), 4)
+	iter.ReadArray()
+	skipped := iter.SkipAndReturnBytes()
+	should.Equal(`{"a" : [{"stream": "c"}], "d": 102 }`, string(skipped))
+}
+
+func Test_skip_empty(t *testing.T) {
+	should := require.New(t)
+	should.NotNil(jsoniter.Get([]byte("")).LastError())
+}
+
+type TestResp struct {
+	Code uint64
+}
+
+func Benchmark_jsoniter_skip(b *testing.B) {
+	input := []byte(`
+{
+    "_shards":{
+        "total" : 5,
+        "successful" : 5,
+        "failed" : 0
+    },
+    "hits":{
+        "total" : 1,
+        "hits" : [
+            {
+                "_index" : "twitter",
+                "_type" : "tweet",
+                "_id" : "1",
+                "_source" : {
+                    "user" : "kimchy",
+                    "postDate" : "2009-11-15T14:12:12",
+                    "message" : "trying out Elasticsearch"
+                }
+            }
+        ]
+    },
+    "code": 200
+}`)
+	for n := 0; n < b.N; n++ {
+		result := TestResp{}
+		iter := jsoniter.ParseBytes(jsoniter.ConfigDefault, input)
+		for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
+			switch field {
+			case "code":
+				result.Code = iter.ReadUint64()
+			default:
+				iter.Skip()
+			}
+		}
+	}
+}
+
+func Benchmark_json_skip(b *testing.B) {
+	input := []byte(`
+{
+    "_shards":{
+        "total" : 5,
+        "successful" : 5,
+        "failed" : 0
+    },
+    "hits":{
+        "total" : 1,
+        "hits" : [
+            {
+                "_index" : "twitter",
+                "_type" : "tweet",
+                "_id" : "1",
+                "_source" : {
+                    "user" : "kimchy",
+                    "postDate" : "2009-11-15T14:12:12",
+                    "message" : "trying out Elasticsearch"
+                }
+            }
+        ]
+    },
+    "code": 200
+}`)
+	for n := 0; n < b.N; n++ {
+		result := TestResp{}
+		json.Unmarshal(input, &result)
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/skip_tests/skip_test.go b/vendor/github.com/json-iterator/go/skip_tests/skip_test.go
new file mode 100644
index 000000000..3295e6f4c
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/skip_tests/skip_test.go
@@ -0,0 +1,45 @@
+package skip_tests
+
+import (
+	"encoding/json"
+	"errors"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"io"
+	"reflect"
+	"testing"
+)
+
+type testCase struct {
+	ptr    interface{}
+	inputs []string
+}
+
+var testCases []testCase
+
+func Test_skip(t *testing.T) {
+	for _, testCase := range testCases {
+		valType := reflect.TypeOf(testCase.ptr).Elem()
+		for _, input := range testCase.inputs {
+			t.Run(input, func(t *testing.T) {
+				should := require.New(t)
+				ptrVal := reflect.New(valType)
+				stdErr := json.Unmarshal([]byte(input), ptrVal.Interface())
+				iter := jsoniter.ParseString(jsoniter.ConfigDefault, input)
+				iter.Skip()
+				iter.ReadNil() // trigger looking forward
+				err := iter.Error
+				if err == io.EOF {
+					err = nil
+				} else {
+					err = errors.New("remaining bytes")
+				}
+				if stdErr == nil {
+					should.Nil(err)
+				} else {
+					should.NotNil(err)
+				}
+			})
+		}
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/skip_tests/string_test.go b/vendor/github.com/json-iterator/go/skip_tests/string_test.go
new file mode 100644
index 000000000..d37777165
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/skip_tests/string_test.go
@@ -0,0 +1,17 @@
+package skip_tests
+
+func init() {
+	testCases = append(testCases, testCase{
+		ptr: (*string)(nil),
+		inputs: []string{
+			`""`,       // valid
+			`"hello"`,  // valid
+			`"`,        // invalid
+			`"\"`,      // invalid
+			`"\x00"`,   // invalid
+			"\"\x00\"", // invalid
+			"\"\t\"",   // invalid
+			`"\t"`,     // valid
+		},
+	})
+}
diff --git a/vendor/github.com/json-iterator/go/skip_tests/struct_test.go b/vendor/github.com/json-iterator/go/skip_tests/struct_test.go
new file mode 100644
index 000000000..7f1571da1
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/skip_tests/struct_test.go
@@ -0,0 +1,19 @@
+package skip_tests
+
+func init() {
+	testCases = append(testCases, testCase{
+		ptr: (*struct{})(nil),
+		inputs: []string{
+			`{}`,                         // valid
+			`{"hello":"world"}`,          // valid
+			`{hello:"world"}`,            // invalid
+			`{"hello:"world"}`,           // invalid
+			`{"hello","world"}`,          // invalid
+			`{"hello":{}`,                // invalid
+			`{"hello":{}}`,               // valid
+			`{"hello":{}}}`,              // invalid
+			`{"hello":  {  "hello": 1}}`, // valid
+			`{abc}`, // invalid
+		},
+	})
+}
diff --git a/vendor/github.com/json-iterator/go/type_tests/array_test.go b/vendor/github.com/json-iterator/go/type_tests/array_test.go
new file mode 100644
index 000000000..db27d4ac8
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/array_test.go
@@ -0,0 +1,63 @@
+package test
+
+func init() {
+	testCases = append(testCases,
+		(*[4]bool)(nil),
+		(*[4]byte)(nil),
+		(*[4]float64)(nil),
+		(*[4]int32)(nil),
+		(*[4]map[int32]string)(nil),
+		(*[4]map[string]string)(nil),
+		(*[4]*bool)(nil),
+		(*[4]*float64)(nil),
+		(*[4]*int32)(nil),
+		(*[4]*map[int32]string)(nil),
+		(*[4]*map[string]string)(nil),
+		(*[4]*[4]bool)(nil),
+		(*[4]*[4]byte)(nil),
+		(*[4]*[4]float64)(nil),
+		(*[4]*[4]int32)(nil),
+		(*[4]*[4]*string)(nil),
+		(*[4]*[4]string)(nil),
+		(*[4]*[4]uint8)(nil),
+		(*[4]*string)(nil),
+		(*[4]*struct {
+			String string
+			Int    int32
+			Float  float64
+			Struct struct {
+				X string
+			}
+			Slice [4]string
+			Map   map[string]string
+		})(nil),
+		(*[4]*uint8)(nil),
+		(*[4][4]bool)(nil),
+		(*[4][4]byte)(nil),
+		(*[4][4]float64)(nil),
+		(*[4][4]int32)(nil),
+		(*[4][4]*string)(nil),
+		(*[4][4]string)(nil),
+		(*[4][4]uint8)(nil),
+		(*[4]string)(nil),
+		(*[4]struct{})(nil),
+		(*[4]structEmpty)(nil),
+		(*[4]struct {
+			F *string
+		})(nil),
+		(*[4]struct {
+			String string
+			Int    int32
+			Float  float64
+			Struct struct {
+				X string
+			}
+			Slice [4]string
+			Map   map[string]string
+		})(nil),
+		(*[4]uint8)(nil),
+	)
+}
+
+type structEmpty struct{}
+type arrayAlis [4]stringAlias
diff --git a/vendor/github.com/json-iterator/go/type_tests/builtin_test.go b/vendor/github.com/json-iterator/go/type_tests/builtin_test.go
new file mode 100644
index 000000000..03dd34597
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/builtin_test.go
@@ -0,0 +1,69 @@
+package test
+
+func init() {
+	testCases = append(testCases,
+		(*bool)(nil),
+		(*boolAlias)(nil),
+		(*byte)(nil),
+		(*byteAlias)(nil),
+		(*float32)(nil),
+		(*float32Alias)(nil),
+		(*float64)(nil),
+		(*float64Alias)(nil),
+		(*int8)(nil),
+		(*int8Alias)(nil),
+		(*int16)(nil),
+		(*int16Alias)(nil),
+		(*int32)(nil),
+		(*int32Alias)(nil),
+		(*int64)(nil),
+		(*int64Alias)(nil),
+		(*string)(nil),
+		(*stringAlias)(nil),
+		(*uint8)(nil),
+		(*uint8Alias)(nil),
+		(*uint16)(nil),
+		(*uint16Alias)(nil),
+		(*uint32)(nil),
+		(*uint32Alias)(nil),
+		(*uintptr)(nil),
+		(*uintptrAlias)(nil),
+		(*struct {
+			A int8Alias    `json:"a"`
+			B int16Alias   `json:"stream"`
+			C int32Alias   `json:"c"`
+			D int64Alias   `json:"d"`
+			E uintAlias    `json:"e"`
+			F uint16Alias  `json:"f"`
+			G uint32Alias  `json:"g"`
+			H uint64Alias  `json:"h"`
+			I float32Alias `json:"i"`
+			J float64Alias `json:"j"`
+			K stringAlias  `json:"k"`
+			L intAlias     `json:"l"`
+			M uintAlias    `json:"m"`
+			N boolAlias    `json:"n"`
+			O uintptrAlias `json:"o"`
+		})(nil),
+	)
+}
+
+type boolAlias bool
+type byteAlias byte
+type float32Alias float32
+type float64Alias float64
+type ptrFloat64Alias *float64
+type int8Alias int8
+type int16Alias int16
+type int32Alias int32
+type ptrInt32Alias *int32
+type int64Alias int64
+type stringAlias string
+type ptrStringAlias *string
+type uint8Alias uint8
+type uint16Alias uint16
+type uint32Alias uint32
+type uintptrAlias uintptr
+type uintAlias uint
+type uint64Alias uint64
+type intAlias int
diff --git a/vendor/github.com/json-iterator/go/type_tests/map_key_test.go b/vendor/github.com/json-iterator/go/type_tests/map_key_test.go
new file mode 100644
index 000000000..e5bd21fb7
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/map_key_test.go
@@ -0,0 +1,43 @@
+package test
+
+import (
+	"encoding"
+	"strings"
+)
+
+func init() {
+	testCases = append(testCases,
+		(*map[stringKeyType]string)(nil),
+		(*map[structKeyType]string)(nil),
+	)
+}
+
+type stringKeyType string
+
+func (k stringKeyType) MarshalText() ([]byte, error) {
+	return []byte("MANUAL__" + k), nil
+}
+
+func (k *stringKeyType) UnmarshalText(text []byte) error {
+	*k = stringKeyType(strings.TrimPrefix(string(text), "MANUAL__"))
+	return nil
+}
+
+var _ encoding.TextMarshaler = stringKeyType("")
+var _ encoding.TextUnmarshaler = new(stringKeyType)
+
+type structKeyType struct {
+	X string
+}
+
+func (k structKeyType) MarshalText() ([]byte, error) {
+	return []byte("MANUAL__" + k.X), nil
+}
+
+func (k *structKeyType) UnmarshalText(text []byte) error {
+	k.X = strings.TrimPrefix(string(text), "MANUAL__")
+	return nil
+}
+
+var _ encoding.TextMarshaler = structKeyType{}
+var _ encoding.TextUnmarshaler = &structKeyType{}
diff --git a/vendor/github.com/json-iterator/go/type_tests/map_test.go b/vendor/github.com/json-iterator/go/type_tests/map_test.go
new file mode 100644
index 000000000..614f7bcd5
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/map_test.go
@@ -0,0 +1,60 @@
+package test
+
+func init() {
+	testCases = append(testCases,
+		(*map[int8]string)(nil),
+		(*map[int16]string)(nil),
+		(*map[int32]string)(nil),
+		(*map[int64]string)(nil),
+		(*map[string][4]string)(nil),
+		(*map[string]bool)(nil),
+		(*map[string]byte)(nil),
+		(*map[string]float64)(nil),
+		(*map[string]int32)(nil),
+		(*map[string]map[string]string)(nil),
+		(*map[string]*[4]string)(nil),
+		(*map[string]*bool)(nil),
+		(*map[string]*float64)(nil),
+		(*map[string]*int32)(nil),
+		(*map[string]*map[string]string)(nil),
+		(*map[string]*[]string)(nil),
+		(*map[string]*string)(nil),
+		(*map[string]*structVarious)(nil),
+		(*map[string]*uint8)(nil),
+		(*map[string][]string)(nil),
+		(*map[string]string)(nil),
+		(*map[string]stringAlias)(nil),
+		(*map[string]struct{})(nil),
+		(*map[string]structEmpty)(nil),
+		(*map[string]struct {
+			F *string
+		})(nil),
+		(*map[string]struct {
+			String string
+			Int    int32
+			Float  float64
+			Struct struct {
+				X string
+			}
+			Slice []string
+			Map   map[string]string
+		})(nil),
+		(*map[string]uint8)(nil),
+		(*map[stringAlias]string)(nil),
+		(*map[stringAlias]stringAlias)(nil),
+		(*map[uint8]string)(nil),
+		(*map[uint16]string)(nil),
+		(*map[uint32]string)(nil),
+	)
+}
+
+type structVarious struct {
+	String string
+	Int    int32
+	Float  float64
+	Struct struct {
+		X string
+	}
+	Slice []string
+	Map   map[string]string
+}
diff --git a/vendor/github.com/json-iterator/go/type_tests/marshaler_string_test.go b/vendor/github.com/json-iterator/go/type_tests/marshaler_string_test.go
new file mode 100644
index 000000000..c871191f4
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/marshaler_string_test.go
@@ -0,0 +1,52 @@
+package test
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"strings"
+)
+
+type StringMarshaler string
+
+func (m StringMarshaler) encode(str string) string {
+	buf := bytes.Buffer{}
+	b64 := base64.NewEncoder(base64.StdEncoding, &buf)
+	if _, err := b64.Write([]byte(str)); err != nil {
+		panic(err)
+	}
+	if err := b64.Close(); err != nil {
+		panic(err)
+	}
+	return buf.String()
+}
+
+func (m StringMarshaler) decode(str string) string {
+	if len(str) == 0 {
+		return ""
+	}
+	b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str))
+	bs := make([]byte, len(str))
+	if n, err := b64.Read(bs); err != nil {
+		panic(err)
+	} else {
+		bs = bs[:n]
+	}
+	return string(bs)
+}
+
+func (m StringMarshaler) MarshalJSON() ([]byte, error) {
+	return []byte(`"MANUAL__` + m.encode(string(m)) + `"`), nil
+}
+
+func (m *StringMarshaler) UnmarshalJSON(text []byte) error {
+	*m = StringMarshaler(m.decode(strings.TrimPrefix(strings.Trim(string(text), `"`), "MANUAL__")))
+	return nil
+}
+
+var _ json.Marshaler = *new(StringMarshaler)
+var _ json.Unmarshaler = new(StringMarshaler)
+
+func init() {
+	testCases = append(testCases, (*StringMarshaler)(nil))
+}
diff --git a/vendor/github.com/json-iterator/go/type_tests/marshaler_struct_test.go b/vendor/github.com/json-iterator/go/type_tests/marshaler_struct_test.go
new file mode 100644
index 000000000..e235dd600
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/marshaler_struct_test.go
@@ -0,0 +1,69 @@
+package test
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"strings"
+)
+
+type structMarshaler struct {
+	X string
+}
+
+func (m structMarshaler) encode(str string) string {
+	buf := bytes.Buffer{}
+	b64 := base64.NewEncoder(base64.StdEncoding, &buf)
+	if _, err := b64.Write([]byte(str)); err != nil {
+		panic(err)
+	}
+	if err := b64.Close(); err != nil {
+		panic(err)
+	}
+	return buf.String()
+}
+
+func (m structMarshaler) decode(str string) string {
+	if len(str) == 0 {
+		return ""
+	}
+	b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str))
+	bs := make([]byte, len(str))
+	if n, err := b64.Read(bs); err != nil {
+		panic(err)
+	} else {
+		bs = bs[:n]
+	}
+	return string(bs)
+}
+
+func (m structMarshaler) MarshalJSON() ([]byte, error) {
+	return []byte(`"MANUAL__` + m.encode(m.X) + `"`), nil
+}
+
+func (m *structMarshaler) UnmarshalJSON(text []byte) error {
+	m.X = m.decode(strings.TrimPrefix(strings.Trim(string(text), `"`), "MANUAL__"))
+	return nil
+}
+
+var _ json.Marshaler = structMarshaler{}
+var _ json.Unmarshaler = &structMarshaler{}
+
+type structMarshalerAlias structMarshaler
+
+func init() {
+	testCases = append(testCases,
+		(*structMarshaler)(nil),
+		(*structMarshalerAlias)(nil),
+		(*struct {
+			S string
+			M structMarshaler
+			I int8
+		})(nil),
+		(*struct {
+			S string
+			M structMarshalerAlias
+			I int8
+		})(nil),
+	)
+}
diff --git a/vendor/github.com/json-iterator/go/type_tests/slice_test.go b/vendor/github.com/json-iterator/go/type_tests/slice_test.go
new file mode 100644
index 000000000..129737d5c
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/slice_test.go
@@ -0,0 +1,125 @@
+package test
+
+func init() {
+	testCases = append(testCases,
+		(*[][4]bool)(nil),
+		(*[][4]byte)(nil),
+		(*[][4]float64)(nil),
+		(*[][4]int32)(nil),
+		(*[][4]*string)(nil),
+		(*[][4]string)(nil),
+		(*[][4]uint8)(nil),
+		(*[]bool)(nil),
+		(*[]byte)(nil),
+		(*[]float64)(nil),
+		(*[]int32)(nil),
+		(*[]int64)(nil),
+		(*[]map[int32]string)(nil),
+		(*[]map[string]string)(nil),
+		(*[4]*[4]bool)(nil),
+		(*[4]*[4]byte)(nil),
+		(*[4]*[4]float64)(nil),
+		(*[4]*[4]int32)(nil),
+		(*[4]*[4]*string)(nil),
+		(*[4]*[4]string)(nil),
+		(*[4]*[4]uint8)(nil),
+		(*[]*bool)(nil),
+		(*[]*float64)(nil),
+		(*[]*int32)(nil),
+		(*[]*map[int32]string)(nil),
+		(*[]*map[string]string)(nil),
+		(*[]*[]bool)(nil),
+		(*[]*[]byte)(nil),
+		(*[]*[]float64)(nil),
+		(*[]*[]int32)(nil),
+		(*[]*[]*string)(nil),
+		(*[]*[]string)(nil),
+		(*[]*[]uint8)(nil),
+		(*[]*string)(nil),
+		(*[]*struct {
+			String string
+			Int    int32
+			Float  float64
+			Struct struct {
+				X string
+			}
+			Slice []string
+			Map   map[string]string
+		})(nil),
+		(*[]*uint8)(nil),
+		(*[][]bool)(nil),
+		(*[][]byte)(nil),
+		(*[][]float64)(nil),
+		(*[][]int32)(nil),
+		(*[][]*string)(nil),
+		(*[][]string)(nil),
+		(*[][]uint8)(nil),
+		(*[]string)(nil),
+		(*[]struct{})(nil),
+		(*[]structEmpty)(nil),
+		(*[]struct {
+			F *string
+		})(nil),
+		(*[]struct {
+			String string
+			Int    int32
+			Float  float64
+			Struct struct {
+				X string
+			}
+			Slice []string
+			Map   map[string]string
+		})(nil),
+		(*[]uint8)(nil),
+		(*[]jsonMarshaler)(nil),
+		(*[]jsonMarshalerMap)(nil),
+		(*[]textMarshaler)(nil),
+		(*[]textMarshalerMap)(nil),
+	)
+}
+
+type jsonMarshaler struct {
+	Id string `json:"id,omitempty" db:"id"`
+}
+
+func (p *jsonMarshaler) MarshalJSON() ([]byte, error) {
+	return []byte(`{}`), nil
+}
+
+func (p *jsonMarshaler) UnmarshalJSON(input []byte) error {
+	p.Id = "hello"
+	return nil
+}
+
+type jsonMarshalerMap map[int]int
+
+func (p *jsonMarshalerMap) MarshalJSON() ([]byte, error) {
+	return []byte(`{}`), nil
+}
+
+func (p *jsonMarshalerMap) UnmarshalJSON(input []byte) error {
+	return nil
+}
+
+type textMarshaler struct {
+	Id string `json:"id,omitempty" db:"id"`
+}
+
+func (p *textMarshaler) MarshalText() ([]byte, error) {
+	return []byte(`{}`), nil
+}
+
+func (p *textMarshaler) UnmarshalText(input []byte) error {
+	p.Id = "hello"
+	return nil
+}
+
+type textMarshalerMap map[int]int
+
+func (p *textMarshalerMap) MarshalText() ([]byte, error) {
+	return []byte(`{}`), nil
+}
+
+func (p *textMarshalerMap) UnmarshalText(input []byte) error {
+	return nil
+}
diff --git a/vendor/github.com/json-iterator/go/type_tests/struct_embedded_test.go b/vendor/github.com/json-iterator/go/type_tests/struct_embedded_test.go
new file mode 100644
index 000000000..3fb3f1107
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/struct_embedded_test.go
@@ -0,0 +1,233 @@
+package test
+
+func init() {
+	testCases = append(testCases,
+		(*struct {
+			EmbeddedFloat64
+		})(nil),
+		(*struct {
+			EmbeddedInt32
+		})(nil),
+		(*struct {
+			F1 float64
+			StringMarshaler
+			F2 int32
+		})(nil),
+		(*struct {
+			EmbeddedMapStringString
+		})(nil),
+		(*struct {
+			*EmbeddedFloat64
+		})(nil),
+		(*struct {
+			*EmbeddedInt32
+		})(nil),
+		(*struct {
+			*EmbeddedMapStringString
+		})(nil),
+		(*struct {
+			*EmbeddedSliceString
+		})(nil),
+		(*struct {
+			*EmbeddedString
+		})(nil),
+		(*struct {
+			*EmbeddedStruct
+		})(nil),
+		(*struct {
+			EmbeddedSliceString
+		})(nil),
+		(*struct {
+			EmbeddedString
+		})(nil),
+		(*struct {
+			EmbeddedString `json:"othername"`
+		})(nil),
+		(*struct {
+			EmbeddedStruct
+		})(nil),
+		(*struct {
+			F1 float64
+			StringTextMarshaler
+			F2 int32
+		})(nil),
+		(*OverlapDifferentLevels)(nil),
+		(*IgnoreDeeperLevel)(nil),
+		(*SameLevel1BothTagged)(nil),
+		(*SameLevel1NoTags)(nil),
+		(*SameLevel1Tagged)(nil),
+		(*SameLevel2BothTagged)(nil),
+		(*SameLevel2NoTags)(nil),
+		(*SameLevel2Tagged)(nil),
+		(*EmbeddedPtr)(nil),
+	)
+}
+
+type EmbeddedFloat64 float64
+type EmbeddedInt32 int32
+type EmbeddedMapStringString map[string]string
+type EmbeddedSliceString []string
+type EmbeddedString string
+type EmbeddedStruct struct {
+	String string
+	Int    int32
+	Float  float64
+	Struct struct {
+		X string
+	}
+	Slice []string
+	Map   map[string]string
+}
+
+type OverlapDifferentLevelsE1 struct {
+	F1 int32
+}
+
+type OverlapDifferentLevelsE2 struct {
+	F2 string
+}
+
+type OverlapDifferentLevels struct {
+	OverlapDifferentLevelsE1
+	OverlapDifferentLevelsE2
+	F1 string
+}
+
+type IgnoreDeeperLevelDoubleEmbedded struct {
+	F1 int32 `json:"F1"`
+}
+
+type IgnoreDeeperLevelE1 struct {
+	IgnoreDeeperLevelDoubleEmbedded
+	F1 int32
+}
+
+type IgnoreDeeperLevelE2 struct {
+	F1 int32 `json:"F1"`
+	IgnoreDeeperLevelDoubleEmbedded
+}
+
+type IgnoreDeeperLevel struct {
+	IgnoreDeeperLevelE1
+	IgnoreDeeperLevelE2
+}
+
+type SameLevel1BothTaggedE1 struct {
+	F1 int32 `json:"F1"`
+}
+
+type SameLevel1BothTaggedE2 struct {
+	F1 int32 `json:"F1"`
+}
+
+type SameLevel1BothTagged struct {
+	SameLevel1BothTaggedE1
+	SameLevel1BothTaggedE2
+}
+
+type SameLevel1NoTagsE1 struct {
+	F1 int32
+}
+
+type SameLevel1NoTagsE2 struct {
+	F1 int32
+}
+
+type SameLevel1NoTags struct {
+	SameLevel1NoTagsE1
+	SameLevel1NoTagsE2
+}
+
+type SameLevel1TaggedE1 struct {
+	F1 int32
+}
+
+type SameLevel1TaggedE2 struct {
+	F1 int32 `json:"F1"`
+}
+
+type SameLevel1Tagged struct {
+	SameLevel1TaggedE1
+	SameLevel1TaggedE2
+}
+
+type SameLevel2BothTaggedDE1 struct {
+	F1 int32 `json:"F1"`
+}
+
+type SameLevel2BothTaggedE1 struct {
+	SameLevel2BothTaggedDE1
+}
+
+// DoubleEmbedded2 TEST ONLY
+type SameLevel2BothTaggedDE2 struct {
+	F1 int32 `json:"F1"`
+}
+
+// Embedded2 TEST ONLY
+type SameLevel2BothTaggedE2 struct {
+	SameLevel2BothTaggedDE2
+}
+
+type SameLevel2BothTagged struct {
+	SameLevel2BothTaggedE1
+	SameLevel2BothTaggedE2
+}
+
+type SameLevel2NoTagsDE1 struct {
+	F1 int32
+}
+
+type SameLevel2NoTagsE1 struct {
+	SameLevel2NoTagsDE1
+}
+
+type SameLevel2NoTagsDE2 struct {
+	F1 int32
+}
+
+type SameLevel2NoTagsE2 struct {
+	SameLevel2NoTagsDE2
+}
+
+type SameLevel2NoTags struct {
+	SameLevel2NoTagsE1
+	SameLevel2NoTagsE2
+}
+
+// DoubleEmbedded1 TEST ONLY
+type SameLevel2TaggedDE1 struct {
+	F1 int32
+}
+
+// Embedded1 TEST ONLY
+type SameLevel2TaggedE1 struct {
+	SameLevel2TaggedDE1
+}
+
+// DoubleEmbedded2 TEST ONLY
+type SameLevel2TaggedDE2 struct {
+	F1 int32 `json:"F1"`
+}
+
+// Embedded2 TEST ONLY
+type SameLevel2TaggedE2 struct {
+	SameLevel2TaggedDE2
+}
+
+type SameLevel2Tagged struct {
+	SameLevel2TaggedE1
+	SameLevel2TaggedE2
+}
+
+type EmbeddedPtrO1 struct {
+	O1F string
+}
+
+type EmbeddedPtrOption struct {
+	O1 *EmbeddedPtrO1
+}
+
+type EmbeddedPtr struct {
+	EmbeddedPtrOption `json:","`
+}
diff --git a/vendor/github.com/json-iterator/go/type_tests/struct_field_case_test.go b/vendor/github.com/json-iterator/go/type_tests/struct_field_case_test.go
new file mode 100644
index 000000000..567f290ba
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/struct_field_case_test.go
@@ -0,0 +1,30 @@
+package test
+
+func init() {
+	testCases = append(testCases,
+		(*struct {
+			Upper bool `json:"M"`
+			Lower bool `json:"m"`
+		})(nil),
+	)
+	asymmetricTestCases = append(asymmetricTestCases, [][2]interface{}{
+		{
+			(*struct {
+				Field string
+			})(nil),
+			(*struct {
+				FIELD string
+			})(nil),
+		},
+		{
+			(*struct {
+				F1 string
+				F2 string
+				F3 string
+			})(nil),
+			(*struct {
+				F1 string
+			})(nil),
+		},
+	}...)
+}
diff --git a/vendor/github.com/json-iterator/go/type_tests/struct_tags_test.go b/vendor/github.com/json-iterator/go/type_tests/struct_tags_test.go
new file mode 100644
index 000000000..6b111faa4
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/struct_tags_test.go
@@ -0,0 +1,282 @@
+package test
+
+func init() {
+	testCases = append(testCases,
+		(*EmbeddedFieldName)(nil),
+		(*StringFieldName)(nil),
+		(*StructFieldName)(nil),
+		(*struct {
+			F1 bool `json:"F1"`
+			F2 bool `json:"F2,omitempty"`
+		})(nil),
+		(*EmbeddedOmitEmpty)(nil),
+		(*struct {
+			F1 float32 `json:"F1"`
+			F2 float32 `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 int32 `json:"F1"`
+			F2 int32 `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 map[string]string `json:"F1"`
+			F2 map[string]string `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 *bool `json:"F1"`
+			F2 *bool `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 *float32 `json:"F1"`
+			F2 *float32 `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 *int32 `json:"F1"`
+			F2 *int32 `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 *map[string]string `json:"F1"`
+			F2 *map[string]string `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 *[]string `json:"F1"`
+			F2 *[]string `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 string `json:"F1"`
+			F2 string `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 *string `json:"F1"`
+			F2 *string `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F *jm `json:"f,omitempty"`
+		})(nil),
+		(*struct {
+			F *tm `json:"f,omitempty"`
+		})(nil),
+		(*struct {
+			F *sjm `json:"f,omitempty"`
+		})(nil),
+		(*struct {
+			F *tm `json:"f,omitempty"`
+		})(nil),
+		(*struct {
+			F1 *uint32 `json:"F1"`
+			F2 *uint32 `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 []string `json:"F1"`
+			F2 []string `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 string `json:"F1"`
+			F2 string `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F jm `json:"f,omitempty"`
+		})(nil),
+		(*struct {
+			F tm `json:"f,omitempty"`
+		})(nil),
+		(*struct {
+			F struct{} `json:"f,omitempty"` // omitempty is meaningless here
+		})(nil),
+		(*struct {
+			F sjm `json:"f,omitempty"`
+		})(nil),
+		(*struct {
+			F stm `json:"f,omitempty"`
+		})(nil),
+		(*struct {
+			F1 uint32 `json:"F1"`
+			F2 uint32 `json:"F2,omitempty"`
+		})(nil),
+		(*struct {
+			F1 bool `json:"F1"`
+			F2 bool `json:"F2,string"`
+		})(nil),
+		(*struct {
+			F1 byte `json:"F1"`
+			F2 byte `json:"F2,string"`
+		})(nil),
+		(*struct {
+			F1 float32 `json:"F1"`
+			F2 float32 `json:"F2,string"`
+		})(nil),
+		(*struct {
+			F1 float64 `json:"F1"`
+			F2 float64 `json:"F2,string"`
+		})(nil),
+		(*struct {
+			F1 int8 `json:"F1"`
+			F2 int8 `json:"F2,string"`
+		})(nil),
+		(*struct {
+			F1 int16 `json:"F1"`
+			F2 int16 `json:"F2,string"`
+		})(nil),
+		(*struct {
+			F1 int32 `json:"F1"`
+			F2 int32 `json:"F2,string"`
+		})(nil),
+		(*struct {
+			F1 string `json:"F1"`
+			F2 string `json:"F2,string"`
+		})(nil),
+		(*struct {
+			F1 uint8 `json:"F1"`
+			F2 uint8 `json:"F2,string"`
+		})(nil),
+		(*struct {
+			F1 uint16 `json:"F1"`
+			F2 uint16 `json:"F2,string"`
+		})(nil),
+		(*struct {
+			F1 uint32 `json:"F1"`
+			F2 uint32 `json:"F2,string"`
+		})(nil),
+		(*struct {
+			A           string            `json:"a,omitempty"`
+			B           string            `json:"b,omitempty"`
+			Annotations map[string]string `json:"annotations,omitempty"`
+		})(nil),
+		(*struct {
+			Field bool `json:",omitempty,string"`
+		})(nil),
+	)
+}
+
+// S1 TEST ONLY
+type EmbeddedFieldNameS1 struct {
+	S1F string
+}
+
+// S2 TEST ONLY
+type EmbeddedFieldNameS2 struct {
+	S2F string
+}
+
+// S3 TEST ONLY
+type EmbeddedFieldNameS3 struct {
+	S3F string
+}
+
+// S4 TEST ONLY
+type EmbeddedFieldNameS4 struct {
+	S4F string
+}
+
+// S5 TEST ONLY
+type EmbeddedFieldNameS5 struct {
+	S5F string
+}
+
+// S6 TEST ONLY
+type EmbeddedFieldNameS6 struct {
+	S6F string
+}
+
+type EmbeddedFieldName struct {
+	EmbeddedFieldNameS1 `json:"F1"`
+	EmbeddedFieldNameS2 `json:"f2"`
+	EmbeddedFieldNameS3 `json:"-"`
+	EmbeddedFieldNameS4 `json:"-,"`
+	EmbeddedFieldNameS5 `json:","`
+	EmbeddedFieldNameS6 `json:""`
+}
+
+type StringFieldNameE struct {
+	E1 string
+}
+
+type StringFieldName struct {
+	F1               string `json:"F1"`
+	F2               string `json:"f2"`
+	F3               string `json:"-"`
+	F4               string `json:"-,"`
+	F5               string `json:","`
+	F6               string `json:""`
+	StringFieldNameE `json:"e"`
+}
+
+type StructFieldNameS1 struct {
+	S1F string
+}
+
+type StructFieldNameS2 struct {
+	S2F string
+}
+
+type StructFieldNameS3 struct {
+	S3F string
+}
+
+type StructFieldNameS4 struct {
+	S4F string
+}
+
+type StructFieldNameS5 struct {
+	S5F string
+}
+
+type StructFieldNameS6 struct {
+	S6F string
+}
+
+type StructFieldName struct {
+	F1 StructFieldNameS1 `json:"F1"`
+	F2 StructFieldNameS2 `json:"f2"`
+	F3 StructFieldNameS3 `json:"-"`
+	F4 StructFieldNameS4 `json:"-,"`
+	F5 StructFieldNameS5 `json:","`
+	F6 StructFieldNameS6 `json:""`
+}
+type EmbeddedOmitEmptyE struct {
+	F string `json:"F,omitempty"`
+}
+
+type EmbeddedOmitEmpty struct {
+	EmbeddedOmitEmptyE
+}
+
+type jm string
+
+func (t *jm) UnmarshalJSON(b []byte) error {
+	return nil
+}
+
+func (t jm) MarshalJSON() ([]byte, error) {
+	return []byte(`""`), nil
+}
+
+type tm string
+
+func (t *tm) UnmarshalText(b []byte) error {
+	return nil
+}
+
+func (t tm) MarshalText() ([]byte, error) {
+	return []byte(`""`), nil
+}
+
+type sjm struct{}
+
+func (t *sjm) UnmarshalJSON(b []byte) error {
+	return nil
+}
+
+func (t sjm) MarshalJSON() ([]byte, error) {
+	return []byte(`""`), nil
+}
+
+type stm struct{}
+
+func (t *stm) UnmarshalText(b []byte) error {
+	return nil
+}
+
+func (t stm) MarshalText() ([]byte, error) {
+	return []byte(`""`), nil
+}
diff --git a/vendor/github.com/json-iterator/go/type_tests/struct_test.go b/vendor/github.com/json-iterator/go/type_tests/struct_test.go
new file mode 100644
index 000000000..0cf32522a
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/struct_test.go
@@ -0,0 +1,404 @@
+package test
+
+import "time"
+
+func init() {
+	structFields1To11()
+	testCases = append(testCases,
+		(*struct1Alias)(nil),
+		(*struct {
+			F [4]*string
+		})(nil),
+		(*struct {
+			F [4]string
+		})(nil),
+		(*struct {
+			F1 [4]stringAlias
+			F2 arrayAlis
+		})(nil),
+		(*struct {
+			F1 [4]string
+			F2 [4]string
+			F3 [4]string
+		})(nil),
+		(*struct {
+			F [4]struct {
+				F1 string
+				F2 string
+				F3 string
+			}
+		})(nil),
+		(*struct{})(nil),
+		(*structEmpty)(nil),
+		(*struct {
+			Byte1   byte
+			Byte2   byte
+			Bool1   bool
+			Bool2   bool
+			Int8    int8
+			Int16   int16
+			Int32   int32
+			Int64   int64
+			Uint8   uint8
+			Uint16  uint16
+			Uint32  uint32
+			Uint64  uint64
+			Float32 float32
+			Float64 float64
+			String1 string
+			String2 string
+		})(nil),
+		(*struct {
+			F float64
+		})(nil),
+		(*struct {
+			F float64Alias
+		})(nil),
+		(*struct {
+			F1 float64
+			F2 float64
+			F3 float64
+		})(nil),
+		(*struct {
+			F1 float64Alias
+			F2 float64Alias
+			F3 float64Alias
+		})(nil),
+		(*struct {
+			F int32
+		})(nil),
+		(*struct {
+			F int32Alias
+		})(nil),
+		(*struct {
+			F1 int32
+			F2 int32
+			F3 int32
+		})(nil),
+		(*struct {
+			F1 int32Alias
+			F2 int32Alias
+			F3 int32Alias
+		})(nil),
+		(*struct {
+			F int64
+		})(nil),
+		(*struct {
+			F map[int32]*string
+		})(nil),
+		(*struct {
+			F map[int32]string
+		})(nil),
+		(*struct {
+			F map[int32]struct {
+				F1 string
+				F2 string
+				F3 string
+			}
+		})(nil),
+		(*struct {
+			F map[string]*string
+		})(nil),
+		(*struct {
+			F map[string]string
+		})(nil),
+		(*struct {
+			F map[string]struct {
+				F1 string
+				F2 string
+				F3 string
+			}
+		})(nil),
+		(*struct {
+			F *float64
+		})(nil),
+		(*struct {
+			F1 *float64Alias
+			F2 ptrFloat64Alias
+			F3 *ptrFloat64Alias
+		})(nil),
+		(*struct {
+			F *int32
+		})(nil),
+		(*struct {
+			F1 *int32Alias
+			F2 ptrInt32Alias
+			F3 *ptrInt32Alias
+		})(nil),
+		(*struct {
+			F **struct{}
+		})(nil),
+		(*struct {
+			F **struct {
+				F1 string
+				F2 string
+				F3 string
+			}
+		})(nil),
+		(*struct {
+			F *string
+		})(nil),
+		(*struct {
+			F1 *stringAlias
+			F2 ptrStringAlias
+			F3 *ptrStringAlias
+		})(nil),
+		(*struct {
+			F *struct{}
+		})(nil),
+		(*struct {
+			F *struct {
+				F1 string
+				F2 string
+				F3 string
+			}
+		})(nil),
+		(*struct {
+			F1 *float64
+			F2 *float64
+			F3 *float64
+		})(nil),
+		(*struct {
+			F1 *int32
+			F2 *int32
+			F3 *int32
+		})(nil),
+		(*struct {
+			F1 *string
+			F2 *string
+			F3 *string
+		})(nil),
+		(*struct {
+			F []*string
+		})(nil),
+		(*struct {
+			F []string
+		})(nil),
+		(*struct {
+			F1 []stringAlias
+			F2 stringAlias
+		})(nil),
+		(*struct {
+			F1 []string
+			F2 []string
+			F3 []string
+		})(nil),
+		(*struct {
+			F []struct {
+				F1 string
+				F2 string
+				F3 string
+			}
+		})(nil),
+		(*struct {
+			F string
+		})(nil),
+		(*struct {
+			F stringAlias
+		})(nil),
+		(*struct {
+			F1 string
+			F2 string
+			F3 string
+		})(nil),
+		(*struct {
+			F1 stringAlias
+			F2 stringAlias
+			F3 stringAlias
+		})(nil),
+		(*struct {
+			F1 struct{}
+			F2 struct{}
+			F3 struct{}
+		})(nil),
+		(*struct {
+			F struct{}
+		})(nil),
+		(*struct {
+			F structEmpty
+		})(nil),
+		(*struct {
+			F struct {
+				F1 float32
+				F2 float32
+				F3 float32
+			}
+		})(nil),
+		(*struct {
+			F struct {
+				F float32
+			}
+		})(nil),
+		(*struct {
+			F struct2
+		})(nil),
+		(*struct {
+			F struct {
+				F1 int32
+				F2 int32
+				F3 int32
+			}
+		})(nil),
+		(*struct {
+			F struct {
+				F1 string
+				F2 string
+				F3 string
+			}
+		})(nil),
+		(*struct {
+			F struct3
+		})(nil),
+		(*struct {
+			TF1 struct {
+				F2 int
+				F1 *withTime
+			}
+		})(nil),
+		(*DeeplyNested)(nil),
+	)
+}
+
+func structFields1To11() {
+	testCases = append(testCases,
+		(*struct {
+			Field1 string
+		})(nil),
+		(*struct {
+			Field1 string
+			Field2 string
+		})(nil),
+		(*struct {
+			Field1 string
+			Field2 string
+			Field3 string
+		})(nil),
+		(*struct {
+			Field1 string
+			Field2 string
+			Field3 string
+			Field4 string
+		})(nil),
+		(*struct {
+			Field1 string
+			Field2 string
+			Field3 string
+			Field4 string
+			Field5 string
+		})(nil),
+		(*struct {
+			Field1 string
+			Field2 string
+			Field3 string
+			Field4 string
+			Field5 string
+			Field6 string
+		})(nil),
+		(*struct {
+			Field1 string
+			Field2 string
+			Field3 string
+			Field4 string
+			Field5 string
+			Field6 string
+			Field7 string
+		})(nil),
+		(*struct {
+			Field1 string
+			Field2 string
+			Field3 string
+			Field4 string
+			Field5 string
+			Field6 string
+			Field7 string
+			Field8 string
+		})(nil),
+		(*struct {
+			Field1 string
+			Field2 string
+			Field3 string
+			Field4 string
+			Field5 string
+			Field6 string
+			Field7 string
+			Field8 string
+			Field9 string
+		})(nil),
+		(*struct {
+			Field1  string
+			Field2  string
+			Field3  string
+			Field4  string
+			Field5  string
+			Field6  string
+			Field7  string
+			Field8  string
+			Field9  string
+			Field10 string
+		})(nil),
+		(*struct {
+			Field1  string
+			Field2  string
+			Field3  string
+			Field4  string
+			Field5  string
+			Field6  string
+			Field7  string
+			Field8  string
+			Field9  string
+			Field10 string
+			Field11 string
+		})(nil),
+	)
+}
+
+type struct1 struct {
+	Byte1   byte
+	Byte2   byte
+	Bool1   bool
+	Bool2   bool
+	Int8    int8
+	Int16   int16
+	Int32   int32
+	Uint8   uint8
+	Uint16  uint16
+	Uint32  uint32
+	Float32 float32
+	Float64 float64
+	String1 string
+	String2 string
+}
+type struct1Alias struct1
+
+type struct2 struct {
+	F float64
+}
+type struct3 struct {
+	F1 stringAlias
+	F2 stringAlias
+	F3 stringAlias
+}
+
+type withTime struct {
+	time.Time
+}
+
+func (t *withTime) UnmarshalJSON(b []byte) error {
+	return nil
+}
+func (t withTime) MarshalJSON() ([]byte, error) {
+	return []byte(`"fake"`), nil
+}
+
+type YetYetAnotherObject struct {
+	Field string
+}
+type YetAnotherObject struct {
+	Field *YetYetAnotherObject
+}
+type AnotherObject struct {
+	Field *YetAnotherObject
+}
+type DeeplyNested struct {
+	Me *AnotherObject
+}
diff --git a/vendor/github.com/json-iterator/go/type_tests/text_marshaler_string_test.go b/vendor/github.com/json-iterator/go/type_tests/text_marshaler_string_test.go
new file mode 100644
index 000000000..c08b7985c
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/text_marshaler_string_test.go
@@ -0,0 +1,57 @@
+package test
+
+import (
+	"bytes"
+	"encoding"
+	"encoding/base64"
+	"strings"
+)
+
+func init() {
+	testCases = append(testCases,
+		(*StringTextMarshaler)(nil),
+	)
+}
+
+// StringTextMarshaler TEST ONLY
+type StringTextMarshaler string
+
+func (m StringTextMarshaler) encode(str string) string {
+	buf := bytes.Buffer{}
+	b64 := base64.NewEncoder(base64.StdEncoding, &buf)
+	if _, err := b64.Write([]byte(str)); err != nil {
+		panic(err)
+	}
+	if err := b64.Close(); err != nil {
+		panic(err)
+	}
+	return buf.String()
+}
+
+func (m StringTextMarshaler) decode(str string) string {
+	if len(str) == 0 {
+		return ""
+	}
+	b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str))
+	bs := make([]byte, len(str))
+	if n, err := b64.Read(bs); err != nil {
+		panic(err)
+	} else {
+		bs = bs[:n]
+	}
+	return string(bs)
+}
+
+// MarshalText TEST ONLY
+func (m StringTextMarshaler) MarshalText() ([]byte, error) {
+	return []byte(`MANUAL__` + m.encode(string(m))), nil
+}
+
+// UnmarshalText TEST ONLY
+func (m *StringTextMarshaler) UnmarshalText(text []byte) error {
+	*m = StringTextMarshaler(m.decode(strings.TrimPrefix(string(text), "MANUAL__")))
+	return nil
+}
+
+var _ encoding.TextMarshaler = *new(StringTextMarshaler)
+var _ encoding.TextUnmarshaler = new(StringTextMarshaler)
diff --git a/vendor/github.com/json-iterator/go/type_tests/text_marshaler_struct_test.go b/vendor/github.com/json-iterator/go/type_tests/text_marshaler_struct_test.go
new file mode 100644
index 000000000..7c4be391e
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/text_marshaler_struct_test.go
@@ -0,0 +1,69 @@
+package test
+
+import (
+	"bytes"
+	"encoding"
+	"encoding/base64"
+	"strings"
+)
+
+func init() {
+	testCases = append(testCases,
+		(*structTextMarshaler)(nil),
+		(*structTextMarshalerAlias)(nil),
+		(*struct {
+			S string
+			M structTextMarshaler
+			I int8
+		})(nil),
+		(*struct {
+			S string
+			M structTextMarshalerAlias
+			I int8
+		})(nil),
+	)
+}
+
+type structTextMarshaler struct {
+	X string
+}
+
+func (m structTextMarshaler) encode(str string) string {
+	buf := bytes.Buffer{}
+	b64 := base64.NewEncoder(base64.StdEncoding, &buf)
+	if _, err := b64.Write([]byte(str)); err != nil {
+		panic(err)
+	}
+	if err := b64.Close(); err != nil {
+		panic(err)
+	}
+	return buf.String()
+}
+
+func (m structTextMarshaler) decode(str string) string {
+	if len(str) == 0 {
+		return ""
+	}
+	b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str))
+	bs := make([]byte, len(str))
+	if n, err := b64.Read(bs); err != nil {
+		panic(err)
+	} else {
+		bs = bs[:n]
+	}
+	return string(bs)
+}
+
+func (m structTextMarshaler) MarshalText() ([]byte, error) {
+	return []byte(`MANUAL__` + m.encode(m.X)), nil
+}
+
+func (m *structTextMarshaler) UnmarshalText(text []byte) error {
+	m.X = m.decode(strings.TrimPrefix(string(text), "MANUAL__"))
+	return nil
+}
+
+var _ encoding.TextMarshaler = structTextMarshaler{}
+var _ encoding.TextUnmarshaler = &structTextMarshaler{}
+
+type structTextMarshalerAlias structTextMarshaler
diff --git a/vendor/github.com/json-iterator/go/type_tests/type_test.go b/vendor/github.com/json-iterator/go/type_tests/type_test.go
new file mode 100644
index 000000000..cde433227
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/type_tests/type_test.go
@@ -0,0 +1,162 @@
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/davecgh/go-spew/spew"
+	"github.com/google/gofuzz"
+	"github.com/json-iterator/go"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var testCases []interface{}
+var asymmetricTestCases [][2]interface{}
+
+type selectedSymmetricCase struct {
+	testCase interface{}
+}
+
+func Test_symmetric(t *testing.T) {
+	for _, testCase := range testCases {
+		selectedSymmetricCase, found := testCase.(selectedSymmetricCase)
+		if found {
+			testCases = []interface{}{selectedSymmetricCase.testCase}
+			break
+		}
+	}
+	for _, testCase := range testCases {
+		valType := reflect.TypeOf(testCase).Elem()
+		t.Run(valType.String(), func(t *testing.T) {
+			fz := fuzz.New().MaxDepth(10).NilChance(0.3)
+			for i := 0; i < 100; i++ {
+				beforePtrVal := reflect.New(valType)
+				beforePtr := beforePtrVal.Interface()
+				fz.Fuzz(beforePtr)
+				before := beforePtrVal.Elem().Interface()
+
+				jbStd, err := json.Marshal(before)
+				if err != nil {
+					t.Fatalf("failed to marshal with stdlib: %v", err)
+				}
+				if len(strings.TrimSpace(string(jbStd))) == 0 {
+					t.Fatal("stdlib marshal produced empty result and no error")
+				}
+				jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
+				if err != nil {
+					t.Fatalf("failed to marshal with jsoniter: %v", err)
+				}
+				if len(strings.TrimSpace(string(jbIter))) == 0 {
+					t.Fatal("jsoniter marshal produced empty result and no error")
+				}
+				if string(jbStd) != string(jbIter) {
+					t.Fatalf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
+						indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
+				}
+
+				afterStdPtrVal := reflect.New(valType)
+				afterStdPtr := afterStdPtrVal.Interface()
+				err = json.Unmarshal(jbIter, afterStdPtr)
+				if err != nil {
+					t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+						err, indent(jbIter, "    "))
+				}
+				afterIterPtrVal := reflect.New(valType)
+				afterIterPtr := afterIterPtrVal.Interface()
+				err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, afterIterPtr)
+				if err != nil {
+					t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+						err, indent(jbIter, "    "))
+				}
+				afterStd := afterStdPtrVal.Elem().Interface()
+				afterIter := afterIterPtrVal.Elem().Interface()
+				if fingerprint(afterStd) != fingerprint(afterIter) {
+					t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",
+						dump(afterStd), dump(afterIter), indent(jbIter, "    "))
+				}
+			}
+		})
+	}
+}
+
+func Test_asymmetric(t *testing.T) {
+	for _, testCase := range asymmetricTestCases {
+		fromType := reflect.TypeOf(testCase[0]).Elem()
+		toType := reflect.TypeOf(testCase[1]).Elem()
+		fz := fuzz.New().MaxDepth(10).NilChance(0.3)
+		for i := 0; i < 100; i++ {
+			beforePtrVal := reflect.New(fromType)
+			beforePtr := beforePtrVal.Interface()
+			fz.Fuzz(beforePtr)
+			before := beforePtrVal.Elem().Interface()
+
+			jbStd, err := json.Marshal(before)
+			if err != nil {
+				t.Fatalf("failed to marshal with stdlib: %v", err)
+			}
+			if len(strings.TrimSpace(string(jbStd))) == 0 {
+				t.Fatal("stdlib marshal produced empty result and no error")
+			}
+			jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
+			if err != nil {
+				t.Fatalf("failed to marshal with jsoniter: %v", err)
+			}
+			if len(strings.TrimSpace(string(jbIter))) == 0 {
+				t.Fatal("jsoniter marshal produced empty result and no error")
+			}
+			if string(jbStd) != string(jbIter) {
+				t.Fatalf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
+					indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
+			}
+
+			afterStdPtrVal := reflect.New(toType)
+			afterStdPtr := afterStdPtrVal.Interface()
+			err = json.Unmarshal(jbIter, afterStdPtr)
+			if err != nil {
+				t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+					err, indent(jbIter, "    "))
+			}
+			afterIterPtrVal := reflect.New(toType)
+			afterIterPtr := afterIterPtrVal.Interface()
+			err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, afterIterPtr)
+			if err != nil {
+				t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+					err, indent(jbIter, "    "))
+			}
+			afterStd := afterStdPtrVal.Elem().Interface()
+			afterIter := afterIterPtrVal.Elem().Interface()
+			if fingerprint(afterStd) != fingerprint(afterIter) {
+				t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",
+					dump(afterStd), dump(afterIter), indent(jbIter, "    "))
+			}
+		}
+	}
+}
+
+const indentStr = ">  "
+
+func fingerprint(obj interface{}) string {
+	c := spew.ConfigState{
+		SortKeys: true,
+		SpewKeys: true,
+	}
+	return c.Sprintf("%v", obj)
+}
+
+func dump(obj interface{}) string {
+	cfg := spew.ConfigState{
+		Indent: indentStr,
+	}
+	return cfg.Sdump(obj)
+}
+
+func indent(src []byte, prefix string) string {
+	var buf bytes.Buffer
+	err := json.Indent(&buf, src, prefix, indentStr)
+	if err != nil {
+		return fmt.Sprintf("!!! %v", err)
+	}
+	return buf.String()
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/array_test.go b/vendor/github.com/json-iterator/go/value_tests/array_test.go
new file mode 100644
index 000000000..75ce27afd
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/array_test.go
@@ -0,0 +1,20 @@
+package test
+
+func init() {
+	two := float64(2)
+	marshalCases = append(marshalCases,
+		[1]*float64{nil},
+		[1]*float64{&two},
+		[2]*float64{},
+	)
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		ptr:   (*[0]int)(nil),
+		input: `[1]`,
+	}, unmarshalCase{
+		ptr:   (*[1]int)(nil),
+		input: `[2]`,
+	}, unmarshalCase{
+		ptr:   (*[1]int)(nil),
+		input: `[]`,
+	})
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/bool_test.go b/vendor/github.com/json-iterator/go/value_tests/bool_test.go
new file mode 100644
index 000000000..40d8ca931
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/bool_test.go
@@ -0,0 +1,10 @@
+package test
+
+func init() {
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		ptr: (*struct {
+			Field bool `json:"field"`
+		})(nil),
+		input: `{"field": null}`,
+	})
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/eface_test.go b/vendor/github.com/json-iterator/go/value_tests/eface_test.go
new file mode 100644
index 000000000..9d22ea92b
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/eface_test.go
@@ -0,0 +1,78 @@
+package test
+
+func init() {
+	var pEFace = func(val interface{}) *interface{} {
+		return &val
+	}
+	var pInt = func(val int) *int {
+		return &val
+	}
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		ptr:   (**interface{})(nil),
+		input: `"hello"`,
+	}, unmarshalCase{
+		ptr:   (**interface{})(nil),
+		input: `1e1`,
+	}, unmarshalCase{
+		ptr:   (**interface{})(nil),
+		input: `1.0e1`,
+	}, unmarshalCase{
+		ptr:   (*[]interface{})(nil),
+		input: `[1.0e1]`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			Field interface{}
+		})(nil),
+		input: `{"field":"hello"}`,
+	}, unmarshalCase{
+		obj: func() interface{} {
+			type TestData struct {
+				Name string `json:"name"`
+			}
+			o := &TestData{}
+			return &o
+		},
+		input: `{"name":"value"}`,
+	}, unmarshalCase{
+		obj: func() interface{} {
+			b := true
+			return &struct {
+				Field interface{} `json:"field"`
+			}{&b}
+		},
+		input: `{"field": null}`,
+	}, unmarshalCase{
+		obj: func() interface{} {
+			var pb *bool
+			return &struct {
+				Field interface{} `json:"field"`
+			}{&pb}
+		},
+		input: `{"field": null}`,
+	}, unmarshalCase{
+		obj: func() interface{} {
+			b := true
+			pb := &b
+			return &struct {
+				Field interface{} `json:"field"`
+			}{&pb}
+		},
+		input: `{"field": null}`,
+	})
+	marshalCases = append(marshalCases,
+		pEFace("hello"),
+		struct {
+			Field interface{}
+		}{"hello"},
+		struct {
+			Field interface{}
+		}{struct {
+			field chan int
+		}{}},
+		struct {
+			Field interface{}
+		}{struct {
+			Field *int
+		}{pInt(100)}},
+	)
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/float_test.go b/vendor/github.com/json-iterator/go/value_tests/float_test.go
new file mode 100644
index 000000000..3c00b2694
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/float_test.go
@@ -0,0 +1,129 @@
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"strconv"
+	"testing"
+)
+
+func Test_read_float(t *testing.T) {
+	inputs := []string{
+		`1.1`, `1000`, `9223372036854775807`, `12.3`, `-12.3`, `720368.54775807`, `720368.547758075`,
+		`1e1`, `1e+1`, `1e-1`, `1E1`, `1E+1`, `1E-1`, `-1e1`, `-1e+1`, `-1e-1`,
+	}
+	for _, input := range inputs {
+		// non-streaming
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.ParseString(jsoniter.ConfigDefault, input+",")
+			expected, err := strconv.ParseFloat(input, 32)
+			should.Nil(err)
+			should.Equal(float32(expected), iter.ReadFloat32())
+		})
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.ParseString(jsoniter.ConfigDefault, input+",")
+			expected, err := strconv.ParseFloat(input, 64)
+			should.Nil(err)
+			should.Equal(expected, iter.ReadFloat64())
+		})
+		// streaming
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.Parse(jsoniter.ConfigDefault, bytes.NewBufferString(input+","), 2)
+			expected, err := strconv.ParseFloat(input, 32)
+			should.Nil(err)
+			should.Equal(float32(expected), iter.ReadFloat32())
+		})
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.Parse(jsoniter.ConfigDefault, bytes.NewBufferString(input+","), 2)
+			val := float64(0)
+			err := json.Unmarshal([]byte(input), &val)
+			should.Nil(err)
+			should.Equal(val, iter.ReadFloat64())
+		})
+	}
+}
+
+func Test_write_float32(t *testing.T) {
+	vals := []float32{0, 1, -1, 99, 0xff, 0xfff, 0xffff, 0xfffff, 0xffffff, 0x4ffffff, 0xfffffff,
+		-0x4ffffff, -0xfffffff, 1.2345, 1.23456, 1.234567, 1.001}
+	for _, val := range vals {
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteFloat32Lossy(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			output, err := json.Marshal(val)
+			should.Nil(err)
+			should.Equal(string(output), buf.String())
+		})
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteVal(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			output, err := json.Marshal(val)
+			should.Nil(err)
+			should.Equal(string(output), buf.String())
+		})
+	}
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 10)
+	stream.WriteRaw("abcdefg")
+	stream.WriteFloat32Lossy(1.123456)
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("abcdefg1.123456", buf.String())
+
+	stream = jsoniter.NewStream(jsoniter.ConfigDefault, nil, 0)
+	stream.WriteFloat32(float32(0.0000001))
+	should.Equal("1e-07", string(stream.Buffer()))
+}
+
+func Test_write_float64(t *testing.T) {
+	vals := []float64{0, 1, -1, 99, 0xff, 0xfff, 0xffff, 0xfffff, 0xffffff, 0x4ffffff, 0xfffffff,
+		-0x4ffffff, -0xfffffff, 1.2345, 1.23456, 1.234567, 1.001}
+	for _, val := range vals {
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteFloat64Lossy(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatFloat(val, 'f', -1, 64), buf.String())
+		})
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteVal(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatFloat(val, 'f', -1, 64), buf.String())
+		})
+	}
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 10)
+	stream.WriteRaw("abcdefg")
+	stream.WriteFloat64Lossy(1.123456)
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("abcdefg1.123456", buf.String())
+
+	stream = jsoniter.NewStream(jsoniter.ConfigDefault, nil, 0)
+	stream.WriteFloat64(float64(0.0000001))
+	should.Equal("1e-07", string(stream.Buffer()))
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/iface_test.go b/vendor/github.com/json-iterator/go/value_tests/iface_test.go
new file mode 100644
index 000000000..b0daf1e00
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/iface_test.go
@@ -0,0 +1,45 @@
+package test
+
+import "io"
+
+func init() {
+	var pCloser1 = func(str string) *io.Closer {
+		closer := io.Closer(strCloser1(str))
+		return &closer
+	}
+	var pCloser2 = func(str string) *io.Closer {
+		strCloser := strCloser2(str)
+		closer := io.Closer(&strCloser)
+		return &closer
+	}
+	marshalCases = append(marshalCases,
+		pCloser1("hello"),
+		pCloser2("hello"),
+	)
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		ptr:   (*[]io.Closer)(nil),
+		input: "[null]",
+	}, unmarshalCase{
+		obj: func() interface{} {
+			strCloser := strCloser2("")
+			return &struct {
+				Field io.Closer
+			}{
+				&strCloser,
+			}
+		},
+		input: `{"Field": "hello"}`,
+	})
+}
+
+type strCloser1 string
+
+func (closer strCloser1) Close() error {
+	return nil
+}
+
+type strCloser2 string
+
+func (closer *strCloser2) Close() error {
+	return nil
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/int_test.go b/vendor/github.com/json-iterator/go/value_tests/int_test.go
new file mode 100644
index 000000000..9a3165ed5
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/int_test.go
@@ -0,0 +1,419 @@
+package test
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"strconv"
+	"testing"
+)
+
+func init() {
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		ptr: (*struct {
+			F1  int8
+			F2  int16
+			F3  int32
+			F4  int64
+			F5  int
+			F6  uint8
+			F7  uint16
+			F8  uint32
+			F9  uint64
+			F10 uint
+			F11 float32
+			F12 float64
+			F13 uintptr
+		})(nil),
+		input: `{
+			"f1":null,
+			"f2":null,
+			"f3":null,
+			"f4":null,
+			"f5":null,
+			"f6":null,
+			"f7":null,
+			"f8":null,
+			"f9":null,
+			"f10":null,
+			"f11":null,
+			"f12":null,
+			"f13":null
+		}`,
+	})
+}
+
+func Test_int8(t *testing.T) {
+	inputs := []string{`127`, `-128`}
+	for _, input := range inputs {
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.ParseString(jsoniter.ConfigDefault, input)
+			expected, err := strconv.ParseInt(input, 10, 8)
+			should.Nil(err)
+			should.Equal(int8(expected), iter.ReadInt8())
+		})
+	}
+}
+
+func Test_read_int16(t *testing.T) {
+	inputs := []string{`32767`, `-32768`}
+	for _, input := range inputs {
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.ParseString(jsoniter.ConfigDefault, input)
+			expected, err := strconv.ParseInt(input, 10, 16)
+			should.Nil(err)
+			should.Equal(int16(expected), iter.ReadInt16())
+		})
+	}
+}
+
+func Test_read_int32(t *testing.T) {
+	inputs := []string{`1`, `12`, `123`, `1234`, `12345`, `123456`, `2147483647`, `-2147483648`}
+	for _, input := range inputs {
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.ParseString(jsoniter.ConfigDefault, input)
+			expected, err := strconv.ParseInt(input, 10, 32)
+			should.Nil(err)
+			should.Equal(int32(expected), iter.ReadInt32())
+		})
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.Parse(jsoniter.ConfigDefault, bytes.NewBufferString(input), 2)
+			expected, err := strconv.ParseInt(input, 10, 32)
+			should.Nil(err)
+			should.Equal(int32(expected), iter.ReadInt32())
+		})
+	}
+}
+
+func Test_read_int_overflow(t *testing.T) {
+	should := require.New(t)
+	inputArr := []string{"123451", "-123451"}
+	for _, s := range inputArr {
+		iter := jsoniter.ParseString(jsoniter.ConfigDefault, s)
+		iter.ReadInt8()
+		should.NotNil(iter.Error)
+
+		iterU := jsoniter.ParseString(jsoniter.ConfigDefault, s)
+		iterU.ReadUint8()
+		should.NotNil(iterU.Error)
+
+	}
+
+	inputArr = []string{"12345678912", "-12345678912"}
+	for _, s := range inputArr {
+		iter := jsoniter.ParseString(jsoniter.ConfigDefault, s)
+		iter.ReadInt16()
+		should.NotNil(iter.Error)
+
+		iterUint := jsoniter.ParseString(jsoniter.ConfigDefault, s)
+		iterUint.ReadUint16()
+		should.NotNil(iterUint.Error)
+	}
+
+	inputArr = []string{"3111111111", "-3111111111", "1234232323232323235678912", "-1234567892323232323212"}
+	for _, s := range inputArr {
+		iter := jsoniter.ParseString(jsoniter.ConfigDefault, s)
+		iter.ReadInt32()
+		should.NotNil(iter.Error)
+
+		iterUint := jsoniter.ParseString(jsoniter.ConfigDefault, s)
+		iterUint.ReadUint32()
+		should.NotNil(iterUint.Error)
+	}
+
+	inputArr = []string{"9223372036854775811", "-9523372036854775807", "1234232323232323235678912", "-1234567892323232323212"}
+	for _, s := range inputArr {
+		iter := jsoniter.ParseString(jsoniter.ConfigDefault, s)
+		iter.ReadInt64()
+		should.NotNil(iter.Error)
+
+		iterUint := jsoniter.ParseString(jsoniter.ConfigDefault, s)
+		iterUint.ReadUint64()
+		should.NotNil(iterUint.Error)
+	}
+}
+
+func Test_read_int64(t *testing.T) {
+	inputs := []string{`1`, `12`, `123`, `1234`, `12345`, `123456`, `9223372036854775807`, `-9223372036854775808`}
+	for _, input := range inputs {
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.ParseString(jsoniter.ConfigDefault, input)
+			expected, err := strconv.ParseInt(input, 10, 64)
+			should.Nil(err)
+			should.Equal(expected, iter.ReadInt64())
+		})
+		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.Parse(jsoniter.ConfigDefault, bytes.NewBufferString(input), 2)
+			expected, err := strconv.ParseInt(input, 10, 64)
+			should.Nil(err)
+			should.Equal(expected, iter.ReadInt64())
+		})
+	}
+}
+
+func Test_write_uint8(t *testing.T) {
+	vals := []uint8{0, 1, 11, 111, 255}
+	for _, val := range vals {
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteUint8(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatUint(uint64(val), 10), buf.String())
+		})
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteVal(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatUint(uint64(val), 10), buf.String())
+		})
+	}
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 3)
+	stream.WriteRaw("a")
+	stream.WriteUint8(100) // should clear buffer
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("a100", buf.String())
+}
+
+func Test_write_int8(t *testing.T) {
+	vals := []int8{0, 1, -1, 99, 0x7f, -0x80}
+	for _, val := range vals {
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteInt8(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatInt(int64(val), 10), buf.String())
+		})
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteVal(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatInt(int64(val), 10), buf.String())
+		})
+	}
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4)
+	stream.WriteRaw("a")
+	stream.WriteInt8(-100) // should clear buffer
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("a-100", buf.String())
+}
+
+func Test_write_uint16(t *testing.T) {
+	vals := []uint16{0, 1, 11, 111, 255, 0xfff, 0xffff}
+	for _, val := range vals {
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteUint16(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatUint(uint64(val), 10), buf.String())
+		})
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteVal(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatUint(uint64(val), 10), buf.String())
+		})
+	}
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 5)
+	stream.WriteRaw("a")
+	stream.WriteUint16(10000) // should clear buffer
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("a10000", buf.String())
+}
+
+func Test_write_int16(t *testing.T) {
+	vals := []int16{0, 1, 11, 111, 255, 0xfff, 0x7fff, -0x8000}
+	for _, val := range vals {
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteInt16(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatInt(int64(val), 10), buf.String())
+		})
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteVal(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatInt(int64(val), 10), buf.String())
+		})
+	}
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 6)
+	stream.WriteRaw("a")
+	stream.WriteInt16(-10000) // should clear buffer
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("a-10000", buf.String())
+}
+
+func Test_write_uint32(t *testing.T) {
+	vals := []uint32{0, 1, 11, 111, 255, 999999, 0xfff, 0xffff, 0xfffff, 0xffffff, 0xfffffff, 0xffffffff}
+	for _, val := range vals {
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteUint32(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatUint(uint64(val), 10), buf.String())
+		})
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteVal(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatUint(uint64(val), 10), buf.String())
+		})
+	}
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 10)
+	stream.WriteRaw("a")
+	stream.WriteUint32(0xffffffff) // should clear buffer
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("a4294967295", buf.String())
+}
+
+func Test_write_int32(t *testing.T) {
+	vals := []int32{0, 1, 11, 111, 255, 999999, 0xfff, 0xffff, 0xfffff, 0xffffff, 0xfffffff, 0x7fffffff, -0x80000000}
+	for _, val := range vals {
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteInt32(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatInt(int64(val), 10), buf.String())
+		})
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteVal(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatInt(int64(val), 10), buf.String())
+		})
+	}
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 11)
+	stream.WriteRaw("a")
+	stream.WriteInt32(-0x7fffffff) // should clear buffer
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("a-2147483647", buf.String())
+}
+
+func Test_write_uint64(t *testing.T) {
+	vals := []uint64{0, 1, 11, 111, 255, 999999, 0xfff, 0xffff, 0xfffff, 0xffffff, 0xfffffff, 0xffffffff,
+		0xfffffffff, 0xffffffffff, 0xfffffffffff, 0xffffffffffff, 0xfffffffffffff, 0xffffffffffffff,
+		0xfffffffffffffff, 0xffffffffffffffff}
+	for _, val := range vals {
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteUint64(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatUint(uint64(val), 10), buf.String())
+		})
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteVal(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatUint(uint64(val), 10), buf.String())
+		})
+	}
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 10)
+	stream.WriteRaw("a")
+	stream.WriteUint64(0xffffffff) // should clear buffer
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("a4294967295", buf.String())
+}
+
+func Test_write_int64(t *testing.T) {
+	vals := []int64{0, 1, 11, 111, 255, 999999, 0xfff, 0xffff, 0xfffff, 0xffffff, 0xfffffff, 0xffffffff,
+		0xfffffffff, 0xffffffffff, 0xfffffffffff, 0xffffffffffff, 0xfffffffffffff, 0xffffffffffffff,
+		0xfffffffffffffff, 0x7fffffffffffffff, -0x8000000000000000}
+	for _, val := range vals {
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteInt64(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatInt(val, 10), buf.String())
+		})
+		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
+			should := require.New(t)
+			buf := &bytes.Buffer{}
+			stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 4096)
+			stream.WriteVal(val)
+			stream.Flush()
+			should.Nil(stream.Error)
+			should.Equal(strconv.FormatInt(val, 10), buf.String())
+		})
+	}
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, buf, 10)
+	stream.WriteRaw("a")
+	stream.WriteInt64(0xffffffff) // should clear buffer
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("a4294967295", buf.String())
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/invalid_test.go b/vendor/github.com/json-iterator/go/value_tests/invalid_test.go
new file mode 100644
index 000000000..5b594a95b
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/invalid_test.go
@@ -0,0 +1,226 @@
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"io"
+	"testing"
+)
+
+func Test_missing_object_end(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct {
+		Metric string                 `json:"metric"`
+		Tags   map[string]interface{} `json:"tags"`
+	}
+	obj := TestObject{}
+	should.NotNil(jsoniter.UnmarshalFromString(`{"metric": "sys.777","tags": {"a":"123"}`, &obj))
+}
+
+func Test_missing_array_end(t *testing.T) {
+	should := require.New(t)
+	should.NotNil(jsoniter.UnmarshalFromString(`[1,2,3`, &[]int{}))
+}
+
+func Test_invalid_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[]"))
+	should.Equal(jsoniter.InvalidValue, any.Get(0.3).ValueType())
+	// is nil correct ?
+	should.Equal(nil, any.Get(0.3).GetInterface())
+
+	any = any.Get(0.3)
+	should.Equal(false, any.ToBool())
+	should.Equal(int(0), any.ToInt())
+	should.Equal(int32(0), any.ToInt32())
+	should.Equal(int64(0), any.ToInt64())
+	should.Equal(uint(0), any.ToUint())
+	should.Equal(uint32(0), any.ToUint32())
+	should.Equal(uint64(0), any.ToUint64())
+	should.Equal(float32(0), any.ToFloat32())
+	should.Equal(float64(0), any.ToFloat64())
+	should.Equal("", any.ToString())
+
+	should.Equal(jsoniter.InvalidValue, any.Get(0.1).Get(1).ValueType())
+}
+
+func Test_invalid_struct_input(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct{}
+	input := []byte{54, 141, 30}
+	obj := TestObject{}
+	should.NotNil(jsoniter.Unmarshal(input, &obj))
+}
+
+func Test_invalid_slice_input(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct{}
+	input := []byte{93}
+	obj := []string{}
+	should.NotNil(jsoniter.Unmarshal(input, &obj))
+}
+
+func Test_invalid_array_input(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct{}
+	input := []byte{93}
+	obj := [0]string{}
+	should.NotNil(jsoniter.Unmarshal(input, &obj))
+}
+
+func Test_invalid_float(t *testing.T) {
+	inputs := []string{
+		`1.e1`, // dot without following digit
+		`1.`,   // dot can not be the last char
+		``,     // empty number
+		`01`,   // extra leading zero
+		`-`,    // negative without digit
+		`--`,   // double negative
+		`--2`,  // double negative
+	}
+	for _, input := range inputs {
+		t.Run(input, func(t *testing.T) {
+			should := require.New(t)
+			iter := jsoniter.ParseString(jsoniter.ConfigDefault, input+",")
+			iter.Skip()
+			should.NotEqual(io.EOF, iter.Error)
+			should.NotNil(iter.Error)
+			v := float64(0)
+			should.NotNil(json.Unmarshal([]byte(input), &v))
+			iter = jsoniter.ParseString(jsoniter.ConfigDefault, input+",")
+			iter.ReadFloat64()
+			should.NotEqual(io.EOF, iter.Error)
+			should.NotNil(iter.Error)
+			iter = jsoniter.ParseString(jsoniter.ConfigDefault, input+",")
+			iter.ReadFloat32()
+			should.NotEqual(io.EOF, iter.Error)
+			should.NotNil(iter.Error)
+		})
+	}
+}
+
+func Test_chan(t *testing.T) {
+	t.Skip("do not support chan")
+
+	type TestObject struct {
+		MyChan  chan bool
+		MyField int
+	}
+
+	should := require.New(t)
+	obj := TestObject{}
+	str, err := json.Marshal(obj)
+	should.Nil(err)
+	should.Equal(``, str)
+}
+
+func Test_invalid_number(t *testing.T) {
+	type Message struct {
+		Number int `json:"number"`
+	}
+	obj := Message{}
+	decoder := jsoniter.ConfigCompatibleWithStandardLibrary.NewDecoder(bytes.NewBufferString(`{"number":"5"}`))
+	err := decoder.Decode(&obj)
+	invalidStr := err.Error()
+	result, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(invalidStr)
+	should := require.New(t)
+	should.Nil(err)
+	result2, err := json.Marshal(invalidStr)
+	should.Nil(err)
+	should.Equal(string(result2), string(result))
+}
+
+func Test_valid(t *testing.T) {
+	should := require.New(t)
+	should.True(jsoniter.Valid([]byte(`{}`)))
+	should.False(jsoniter.Valid([]byte(`{`)))
+}
+
+func Test_nil_pointer(t *testing.T) {
+	should := require.New(t)
+	data := []byte(`{"A":0}`)
+	type T struct {
+		X int
+	}
+	var obj *T
+	err := jsoniter.Unmarshal(data, obj)
+	should.NotNil(err)
+}
+
+func Test_func_pointer_type(t *testing.T) {
+	type TestObject2 struct {
+		F func()
+	}
+	type TestObject1 struct {
+		Obj *TestObject2
+	}
+	t.Run("encode null is valid", func(t *testing.T) {
+		should := require.New(t)
+		output, err := json.Marshal(TestObject1{})
+		should.Nil(err)
+		should.Equal(`{"Obj":null}`, string(output))
+		output, err = jsoniter.Marshal(TestObject1{})
+		should.Nil(err)
+		should.Equal(`{"Obj":null}`, string(output))
+	})
+	t.Run("encode not null is invalid", func(t *testing.T) {
+		should := require.New(t)
+		_, err := json.Marshal(TestObject1{Obj: &TestObject2{}})
+		should.NotNil(err)
+		_, err = jsoniter.Marshal(TestObject1{Obj: &TestObject2{}})
+		should.NotNil(err)
+	})
+	t.Run("decode null is valid", func(t *testing.T) {
+		should := require.New(t)
+		var obj TestObject1
+		should.Nil(json.Unmarshal([]byte(`{"Obj":{"F": null}}`), &obj))
+		should.Nil(jsoniter.Unmarshal([]byte(`{"Obj":{"F": null}}`), &obj))
+	})
+	t.Run("decode not null is invalid", func(t *testing.T) {
+		should := require.New(t)
+		var obj TestObject1
+		should.NotNil(json.Unmarshal([]byte(`{"Obj":{"F": "hello"}}`), &obj))
+		should.NotNil(jsoniter.Unmarshal([]byte(`{"Obj":{"F": "hello"}}`), &obj))
+	})
+}
+
+func TestEOF(t *testing.T) {
+	var s string
+	err := jsoniter.ConfigCompatibleWithStandardLibrary.NewDecoder(&bytes.Buffer{}).Decode(&s)
+	assert.Equal(t, io.EOF, err)
+}
+
+func TestDecodeErrorType(t *testing.T) {
+	should := require.New(t)
+	var err error
+	should.Nil(jsoniter.Unmarshal([]byte("null"), &err))
+	should.NotNil(jsoniter.Unmarshal([]byte("123"), &err))
+}
+
+func Test_decode_slash(t *testing.T) {
+	should := require.New(t)
+	var obj interface{}
+	should.NotNil(json.Unmarshal([]byte("\\"), &obj))
+	should.NotNil(jsoniter.UnmarshalFromString("\\", &obj))
+}
+
+func Test_NilInput(t *testing.T) {
+	var jb []byte // nil
+	var out string
+	err := jsoniter.Unmarshal(jb, &out)
+	if err == nil {
+		t.Errorf("Expected error")
+	}
+}
+
+func Test_EmptyInput(t *testing.T) {
+	jb := []byte("")
+	var out string
+	err := jsoniter.Unmarshal(jb, &out)
+	if err == nil {
+		t.Errorf("Expected error")
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/map_test.go b/vendor/github.com/json-iterator/go/value_tests/map_test.go
new file mode 100644
index 000000000..24cf98ed3
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/map_test.go
@@ -0,0 +1,51 @@
+package test
+
+import (
+	"encoding/json"
+	"math/big"
+)
+
+func init() {
+	var pRawMessage = func(val json.RawMessage) *json.RawMessage {
+		return &val
+	}
+	nilMap := map[string]string(nil)
+	marshalCases = append(marshalCases,
+		map[string]interface{}{"abc": 1},
+		map[string]MyInterface{"hello": MyString("world")},
+		map[*big.Float]string{big.NewFloat(1.2): "2"},
+		map[string]interface{}{
+			"3": 3,
+			"1": 1,
+			"2": 2,
+		},
+		map[uint64]interface{}{
+			uint64(1): "a",
+			uint64(2): "a",
+			uint64(4): "a",
+		},
+		nilMap,
+		&nilMap,
+		map[string]*json.RawMessage{"hello": pRawMessage(json.RawMessage("[]"))},
+	)
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		ptr:   (*map[string]string)(nil),
+		input: `{"k\"ey": "val"}`,
+	}, unmarshalCase{
+		ptr:   (*map[string]string)(nil),
+		input: `null`,
+	}, unmarshalCase{
+		ptr:   (*map[string]*json.RawMessage)(nil),
+		input: "{\"test\":[{\"key\":\"value\"}]}",
+	})
+}
+
+type MyInterface interface {
+	Hello() string
+}
+
+type MyString string
+
+func (ms MyString) Hello() string {
+	return string(ms)
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/marshaler_test.go b/vendor/github.com/json-iterator/go/value_tests/marshaler_test.go
new file mode 100644
index 000000000..5459495c9
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/marshaler_test.go
@@ -0,0 +1,84 @@
+package test
+
+import (
+	"encoding"
+	"encoding/json"
+)
+
+func init() {
+	jm := json.Marshaler(jmOfStruct{})
+	tm1 := encoding.TextMarshaler(tmOfStruct{})
+	tm2 := encoding.TextMarshaler(&tmOfStructInt{})
+	marshalCases = append(marshalCases,
+		jmOfStruct{},
+		&jm,
+		tmOfStruct{},
+		&tm1,
+		tmOfStructInt{},
+		&tm2,
+		map[tmOfStruct]int{
+			{}: 100,
+		},
+		map[*tmOfStruct]int{
+			{}: 100,
+		},
+		map[encoding.TextMarshaler]int{
+			tm1: 100,
+		},
+	)
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		ptr:   (*tmOfMap)(nil),
+		input: `"{1:2}"`,
+	}, unmarshalCase{
+		ptr:   (*tmOfMapPtr)(nil),
+		input: `"{1:2}"`,
+	})
+}
+
+type jmOfStruct struct {
+	F2 chan []byte
+}
+
+func (q jmOfStruct) MarshalJSON() ([]byte, error) {
+	return []byte(`""`), nil
+}
+
+func (q *jmOfStruct) UnmarshalJSON(value []byte) error {
+	return nil
+}
+
+type tmOfStruct struct {
+	F2 chan []byte
+}
+
+func (q tmOfStruct) MarshalText() ([]byte, error) {
+	return []byte(`""`), nil
+}
+
+func (q *tmOfStruct) UnmarshalText(value []byte) error {
+	return nil
+}
+
+type tmOfStructInt struct {
+	Field2 int
+}
+
+func (q *tmOfStructInt) MarshalText() ([]byte, error) {
+	return []byte(`"abc"`), nil
+}
+
+func (q *tmOfStructInt) UnmarshalText(value []byte) error {
+	return nil
+}
+
+type tmOfMap map[int]int
+
+func (q tmOfMap) UnmarshalText(value []byte) error {
+	return nil
+}
+
+type tmOfMapPtr map[int]int
+
+func (q *tmOfMapPtr) UnmarshalText(value []byte) error {
+	return nil
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/number_test.go b/vendor/github.com/json-iterator/go/value_tests/number_test.go
new file mode 100644
index 000000000..98ab4b5a4
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/number_test.go
@@ -0,0 +1,17 @@
+package test
+
+import "encoding/json"
+
+func init() {
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		ptr:   (*json.Number)(nil),
+		input: `"500"`,
+	}, unmarshalCase{
+		ptr:   (*json.Number)(nil),
+		input: `1`,
+	}, unmarshalCase{
+		ptr:   (*json.Number)(nil),
+		input: `null`,
+	})
+	marshalCases = append(marshalCases, json.Number(""))
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/ptr_test.go b/vendor/github.com/json-iterator/go/value_tests/ptr_test.go
new file mode 100644
index 000000000..222b2d43a
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/ptr_test.go
@@ -0,0 +1,39 @@
+package test
+
+func init() {
+	var pInt = func(val int) *int {
+		return &val
+	}
+	marshalCases = append(marshalCases,
+		(*int)(nil),
+		pInt(100),
+	)
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		obj: func() interface{} {
+			var i int
+			return &i
+		},
+		input: "null",
+	}, unmarshalCase{
+		obj: func() interface{} {
+			var i *int
+			return &i
+		},
+		input: "10",
+	}, unmarshalCase{
+		obj: func() interface{} {
+			var i int
+			pi := &i
+			return &pi
+		},
+		input: "null",
+	}, unmarshalCase{
+		obj: func() interface{} {
+			var i int
+			pi := &i
+			ppi := &pi
+			return &ppi
+		},
+		input: "null",
+	})
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/raw_message_test.go b/vendor/github.com/json-iterator/go/value_tests/raw_message_test.go
new file mode 100644
index 000000000..210451d20
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/raw_message_test.go
@@ -0,0 +1,13 @@
+package test
+
+import "encoding/json"
+
+func init() {
+	marshalCases = append(marshalCases,
+		json.RawMessage("{}"),
+	)
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		ptr:   (*json.RawMessage)(nil),
+		input: `[1,2,3]`,
+	})
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/slice_test.go b/vendor/github.com/json-iterator/go/value_tests/slice_test.go
new file mode 100644
index 000000000..f504e851e
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/slice_test.go
@@ -0,0 +1,24 @@
+package test
+
+func init() {
+	nilSlice := []string(nil)
+	marshalCases = append(marshalCases,
+		[]interface{}{"hello"},
+		nilSlice,
+		&nilSlice,
+		[]byte{1, 2, 3},
+	)
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		ptr:   (*[]string)(nil),
+		input: "null",
+	}, unmarshalCase{
+		ptr:   (*[]string)(nil),
+		input: "[]",
+	}, unmarshalCase{
+		ptr:   (*[]byte)(nil),
+		input: "[1,2,3]",
+	}, unmarshalCase{
+		ptr:   (*[]byte)(nil),
+		input: `"aGVsbG8="`,
+	})
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/string_test.go b/vendor/github.com/json-iterator/go/value_tests/string_test.go
new file mode 100644
index 000000000..5f34f9d88
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/string_test.go
@@ -0,0 +1,88 @@
+package test
+
+import (
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"testing"
+	"unicode/utf8"
+)
+
+func init() {
+	marshalCases = append(marshalCases,
+		`>`,
+		`"数字山谷"`,
+		"he\u2029\u2028he",
+	)
+	for i := 0; i < utf8.RuneSelf; i++ {
+		marshalCases = append(marshalCases, string([]byte{byte(i)}))
+	}
+}
+
+func Test_read_string(t *testing.T) {
+	badInputs := []string{
+		``,
+		`"`,
+		`"\"`,
+		`"\\\"`,
+		"\"\n\"",
+		`"\U0001f64f"`,
+		`"\uD83D\u00"`,
+	}
+	for i := 0; i < 32; i++ {
+		// control characters are invalid
+		badInputs = append(badInputs, string([]byte{'"', byte(i), '"'}))
+	}
+
+	for _, input := range badInputs {
+		testReadString(t, input, "", true, "json.Unmarshal", json.Unmarshal)
+		testReadString(t, input, "", true, "jsoniter.Unmarshal", jsoniter.Unmarshal)
+		testReadString(t, input, "", true, "jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
+	}
+
+	goodInputs := []struct {
+		input       string
+		expectValue string
+	}{
+		{`""`, ""},
+		{`"a"`, "a"},
+		{`null`, ""},
+		{`"Iñtërnâtiônàlizætiøn,💝🐹🌇⛔"`, "Iñtërnâtiônàlizætiøn,💝🐹🌇⛔"},
+		{`"\uD83D"`, string([]byte{239, 191, 189})},
+		{`"\uD83D\\"`, string([]byte{239, 191, 189, '\\'})},
+		{`"\uD83D\ub000"`, string([]byte{239, 191, 189, 235, 128, 128})},
+		{`"\uD83D\ude04"`, "😄"},
+		{`"\uDEADBEEF"`, string([]byte{239, 191, 189, 66, 69, 69, 70})},
+		{`"hel\"lo"`, `hel"lo`},
+		{`"hel\\\/lo"`, `hel\/lo`},
+		{`"hel\\blo"`, `hel\blo`},
+		{`"hel\\\blo"`, "hel\\\blo"},
+		{`"hel\\nlo"`, `hel\nlo`},
+		{`"hel\\\nlo"`, "hel\\\nlo"},
+		{`"hel\\tlo"`, `hel\tlo`},
+		{`"hel\\flo"`, `hel\flo`},
+		{`"hel\\\flo"`, "hel\\\flo"},
+		{`"hel\\\rlo"`, "hel\\\rlo"},
+		{`"hel\\\tlo"`, "hel\\\tlo"},
+		{`"\u4e2d\u6587"`, "中文"},
+		{`"\ud83d\udc4a"`, "\xf0\x9f\x91\x8a"},
+	}
+
+	for _, tc := range goodInputs {
+		testReadString(t, tc.input, tc.expectValue, false, "json.Unmarshal", json.Unmarshal)
+		testReadString(t, tc.input, tc.expectValue, false, "jsoniter.Unmarshal", jsoniter.Unmarshal)
+		testReadString(t, tc.input, tc.expectValue, false, "jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
+	}
+}
+
+func testReadString(t *testing.T, input string, expectValue string, expectError bool, marshalerName string, marshaler func([]byte, interface{}) error) {
+	var value string
+	err := marshaler([]byte(input), &value)
+	if expectError != (err != nil) {
+		t.Errorf("%q: %s: expected error %v, got %v", input, marshalerName, expectError, err)
+		return
+	}
+	if value != expectValue {
+		t.Errorf("%q: %s: expected %q, got %q", input, marshalerName, expectValue, value)
+		return
+	}
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/struct_test.go b/vendor/github.com/json-iterator/go/value_tests/struct_test.go
new file mode 100644
index 000000000..2335d0786
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/struct_test.go
@@ -0,0 +1,200 @@
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"time"
+)
+
+func init() {
+	var pString = func(val string) *string {
+		return &val
+	}
+	epoch := time.Unix(0, 0)
+	unmarshalCases = append(unmarshalCases, unmarshalCase{
+		ptr: (*struct {
+			Field interface{}
+		})(nil),
+		input: `{"Field": "hello"}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			Field interface{}
+		})(nil),
+		input: `{"Field": "hello"}       `,
+	}, unmarshalCase{
+		ptr: (*struct {
+			Field int `json:"field"`
+		})(nil),
+		input: `{"field": null}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			ID      int                    `json:"id"`
+			Payload map[string]interface{} `json:"payload"`
+			buf     *bytes.Buffer
+		})(nil),
+		input: ` {"id":1, "payload":{"account":"123","password":"456"}}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			Field1 string
+		})(nil),
+		input: `{"Field\"1":"hello"}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			Field1 string
+		})(nil),
+		input: `{"\u0046ield1":"hello"}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			Field1 *string
+			Field2 *string
+		})(nil),
+		input: `{"field1": null, "field2": "world"}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			Field1 string
+			Field2 json.RawMessage
+		})(nil),
+		input: `{"field1": "hello", "field2":[1,2,3]}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			a int
+			b <-chan int
+			C int
+			d *time.Timer
+		})(nil),
+		input: `{"a": 444, "b":"bad", "C":256, "d":{"not":"a timer"}}`,
+	})
+	marshalCases = append(marshalCases,
+		struct {
+			Field map[string]interface{}
+		}{
+			map[string]interface{}{"hello": "world"},
+		},
+		struct {
+			Field  map[string]interface{}
+			Field2 string
+		}{
+			map[string]interface{}{"hello": "world"}, "",
+		},
+		struct {
+			Field interface{}
+		}{
+			1024,
+		},
+		struct {
+			Field MyInterface
+		}{
+			MyString("hello"),
+		},
+		struct {
+			F *float64
+		}{},
+		struct {
+			*time.Time
+		}{&epoch},
+		struct {
+			*StructVarious
+		}{&StructVarious{}},
+		struct {
+			*StructVarious
+			Field int
+		}{nil, 10},
+		struct {
+			Field1 int
+			Field2 [1]*float64
+		}{},
+		struct {
+			Field interface{} `json:"field,omitempty"`
+		}{},
+		struct {
+			Field MyInterface `json:"field,omitempty"`
+		}{},
+		struct {
+			Field MyInterface `json:"field,omitempty"`
+		}{MyString("hello")},
+		struct {
+			Field json.Marshaler `json:"field"`
+		}{},
+		struct {
+			Field MyInterface `json:"field"`
+		}{},
+		struct {
+			Field MyInterface `json:"field"`
+		}{MyString("hello")},
+		struct {
+			Field1 string `json:"field-1,omitempty"`
+			Field2 func() `json:"-"`
+		}{},
+		structRecursive{},
+		struct {
+			*CacheItem
+
+			// Omit bad keys
+			OmitMaxAge omit `json:"cacheAge,omitempty"`
+
+			// Add nice keys
+			MaxAge int `json:"max_age"`
+		}{
+			CacheItem: &CacheItem{
+				Key:    "value",
+				MaxAge: 100,
+			},
+			MaxAge: 20,
+		},
+		structOrder{},
+		struct {
+			Field1 *string
+			Field2 *string
+		}{Field2: pString("world")},
+		struct {
+			a int
+			b <-chan int
+			C int
+			d *time.Timer
+		}{
+			a: 42,
+			b: make(<-chan int, 10),
+			C: 21,
+			d: time.NewTimer(10 * time.Second),
+		},
+	)
+}
+
+type StructVarious struct {
+	Field0 string
+	Field1 []string
+	Field2 map[string]interface{}
+}
+
+type structRecursive struct {
+	Field1 string
+	Me     *structRecursive
+}
+
+type omit *struct{}
+type CacheItem struct {
+	Key    string `json:"key"`
+	MaxAge int    `json:"cacheAge"`
+}
+
+type orderA struct {
+	Field2 string
+}
+
+type orderC struct {
+	Field5 string
+}
+
+type orderB struct {
+	Field4 string
+	orderC
+	Field6 string
+}
+
+type structOrder struct {
+	Field1 string
+	orderA
+	Field3 string
+	orderB
+	Field7 string
+}
diff --git a/vendor/github.com/json-iterator/go/value_tests/value_test.go b/vendor/github.com/json-iterator/go/value_tests/value_test.go
new file mode 100644
index 000000000..95cfdd568
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/value_tests/value_test.go
@@ -0,0 +1,80 @@
+package test
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/json-iterator/go"
+	"github.com/modern-go/reflect2"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+type unmarshalCase struct {
+	obj      func() interface{}
+	ptr      interface{}
+	input    string
+	selected bool
+}
+
+var unmarshalCases []unmarshalCase
+
+var marshalCases = []interface{}{
+	nil,
+}
+
+type selectedMarshalCase struct {
+	marshalCase interface{}
+}
+
+func Test_unmarshal(t *testing.T) {
+	for _, testCase := range unmarshalCases {
+		if testCase.selected {
+			unmarshalCases = []unmarshalCase{testCase}
+			break
+		}
+	}
+	for i, testCase := range unmarshalCases {
+		t.Run(fmt.Sprintf("[%v]%s", i, testCase.input), func(t *testing.T) {
+			should := require.New(t)
+			var obj1 interface{}
+			var obj2 interface{}
+			if testCase.obj != nil {
+				obj1 = testCase.obj()
+				obj2 = testCase.obj()
+			} else {
+				valType := reflect2.TypeOfPtr(testCase.ptr).Elem()
+				obj1 = valType.New()
+				obj2 = valType.New()
+			}
+			err1 := json.Unmarshal([]byte(testCase.input), obj1)
+			should.NoError(err1, "json")
+			err2 := jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal([]byte(testCase.input), obj2)
+			should.NoError(err2, "jsoniter")
+			should.Equal(obj1, obj2)
+		})
+	}
+}
+
+func Test_marshal(t *testing.T) {
+	for _, testCase := range marshalCases {
+		selectedMarshalCase, found := testCase.(selectedMarshalCase)
+		if found {
+			marshalCases = []interface{}{selectedMarshalCase.marshalCase}
+			break
+		}
+	}
+	for i, testCase := range marshalCases {
+		var name string
+		if testCase != nil {
+			name = fmt.Sprintf("[%v]%v/%s", i, testCase, reflect2.TypeOf(testCase).String())
+		}
+		t.Run(name, func(t *testing.T) {
+			should := require.New(t)
+			output1, err1 := json.Marshal(testCase)
+			should.NoError(err1, "json")
+			output2, err2 := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(testCase)
+			should.NoError(err2, "jsoniter")
+			should.Equal(string(output1), string(output2))
+		})
+	}
+}