fix coverage

The use of strconv.FormatFloat causes a string allocation,
by setting aside a reusable buffer and using strconv.AppendFloat
this can be avoided.

Before:
BenchmarkRespond-4           300           5392189 ns/op          618936 B/op      20010 allocs/op

After:
BenchmarkRespond-4           300           4713746 ns/op          139744 B/op         10 allocs/op

This benchmark is using a custom encoder that calls WriteFloat64 20k
times, which is the bulk of the work.

README.md

@@ -8,6 +8,8 @@
 
 A high-performance 100% compatible drop-in replacement of "encoding/json"
 
+You can also use thrift like JSON using [thrift-iterator](https://github.com/thrift-iterator/go)
+
 ```
 Go开发者们请加入我们，滴滴出行平台技术部 taowen@didichuxing.com
 ```

any_tests/jsoniter_any_array_test.go

@@ -1,18 +1,19 @@
-package jsoniter
+package any_tests
 
 import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
 )
 
 func Test_read_empty_array_as_any(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte("[]"))
-	should.Equal(ArrayValue, any.Get().ValueType())
-	should.Equal(InvalidValue, any.Get(0.3).ValueType())
+	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(ArrayValue, any.ValueType())
+	should.Equal(jsoniter.ArrayValue, any.ValueType())
 	should.Nil(any.LastError())
 	should.Equal(0, any.ToInt())
 	should.Equal(int32(0), any.ToInt32())
@@ -26,19 +27,19 @@ func Test_read_empty_array_as_any(t *testing.T) {
 
 func Test_read_one_element_array_as_any(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte("[1]"))
+	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 := Get([]byte("[1,2]"))
+	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 := NewStream(ConfigDefault, nil, 32)
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
 	any.WriteTo(stream)
 	should.Equal("[1,2]", string(stream.Buffer()))
 	arr := []int{}
@@ -48,8 +49,8 @@ func Test_read_two_element_array_as_any(t *testing.T) {
 
 func Test_wrap_array_and_convert_to_any(t *testing.T) {
 	should := require.New(t)
-	any := Wrap([]int{1, 2, 3})
-	any2 := Wrap([]int{})
+	any := jsoniter.Wrap([]int{1, 2, 3})
+	any2 := jsoniter.Wrap([]int{})
 
 	should.Equal("[1,2,3]", any.ToString())
 	should.True(any.ToBool())
@@ -80,43 +81,43 @@ func Test_wrap_array_and_convert_to_any(t *testing.T) {
 
 func Test_array_lazy_any_get(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte("[1,[2,3],4]"))
+	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 := Get([]byte("[[1],[2],[3,4]]"))
+	any := jsoniter.Get([]byte("[[1],[2],[3,4]]"))
 	should.Equal("[1,2,3]", any.Get('*', 0).ToString())
-	any = Get([]byte("[[[1],[2],[3,4]]]"), 0, '*', 0)
+	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 := wrapArray([][]int{
+	any := jsoniter.Wrap([][]int{
 		{1, 2},
 		{3, 4},
 		{5, 6},
 	})
 	should.Equal("[1,3,5]", any.Get('*', 0).ToString())
-	should.Equal(ArrayValue, any.ValueType())
+	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 := Get([]byte("[]"))
-	should.Equal(InvalidValue, any.Get(1, 1).ValueType())
+	any := jsoniter.Get([]byte("[]"))
+	should.Equal(jsoniter.InvalidValue, any.Get(1, 1).ValueType())
 	should.NotNil(any.Get(1, 1).LastError())
-	should.Equal(InvalidValue, any.Get("1").ValueType())
+	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 := Get([]byte("["), 0)
-	should.Equal(InvalidValue, any.ValueType())
+	any := jsoniter.Get([]byte("["), 0)
+	should.Equal(jsoniter.InvalidValue, any.ValueType())
 }

any_tests/jsoniter_any_bool_test.go

@@ -1,10 +1,11 @@
-package jsoniter
+package any_tests
 
 import (
 	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
 )
 
 var boolConvertMap = map[string]bool{
@@ -35,9 +36,9 @@ var boolConvertMap = map[string]bool{
 func Test_read_bool_as_any(t *testing.T) {
 	should := require.New(t)
 
-	var any Any
+	var any jsoniter.Any
 	for k, v := range boolConvertMap {
-		any = Get([]byte(k))
+		any = jsoniter.Get([]byte(k))
 		if v {
 			should.True(any.ToBool(), fmt.Sprintf("origin val is %v", k))
 		} else {
@@ -49,16 +50,16 @@ func Test_read_bool_as_any(t *testing.T) {
 
 func Test_write_bool_to_stream(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte("true"))
-	stream := NewStream(ConfigDefault, nil, 32)
+	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(), BoolValue)
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
 
-	any = Get([]byte("false"))
-	stream = NewStream(ConfigDefault, nil, 32)
+	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(), BoolValue)
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
 }

any_tests/jsoniter_any_float_test.go

@@ -1,9 +1,10 @@
-package jsoniter
+package any_tests
 
 import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
 )
 
 var floatConvertMap = map[string]float64{
@@ -67,22 +68,22 @@ var floatConvertMap = map[string]float64{
 func Test_read_any_to_float(t *testing.T) {
 	should := require.New(t)
 	for k, v := range floatConvertMap {
-		any := Get([]byte(k))
+		any := jsoniter.Get([]byte(k))
 		should.Equal(float64(v), any.ToFloat64(), "the original val is "+k)
 	}
 
 	for k, v := range floatConvertMap {
-		any := Get([]byte(k))
+		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 := WrapFloat64(12.3)
+	any := jsoniter.WrapFloat64(12.3)
 	anyFloat64 := float64(12.3)
 	//negaAnyFloat64 := float64(-1.1)
-	any2 := WrapFloat64(-1.1)
+	any2 := jsoniter.WrapFloat64(-1.1)
 	should.Equal(float64(12.3), any.ToFloat64())
 	//should.Equal("12.3", any.ToString())
 	should.True(any.ToBool())
@@ -96,7 +97,7 @@ func Test_read_float_to_any(t *testing.T) {
 	should.Equal(uint(0), any2.ToUint())
 	should.Equal(uint32(0), any2.ToUint32())
 	should.Equal(uint64(0), any2.ToUint64())
-	should.Equal(any.ValueType(), NumberValue)
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
 
 	should.Equal("1.23E+01", any.ToString())
 }

any_tests/jsoniter_any_int_test.go

@@ -1,10 +1,11 @@
-package jsoniter
+package any_tests
 
 import (
 	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
 )
 
 var intConvertMap = map[string]int{
@@ -41,19 +42,19 @@ func Test_read_any_to_int(t *testing.T) {
 
 	// int
 	for k, v := range intConvertMap {
-		any := Get([]byte(k))
+		any := jsoniter.Get([]byte(k))
 		should.Equal(v, any.ToInt(), fmt.Sprintf("origin val %v", k))
 	}
 
 	// int32
 	for k, v := range intConvertMap {
-		any := Get([]byte(k))
+		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 := Get([]byte(k))
+		any := jsoniter.Get([]byte(k))
 		should.Equal(int64(v), any.ToInt64(), fmt.Sprintf("original val is %v", k))
 	}
 
@@ -94,17 +95,17 @@ func Test_read_any_to_uint(t *testing.T) {
 	should := require.New(t)
 
 	for k, v := range uintConvertMap {
-		any := Get([]byte(k))
+		any := jsoniter.Get([]byte(k))
 		should.Equal(uint64(v), any.ToUint64(), fmt.Sprintf("origin val %v", k))
 	}
 
 	for k, v := range uintConvertMap {
-		any := Get([]byte(k))
+		any := jsoniter.Get([]byte(k))
 		should.Equal(uint32(v), any.ToUint32(), fmt.Sprintf("origin val %v", k))
 	}
 
 	for k, v := range uintConvertMap {
-		any := Get([]byte(k))
+		any := jsoniter.Get([]byte(k))
 		should.Equal(uint(v), any.ToUint(), fmt.Sprintf("origin val %v", k))
 	}
 
@@ -112,7 +113,7 @@ func Test_read_any_to_uint(t *testing.T) {
 
 func Test_read_int64_to_any(t *testing.T) {
 	should := require.New(t)
-	any := WrapInt64(12345)
+	any := jsoniter.WrapInt64(12345)
 	should.Equal(12345, any.ToInt())
 	should.Equal(int32(12345), any.ToInt32())
 	should.Equal(int64(12345), any.ToInt64())
@@ -123,14 +124,14 @@ func Test_read_int64_to_any(t *testing.T) {
 	should.Equal(float64(12345), any.ToFloat64())
 	should.Equal("12345", any.ToString())
 	should.Equal(true, any.ToBool())
-	should.Equal(any.ValueType(), NumberValue)
-	stream := NewStream(ConfigDefault, nil, 32)
+	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 := WrapInt32(12345)
+	any := jsoniter.WrapInt32(12345)
 	should.Equal(12345, any.ToInt())
 	should.Equal(int32(12345), any.ToInt32())
 	should.Equal(int64(12345), any.ToInt64())
@@ -141,15 +142,15 @@ func Test_read_int32_to_any(t *testing.T) {
 	should.Equal(float64(12345), any.ToFloat64())
 	should.Equal("12345", any.ToString())
 	should.Equal(true, any.ToBool())
-	should.Equal(any.ValueType(), NumberValue)
-	stream := NewStream(ConfigDefault, nil, 32)
+	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 := WrapUint32(12345)
+	any := jsoniter.WrapUint32(12345)
 	should.Equal(12345, any.ToInt())
 	should.Equal(int32(12345), any.ToInt32())
 	should.Equal(int64(12345), any.ToInt64())
@@ -160,15 +161,15 @@ func Test_read_uint32_to_any(t *testing.T) {
 	should.Equal(float64(12345), any.ToFloat64())
 	should.Equal("12345", any.ToString())
 	should.Equal(true, any.ToBool())
-	should.Equal(any.ValueType(), NumberValue)
-	stream := NewStream(ConfigDefault, nil, 32)
+	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 := WrapUint64(12345)
+	any := jsoniter.WrapUint64(12345)
 	should.Equal(12345, any.ToInt())
 	should.Equal(int32(12345), any.ToInt32())
 	should.Equal(int64(12345), any.ToInt64())
@@ -179,19 +180,19 @@ func Test_read_uint64_to_any(t *testing.T) {
 	should.Equal(float64(12345), any.ToFloat64())
 	should.Equal("12345", any.ToString())
 	should.Equal(true, any.ToBool())
-	should.Equal(any.ValueType(), NumberValue)
-	stream := NewStream(ConfigDefault, nil, 32)
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
 	any.WriteTo(stream)
 	should.Equal("12345", string(stream.Buffer()))
-	stream = NewStream(ConfigDefault, nil, 32)
+	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 := Get([]byte("1234"))
+	any := jsoniter.Get([]byte("1234"))
 	// panic!!
 	//should.Equal(any.LastError(), io.EOF)
-	should.Equal(InvalidValue, any.Get(1, "2").ValueType())
+	should.Equal(jsoniter.InvalidValue, any.Get(1, "2").ValueType())
 }

any_tests/jsoniter_any_map_test.go

@@ -0,0 +1,28 @@
+package any_tests
+
+import (
+	"github.com/stretchr/testify/require"
+	"testing"
+	"github.com/json-iterator/go"
+)
+
+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), "")
+}

any_tests/jsoniter_any_null_test.go

@@ -1,13 +1,14 @@
-package jsoniter
+package any_tests
 
 import (
 	"github.com/stretchr/testify/require"
 	"testing"
+	"github.com/json-iterator/go"
 )
 
 func Test_read_null_as_any(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte(`null`))
+	any := jsoniter.Get([]byte(`null`))
 	should.Equal(0, any.ToInt())
 	should.Equal(float64(0), any.ToFloat64())
 	should.Equal("", any.ToString())

any_tests/jsoniter_any_object_test.go

@@ -1,26 +1,27 @@
-package jsoniter
+package any_tests
 
 import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
 )
 
 func Test_read_object_as_any(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte(`{"a":"stream","c":"d"}`))
+	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 = Get([]byte(`{"a":"stream","c":"d"}`))
+	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(ObjectValue, any.ValueType())
+	should.Equal(jsoniter.ObjectValue, any.ValueType())
 	should.Nil(any.LastError())
 	obj := struct {
 		A string
@@ -31,26 +32,26 @@ func Test_read_object_as_any(t *testing.T) {
 
 func Test_object_lazy_any_get(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte(`{"a":{"stream":{"c":"d"}}}`))
+	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 := Get([]byte(`{"a":[0],"stream":[1]}`))
+	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 := Get([]byte(`{}`))
-	should.Equal(InvalidValue, any.Get("a", "stream", "c").ValueType())
-	should.Equal(InvalidValue, any.Get(1).ValueType())
+	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 := Wrap(map[string]interface{}{"a": 1})
+	any := jsoniter.Wrap(map[string]interface{}{"a": 1})
 	should.True(any.ToBool())
 	should.Equal(0, any.ToInt())
 	should.Equal(int32(0), any.ToInt32())
@@ -68,9 +69,9 @@ func Test_wrap_object_and_convert_to_any(t *testing.T) {
 		Field1 string
 		field2 string
 	}
-	any := Wrap(TestObject{"hello", "world"})
+	any := jsoniter.Wrap(TestObject{"hello", "world"})
 	should.Equal("hello", any.Get("Field1").ToString())
-	any = Wrap(TestObject{"hello", "world"})
+	any = jsoniter.Wrap(TestObject{"hello", "world"})
 	should.Equal(2, any.Size())
 	should.Equal(`{"Field1":"hello"}`, any.Get('*').ToString())
 
@@ -96,12 +97,27 @@ func Test_wrap_object_and_convert_to_any(t *testing.T) {
 func Test_any_within_struct(t *testing.T) {
 	should := require.New(t)
 	type TestObject struct {
-		Field1 Any
-		Field2 Any
+		Field1 jsoniter.Any
+		Field2 jsoniter.Any
 	}
 	obj := TestObject{}
-	err := UnmarshalFromString(`{"Field1": "hello", "Field2": [1,2,3]}`, &obj)
+	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)
+}

any_tests/jsoniter_any_string_test.go

@@ -1,9 +1,10 @@
-package jsoniter
+package any_tests
 
 import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
 )
 
 var stringConvertMap = map[string]string{
@@ -31,27 +32,27 @@ var stringConvertMap = map[string]string{
 func Test_read_any_to_string(t *testing.T) {
 	should := require.New(t)
 	for k, v := range stringConvertMap {
-		any := Get([]byte(k))
+		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 := Get([]byte(`"hello"`))
+	any := jsoniter.Get([]byte(`"hello"`))
 	should.Equal("hello", any.ToString())
 	should.True(any.ToBool())
-	any = Get([]byte(`" "`))
+	any = jsoniter.Get([]byte(`" "`))
 	should.False(any.ToBool())
-	any = Get([]byte(`"false"`))
+	any = jsoniter.Get([]byte(`"false"`))
 	should.True(any.ToBool())
-	any = Get([]byte(`"123"`))
+	any = jsoniter.Get([]byte(`"123"`))
 	should.Equal(123, any.ToInt())
 }
 
 func Test_wrap_string(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte("-32000")).MustBeValid()
+	any := jsoniter.Get([]byte("-32000")).MustBeValid()
 	should.Equal(-32000, any.ToInt())
 	should.NoError(any.LastError())
 }

any_tests/jsoniter_must_be_valid_test.go

@@ -1,71 +1,72 @@
-package jsoniter
+package any_tests
 
 import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
 )
 
 // if must be valid is useless, just drop this test
 func Test_must_be_valid(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte("123"))
+	any := jsoniter.Get([]byte("123"))
 	should.Equal(any.MustBeValid().ToInt(), 123)
 
-	any = Wrap(int8(10))
+	any = jsoniter.Wrap(int8(10))
 	should.Equal(any.MustBeValid().ToInt(), 10)
 
-	any = Wrap(int16(10))
+	any = jsoniter.Wrap(int16(10))
 	should.Equal(any.MustBeValid().ToInt(), 10)
 
-	any = Wrap(int32(10))
+	any = jsoniter.Wrap(int32(10))
 	should.Equal(any.MustBeValid().ToInt(), 10)
 
-	any = Wrap(int64(10))
+	any = jsoniter.Wrap(int64(10))
 	should.Equal(any.MustBeValid().ToInt(), 10)
 
-	any = Wrap(uint(10))
+	any = jsoniter.Wrap(uint(10))
 	should.Equal(any.MustBeValid().ToInt(), 10)
 
-	any = Wrap(uint8(10))
+	any = jsoniter.Wrap(uint8(10))
 	should.Equal(any.MustBeValid().ToInt(), 10)
 
-	any = Wrap(uint16(10))
+	any = jsoniter.Wrap(uint16(10))
 	should.Equal(any.MustBeValid().ToInt(), 10)
 
-	any = Wrap(uint32(10))
+	any = jsoniter.Wrap(uint32(10))
 	should.Equal(any.MustBeValid().ToInt(), 10)
 
-	any = Wrap(uint64(10))
+	any = jsoniter.Wrap(uint64(10))
 	should.Equal(any.MustBeValid().ToInt(), 10)
 
-	any = Wrap(float32(10))
+	any = jsoniter.Wrap(float32(10))
 	should.Equal(any.MustBeValid().ToFloat64(), float64(10))
 
-	any = Wrap(float64(10))
+	any = jsoniter.Wrap(float64(10))
 	should.Equal(any.MustBeValid().ToFloat64(), float64(10))
 
-	any = Wrap(true)
+	any = jsoniter.Wrap(true)
 	should.Equal(any.MustBeValid().ToFloat64(), float64(1))
 
-	any = Wrap(false)
+	any = jsoniter.Wrap(false)
 	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
 
-	any = Wrap(nil)
+	any = jsoniter.Wrap(nil)
 	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
 
-	any = Wrap(struct{ age int }{age: 1})
+	any = jsoniter.Wrap(struct{ age int }{age: 1})
 	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
 
-	any = Wrap(map[string]interface{}{"abc": 1})
+	any = jsoniter.Wrap(map[string]interface{}{"abc": 1})
 	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
 
-	any = Wrap("abc")
+	any = jsoniter.Wrap("abc")
 	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
 
-	any = Wrap([]int{})
+	any = jsoniter.Wrap([]int{})
 	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
 
-	any = Wrap([]int{1, 2})
+	any = jsoniter.Wrap([]int{1, 2})
 	should.Equal(any.MustBeValid().ToFloat64(), float64(1))
 }

any_tests/jsoniter_wrap_test.go

@@ -1,116 +1,117 @@
-package jsoniter
+package any_tests
 
 import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
 )
 
 func Test_wrap_and_valuetype_everything(t *testing.T) {
 	should := require.New(t)
 	var i interface{}
-	any := Get([]byte("123"))
+	any := jsoniter.Get([]byte("123"))
 	// default of number type is float64
 	i = float64(123)
 	should.Equal(i, any.GetInterface())
 
-	any = Wrap(int8(10))
-	should.Equal(any.ValueType(), NumberValue)
+	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 = Wrap(int16(10))
-	should.Equal(any.ValueType(), NumberValue)
+	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 = Wrap(int32(10))
-	should.Equal(any.ValueType(), NumberValue)
+	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 = Wrap(int64(10))
-	should.Equal(any.ValueType(), NumberValue)
+	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 = Wrap(uint(10))
-	should.Equal(any.ValueType(), NumberValue)
+	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 = Wrap(uint8(10))
-	should.Equal(any.ValueType(), NumberValue)
+	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 = Wrap(uint16(10))
-	should.Equal(any.ValueType(), NumberValue)
+	any = jsoniter.Wrap(uint16(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
 	should.Equal(any.LastError(), nil)
-	any = Wrap(uint32(10))
-	should.Equal(any.ValueType(), NumberValue)
+	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 = Wrap(uint64(10))
-	should.Equal(any.ValueType(), NumberValue)
+	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 = Wrap(float32(10))
-	should.Equal(any.ValueType(), NumberValue)
+	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 = Wrap(float64(10))
-	should.Equal(any.ValueType(), NumberValue)
+	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 = Wrap(true)
-	should.Equal(any.ValueType(), BoolValue)
+	any = jsoniter.Wrap(true)
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
 	should.Equal(any.LastError(), nil)
 	i = true
 	should.Equal(i, any.GetInterface())
-	any = Wrap(false)
-	should.Equal(any.ValueType(), BoolValue)
+	any = jsoniter.Wrap(false)
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
 	should.Equal(any.LastError(), nil)
 	i = false
 	should.Equal(i, any.GetInterface())
 
-	any = Wrap(nil)
-	should.Equal(any.ValueType(), NilValue)
+	any = jsoniter.Wrap(nil)
+	should.Equal(any.ValueType(), jsoniter.NilValue)
 	should.Equal(any.LastError(), nil)
 	i = nil
 	should.Equal(i, any.GetInterface())
 
-	stream := NewStream(ConfigDefault, nil, 32)
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
 	any.WriteTo(stream)
 	should.Equal("null", string(stream.Buffer()))
 	should.Equal(any.LastError(), nil)
 
-	any = Wrap(struct{ age int }{age: 1})
-	should.Equal(any.ValueType(), ObjectValue)
+	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 = Wrap(map[string]interface{}{"abc": 1})
-	should.Equal(any.ValueType(), ObjectValue)
+	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 = Wrap("abc")
+	any = jsoniter.Wrap("abc")
 	i = "abc"
 	should.Equal(i, any.GetInterface())
 	should.Equal(nil, any.LastError())

api_tests/config_test.go

@@ -0,0 +1,38 @@
+package test
+
+import (
+	"testing"
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+	"encoding/json"
+)
+
+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)
+}

api_tests/decoder_test.go

@@ -0,0 +1,59 @@
+package test
+
+import (
+	"bytes"
+	"github.com/stretchr/testify/require"
+	"testing"
+	"github.com/json-iterator/go"
+	"io/ioutil"
+	"encoding/json"
+)
+
+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)
+}

api_tests/encoder_18_test.go

@@ -1,6 +1,6 @@
-// +build go1.8
+//+build go1.8
 
-package jsoniter
+package test
 
 import (
 	"bytes"
@@ -9,6 +9,7 @@ import (
 	"unicode/utf8"
 
 	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
 )
 
 func Test_new_encoder(t *testing.T) {
@@ -19,14 +20,14 @@ func Test_new_encoder(t *testing.T) {
 	encoder1.Encode([]int{1})
 	should.Equal("[1]\n", buf1.String())
 	buf2 := &bytes.Buffer{}
-	encoder2 := NewEncoder(buf2)
+	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 := Config{EscapeHTML: false}.Froze()
+	api := jsoniter.Config{EscapeHTML: false}.Froze()
 	should := require.New(t)
 	for i := 0; i < utf8.RuneSelf; i++ {
 		input := string([]byte{byte(i)})

api_tests/encoder_test.go

@@ -0,0 +1,20 @@
+package test
+
+import (
+	"testing"
+	"github.com/stretchr/testify/require"
+	"bytes"
+	"github.com/json-iterator/go"
+	"encoding/json"
+)
+
+// 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())
+}

api_tests/marshal_indent_test.go

@@ -0,0 +1,36 @@
+package test
+
+import (
+	"encoding/json"
+	"github.com/stretchr/testify/require"
+	"testing"
+	"github.com/json-iterator/go"
+)
+
+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))
+}

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)
+		}
+	}
+}

benchmarks/jsoniter_large_file_test.go

@@ -1,10 +1,11 @@
-package jsoniter
+package test
 
 import (
 	"encoding/json"
 	"io/ioutil"
 	"os"
 	"testing"
+	"github.com/json-iterator/go"
 )
 
 //func Test_large_file(t *testing.T) {
@@ -127,9 +128,9 @@ 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 := Parse(ConfigDefault, file, 4096)
+		iter := jsoniter.Parse(jsoniter.ConfigDefault, file, 4096)
 		count := 0
-		iter.ReadArrayCB(func(iter *Iterator) bool {
+		iter.ReadArrayCB(func(iter *jsoniter.Iterator) bool {
 			// Skip() is strict by default, use --tags jsoniter-sloppy to skip without validation
 			iter.Skip()
 			count++

compatible_test.go

@@ -1,40 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-// Standard Encoder has trailing newline.
-func TestEncoderHasTrailingNewline(t *testing.T) {
-	should := require.New(t)
-	var buf, stdbuf bytes.Buffer
-	enc := ConfigCompatibleWithStandardLibrary.NewEncoder(&buf)
-	enc.Encode(1)
-	stdenc := json.NewEncoder(&stdbuf)
-	stdenc.Encode(1)
-	should.Equal(stdbuf.Bytes(), buf.Bytes())
-}
-
-// Non-nil but empty map should be ignored.
-func TestOmitempty(t *testing.T) {
-	o := struct {
-		A           string            `json:"a,omitempty"`
-		B           string            `json:"b,omitempty"`
-		Annotations map[string]string `json:"annotations,omitempty"`
-	}{
-		A:           "a",
-		B:           "b",
-		Annotations: map[string]string{},
-	}
-	should := require.New(t)
-	var buf, stdbuf bytes.Buffer
-	enc := ConfigCompatibleWithStandardLibrary.NewEncoder(&buf)
-	enc.Encode(o)
-	stdenc := json.NewEncoder(&stdbuf)
-	stdenc.Encode(o)
-	should.Equal(string(stdbuf.Bytes()), string(buf.Bytes()))
-}

extension_tests/decoder_test.go

@@ -0,0 +1,101 @@
+package test
+
+import (
+	"testing"
+	"unsafe"
+	"time"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"strconv"
+)
+
+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())
+}

extension_tests/extension_test.go

@@ -0,0 +1,75 @@
+package test
+
+import (
+	"unsafe"
+	"strconv"
+	"testing"
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+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)
+}
+
+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) EncodeInterface(val interface{}, stream *jsoniter.Stream) {
+	jsoniter.WriteToStream(val, stream, encoder)
+}
+
+func (encoder *funcEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+	if encoder.isEmptyFunc == nil {
+		return false
+	}
+	return encoder.isEmptyFunc(ptr)
+}

feature_adapter.go

@@ -95,11 +95,21 @@ func (adapter *Decoder) Buffered() io.Reader {
 	return bytes.NewReader(remaining)
 }
 
-// UseNumber for number JSON element, use float64 or json.NumberValue (alias of string)
+// UseNumber causes the Decoder to unmarshal a number into an interface{} as a
+// Number instead of as a float64.
 func (adapter *Decoder) UseNumber() {
-	origCfg := adapter.iter.cfg.configBeforeFrozen
-	origCfg.UseNumber = true
-	adapter.iter.cfg = origCfg.Froze().(*frozenConfig)
+	cfg := adapter.iter.cfg.configBeforeFrozen
+	cfg.UseNumber = true
+	adapter.iter.cfg = cfg.frozeWithCacheReuse()
+}
+
+// DisallowUnknownFields causes the Decoder to return an error when the destination
+// is a struct and the input contains object keys which do not match any
+// non-ignored, exported fields in the destination.
+func (adapter *Decoder) DisallowUnknownFields() {
+	cfg := adapter.iter.cfg.configBeforeFrozen
+	cfg.DisallowUnknownFields = true
+	adapter.iter.cfg = cfg.frozeWithCacheReuse()
 }
 
 // NewEncoder same as json.NewEncoder
@@ -122,14 +132,16 @@ func (adapter *Encoder) Encode(val interface{}) error {
 
 // SetIndent set the indention. Prefix is not supported
 func (adapter *Encoder) SetIndent(prefix, indent string) {
-	adapter.stream.cfg.indentionStep = len(indent)
+	config := adapter.stream.cfg.configBeforeFrozen
+	config.IndentionStep = len(indent)
+	adapter.stream.cfg = config.frozeWithCacheReuse()
 }
 
 // SetEscapeHTML escape html by default, set to false to disable
 func (adapter *Encoder) SetEscapeHTML(escapeHTML bool) {
 	config := adapter.stream.cfg.configBeforeFrozen
 	config.EscapeHTML = escapeHTML
-	adapter.stream.cfg = config.Froze().(*frozenConfig)
+	adapter.stream.cfg = config.frozeWithCacheReuse()
 }
 
 // Valid reports whether data is a valid JSON encoding.

feature_any_number.go

@@ -1,8 +1,8 @@
 package jsoniter
 
 import (
-	"unsafe"
 	"io"
+	"unsafe"
 )
 
 type numberLazyAny struct {

feature_config.go

@@ -16,6 +16,7 @@ type Config struct {
 	EscapeHTML                    bool
 	SortMapKeys                   bool
 	UseNumber                     bool
+	DisallowUnknownFields         bool
 	TagKey                        string
 	OnlyTaggedField               bool
 	ValidateJsonRawMessage        bool
@@ -60,30 +61,40 @@ var ConfigFastest = Config{
 
 // Froze forge API from config
 func (cfg Config) Froze() API {
-	// TODO: cache frozen config
-	frozenConfig := &frozenConfig{
+	api := &frozenConfig{
 		sortMapKeys:                   cfg.SortMapKeys,
 		indentionStep:                 cfg.IndentionStep,
 		objectFieldMustBeSimpleString: cfg.ObjectFieldMustBeSimpleString,
 		onlyTaggedField:               cfg.OnlyTaggedField,
+		disallowUnknownFields:         cfg.DisallowUnknownFields,
 		streamPool:                    make(chan *Stream, 16),
 		iteratorPool:                  make(chan *Iterator, 16),
 	}
-	frozenConfig.initCache()
+	api.initCache()
 	if cfg.MarshalFloatWith6Digits {
-		frozenConfig.marshalFloatWith6Digits()
+		api.marshalFloatWith6Digits()
 	}
 	if cfg.EscapeHTML {
-		frozenConfig.escapeHTML()
+		api.escapeHTML()
 	}
 	if cfg.UseNumber {
-		frozenConfig.useNumber()
+		api.useNumber()
 	}
 	if cfg.ValidateJsonRawMessage {
-		frozenConfig.validateJsonRawMessage()
+		api.validateJsonRawMessage()
 	}
-	frozenConfig.configBeforeFrozen = cfg
-	return frozenConfig
+	api.configBeforeFrozen = cfg
+	return api
+}
+
+func (cfg Config) frozeWithCacheReuse() *frozenConfig {
+	api := getFrozenConfigFromCache(cfg)
+	if api != nil {
+		return api
+	}
+	api = cfg.Froze().(*frozenConfig)
+	addFrozenConfigToCache(cfg, api)
+	return api
 }
 
 func (cfg *frozenConfig) validateJsonRawMessage() {
@@ -229,7 +240,7 @@ func (cfg *frozenConfig) MarshalIndent(v interface{}, prefix, indent string) ([]
 	}
 	newCfg := cfg.configBeforeFrozen
 	newCfg.IndentionStep = len(indent)
-	return newCfg.Froze().Marshal(v)
+	return newCfg.frozeWithCacheReuse().Marshal(v)
 }
 
 func (cfg *frozenConfig) UnmarshalFromString(str string, v interface{}) error {

feature_config_with_sync_map.go

@@ -13,6 +13,7 @@ type frozenConfig struct {
 	indentionStep                 int
 	objectFieldMustBeSimpleString bool
 	onlyTaggedField               bool
+	disallowUnknownFields         bool
 	decoderCache                  sync.Map
 	encoderCache                  sync.Map
 	extensions                    []Extension
@@ -25,7 +26,6 @@ func (cfg *frozenConfig) initCache() {
 	cfg.encoderCache = sync.Map{}
 }
 
-
 func (cfg *frozenConfig) addDecoderToCache(cacheKey reflect.Type, decoder ValDecoder) {
 	cfg.decoderCache.Store(cacheKey, decoder)
 }
@@ -48,4 +48,18 @@ func (cfg *frozenConfig) getEncoderFromCache(cacheKey reflect.Type) ValEncoder {
 		return encoder.(ValEncoder)
 	}
 	return nil
-}
+}
+
+var cfgCache = &sync.Map{}
+
+func getFrozenConfigFromCache(cfg Config) *frozenConfig {
+	obj, found := cfgCache.Load(cfg)
+	if found {
+		return obj.(*frozenConfig)
+	}
+	return nil
+}
+
+func addFrozenConfigToCache(cfg Config, frozenConfig *frozenConfig) {
+	cfgCache.Store(cfg, frozenConfig)
+}

feature_config_without_sync_map.go

@@ -13,6 +13,7 @@ type frozenConfig struct {
 	indentionStep                 int
 	objectFieldMustBeSimpleString bool
 	onlyTaggedField               bool
+	disallowUnknownFields         bool
 	cacheLock                     *sync.RWMutex
 	decoderCache                  map[reflect.Type]ValDecoder
 	encoderCache                  map[reflect.Type]ValEncoder
@@ -52,3 +53,19 @@ func (cfg *frozenConfig) getEncoderFromCache(cacheKey reflect.Type) ValEncoder {
 	cfg.cacheLock.RUnlock()
 	return encoder
 }
+
+var cfgCacheLock = &sync.RWMutex{}
+var cfgCache = map[Config]*frozenConfig{}
+
+func getFrozenConfigFromCache(cfg Config) *frozenConfig {
+	cfgCacheLock.RLock()
+	frozenConfig := cfgCache[cfg]
+	cfgCacheLock.RUnlock()
+	return frozenConfig
+}
+
+func addFrozenConfigToCache(cfg Config, frozenConfig *frozenConfig) {
+	cfgCacheLock.Lock()
+	cfgCache[cfg] = frozenConfig
+	cfgCacheLock.Unlock()
+}

feature_iter_object.go

@@ -3,7 +3,6 @@ package jsoniter
 import (
 	"fmt"
 	"unicode"
-	"unsafe"
 )
 
 // ReadObject read one field from object.
@@ -19,26 +18,6 @@ func (iter *Iterator) ReadObject() (ret string) {
 		c = iter.nextToken()
 		if c == '"' {
 			iter.unreadByte()
-			if iter.cfg.objectFieldMustBeSimpleString {
-				return string(iter.readObjectFieldAsBytes())
-			} else {
-				field := iter.ReadString()
-				c = iter.nextToken()
-				if c != ':' {
-					iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
-				}
-				return field
-			}
-		}
-		if c == '}' {
-			return "" // end of object
-		}
-		iter.ReportError("ReadObject", `expect " after {, but found `+string([]byte{c}))
-		return
-	case ',':
-		if iter.cfg.objectFieldMustBeSimpleString {
-			return string(iter.readObjectFieldAsBytes())
-		} else {
 			field := iter.ReadString()
 			c = iter.nextToken()
 			if c != ':' {
@@ -46,6 +25,18 @@ func (iter *Iterator) ReadObject() (ret string) {
 			}
 			return field
 		}
+		if c == '}' {
+			return "" // end of object
+		}
+		iter.ReportError("ReadObject", `expect " after {, but found `+string([]byte{c}))
+		return
+	case ',':
+		field := iter.ReadString()
+		c = iter.nextToken()
+		if c != ':' {
+			iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+		}
+		return field
 	case '}':
 		return "" // end of object
 	default:
@@ -54,97 +45,87 @@ func (iter *Iterator) ReadObject() (ret string) {
 	}
 }
 
-func (iter *Iterator) readFieldHash() int32 {
+// CaseInsensitive
+func (iter *Iterator) readFieldHash() int64 {
 	hash := int64(0x811c9dc5)
 	c := iter.nextToken()
-	if c == '"' {
-		for {
-			for i := iter.head; i < iter.tail; i++ {
-				// require ascii string and no escape
-				b := iter.buf[i]
-				if !iter.cfg.objectFieldMustBeSimpleString && b == '\\' {
-					iter.head = i
-					for _, b := range iter.readStringSlowPath() {
-						if 'A' <= b && b <= 'Z' {
-							b += 'a' - 'A'
-						}
-						hash ^= int64(b)
-						hash *= 0x1000193
+	if c != '"' {
+		iter.ReportError("readFieldHash", `expect ", but found `+string([]byte{c}))
+		return 0
+	}
+	for {
+		for i := iter.head; i < iter.tail; i++ {
+			// require ascii string and no escape
+			b := iter.buf[i]
+			if b == '\\' {
+				iter.head = i
+				for _, b := range iter.readStringSlowPath() {
+					if 'A' <= b && b <= 'Z' {
+						b += 'a' - 'A'
 					}
-					c = iter.nextToken()
-					if c != ':' {
-						iter.ReportError("readFieldHash", `expect :, but found `+string([]byte{c}))
-						return 0
-					}
-					return int32(hash)
+					hash ^= int64(b)
+					hash *= 0x1000193
 				}
-				if b == '"' {
-					iter.head = i + 1
-					c = iter.nextToken()
-					if c != ':' {
-						iter.ReportError("readFieldHash", `expect :, but found `+string([]byte{c}))
-						return 0
-					}
-					return int32(hash)
+				c = iter.nextToken()
+				if c != ':' {
+					iter.ReportError("readFieldHash", `expect :, but found `+string([]byte{c}))
+					return 0
 				}
-				if 'A' <= b && b <= 'Z' {
-					b += 'a' - 'A'
-				}
-				hash ^= int64(b)
-				hash *= 0x1000193
+				return hash
 			}
-			if !iter.loadMore() {
-				iter.ReportError("readFieldHash", `incomplete field name`)
-				return 0
+			if b == '"' {
+				iter.head = i + 1
+				c = iter.nextToken()
+				if c != ':' {
+					iter.ReportError("readFieldHash", `expect :, but found `+string([]byte{c}))
+					return 0
+				}
+				return hash
 			}
+			if 'A' <= b && b <= 'Z' {
+				b += 'a' - 'A'
+			}
+			hash ^= int64(b)
+			hash *= 0x1000193
+		}
+		if !iter.loadMore() {
+			iter.ReportError("readFieldHash", `incomplete field name`)
+			return 0
 		}
 	}
-	iter.ReportError("readFieldHash", `expect ", but found `+string([]byte{c}))
-	return 0
 }
 
-func calcHash(str string) int32 {
+func calcHash(str string) int64 {
 	hash := int64(0x811c9dc5)
 	for _, b := range str {
 		hash ^= int64(unicode.ToLower(b))
 		hash *= 0x1000193
 	}
-	return int32(hash)
+	return int64(hash)
 }
 
 // ReadObjectCB read object with callback, the key is ascii only and field name not copied
 func (iter *Iterator) ReadObjectCB(callback func(*Iterator, string) bool) bool {
 	c := iter.nextToken()
-	var fieldBytes []byte
 	var field string
 	if c == '{' {
 		c = iter.nextToken()
 		if c == '"' {
 			iter.unreadByte()
-			if iter.cfg.objectFieldMustBeSimpleString {
-				fieldBytes = iter.readObjectFieldAsBytes()
-				field = *(*string)(unsafe.Pointer(&fieldBytes))
-			} else {
-				field = iter.ReadString()
-				c = iter.nextToken()
-				if c != ':' {
-					iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
-				}
+			field = iter.ReadString()
+			c = iter.nextToken()
+			if c != ':' {
+				iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
 			}
 			if !callback(iter, field) {
 				return false
 			}
 			c = iter.nextToken()
 			for c == ',' {
-				if iter.cfg.objectFieldMustBeSimpleString {
-					fieldBytes = iter.readObjectFieldAsBytes()
-					field = *(*string)(unsafe.Pointer(&fieldBytes))
-				} else {
-					field = iter.ReadString()
-					c = iter.nextToken()
-					if c != ':' {
-						iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
-					}
+				field = iter.ReadString()
+				c = iter.nextToken()
+				if c != ':' {
+					iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
 				}
 				if !callback(iter, field) {
 					return false

feature_iter_skip_sloppy_test.go

@@ -1,4 +1,4 @@
-//+build jsoniter-sloppy
+//+build jsoniter_sloppy
 
 package jsoniter
 

feature_reflect_native.go

@@ -599,10 +599,10 @@ func (codec *base64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
 	}
 	encoding := base64.StdEncoding
 	stream.writeByte('"')
-	toGrow := encoding.EncodedLen(len(src))
-	stream.ensure(toGrow)
-	encoding.Encode(stream.buf[stream.n:], src)
-	stream.n += toGrow
+	size := encoding.EncodedLen(len(src))
+	buf := make([]byte, size)
+	encoding.Encode(buf, src)
+	stream.buf = append(stream.buf, buf...)
 	stream.writeByte('"')
 }
 
@@ -615,10 +615,10 @@ func (codec *base64Codec) EncodeInterface(val interface{}, stream *Stream) {
 	}
 	encoding := base64.StdEncoding
 	stream.writeByte('"')
-	toGrow := encoding.EncodedLen(len(src))
-	stream.ensure(toGrow)
-	encoding.Encode(stream.buf[stream.n:], src)
-	stream.n += toGrow
+	size := encoding.EncodedLen(len(src))
+	buf := make([]byte, size)
+	encoding.Encode(buf, src)
+	stream.buf = append(stream.buf, buf...)
 	stream.writeByte('"')
 }
 

feature_reflect_object.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"io"
 	"reflect"
-	"strings"
 	"unsafe"
 )
 
@@ -97,9 +96,9 @@ func decoderOfStruct(cfg *frozenConfig, prefix string, typ reflect.Type) ValDeco
 	}
 	fields := map[string]*structFieldDecoder{}
 	for k, binding := range bindings {
-		fields[strings.ToLower(k)] = binding.Decoder.(*structFieldDecoder)
+		fields[k] = binding.Decoder.(*structFieldDecoder)
 	}
-	return createStructDecoder(typ, fields)
+	return createStructDecoder(cfg, typ, fields)
 }
 
 type structFieldEncoder struct {

feature_reflect_struct_decoder.go

@@ -8,8 +8,11 @@ import (
 	"unsafe"
 )
 
-func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder) ValDecoder {
-	knownHash := map[int32]struct{}{
+func createStructDecoder(cfg *frozenConfig, typ reflect.Type, fields map[string]*structFieldDecoder) ValDecoder {
+	if cfg.disallowUnknownFields {
+		return &generalStructDecoder{typ: typ, fields: fields, disallowUnknownFields: true}
+	}
+	knownHash := map[int64]struct{}{
 		0: {},
 	}
 	switch len(fields) {
@@ -20,21 +23,21 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldHash := calcHash(fieldName)
 			_, known := knownHash[fieldHash]
 			if known {
-				return &generalStructDecoder{typ, fields}
+				return &generalStructDecoder{typ, fields, false}
 			}
 			knownHash[fieldHash] = struct{}{}
 			return &oneFieldStructDecoder{typ, fieldHash, fieldDecoder}
 		}
 	case 2:
-		var fieldHash1 int32
-		var fieldHash2 int32
+		var fieldHash1 int64
+		var fieldHash2 int64
 		var fieldDecoder1 *structFieldDecoder
 		var fieldDecoder2 *structFieldDecoder
 		for fieldName, fieldDecoder := range fields {
 			fieldHash := calcHash(fieldName)
 			_, known := knownHash[fieldHash]
 			if known {
-				return &generalStructDecoder{typ, fields}
+				return &generalStructDecoder{typ, fields, false}
 			}
 			knownHash[fieldHash] = struct{}{}
 			if fieldHash1 == 0 {
@@ -47,9 +50,9 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 		}
 		return &twoFieldsStructDecoder{typ, fieldHash1, fieldDecoder1, fieldHash2, fieldDecoder2}
 	case 3:
-		var fieldName1 int32
-		var fieldName2 int32
-		var fieldName3 int32
+		var fieldName1 int64
+		var fieldName2 int64
+		var fieldName3 int64
 		var fieldDecoder1 *structFieldDecoder
 		var fieldDecoder2 *structFieldDecoder
 		var fieldDecoder3 *structFieldDecoder
@@ -57,7 +60,7 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldHash := calcHash(fieldName)
 			_, known := knownHash[fieldHash]
 			if known {
-				return &generalStructDecoder{typ, fields}
+				return &generalStructDecoder{typ, fields, false}
 			}
 			knownHash[fieldHash] = struct{}{}
 			if fieldName1 == 0 {
@@ -76,10 +79,10 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldName2, fieldDecoder2,
 			fieldName3, fieldDecoder3}
 	case 4:
-		var fieldName1 int32
-		var fieldName2 int32
-		var fieldName3 int32
-		var fieldName4 int32
+		var fieldName1 int64
+		var fieldName2 int64
+		var fieldName3 int64
+		var fieldName4 int64
 		var fieldDecoder1 *structFieldDecoder
 		var fieldDecoder2 *structFieldDecoder
 		var fieldDecoder3 *structFieldDecoder
@@ -88,7 +91,7 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldHash := calcHash(fieldName)
 			_, known := knownHash[fieldHash]
 			if known {
-				return &generalStructDecoder{typ, fields}
+				return &generalStructDecoder{typ, fields, false}
 			}
 			knownHash[fieldHash] = struct{}{}
 			if fieldName1 == 0 {
@@ -111,11 +114,11 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldName3, fieldDecoder3,
 			fieldName4, fieldDecoder4}
 	case 5:
-		var fieldName1 int32
-		var fieldName2 int32
-		var fieldName3 int32
-		var fieldName4 int32
-		var fieldName5 int32
+		var fieldName1 int64
+		var fieldName2 int64
+		var fieldName3 int64
+		var fieldName4 int64
+		var fieldName5 int64
 		var fieldDecoder1 *structFieldDecoder
 		var fieldDecoder2 *structFieldDecoder
 		var fieldDecoder3 *structFieldDecoder
@@ -125,7 +128,7 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldHash := calcHash(fieldName)
 			_, known := knownHash[fieldHash]
 			if known {
-				return &generalStructDecoder{typ, fields}
+				return &generalStructDecoder{typ, fields, false}
 			}
 			knownHash[fieldHash] = struct{}{}
 			if fieldName1 == 0 {
@@ -152,12 +155,12 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldName4, fieldDecoder4,
 			fieldName5, fieldDecoder5}
 	case 6:
-		var fieldName1 int32
-		var fieldName2 int32
-		var fieldName3 int32
-		var fieldName4 int32
-		var fieldName5 int32
-		var fieldName6 int32
+		var fieldName1 int64
+		var fieldName2 int64
+		var fieldName3 int64
+		var fieldName4 int64
+		var fieldName5 int64
+		var fieldName6 int64
 		var fieldDecoder1 *structFieldDecoder
 		var fieldDecoder2 *structFieldDecoder
 		var fieldDecoder3 *structFieldDecoder
@@ -168,7 +171,7 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldHash := calcHash(fieldName)
 			_, known := knownHash[fieldHash]
 			if known {
-				return &generalStructDecoder{typ, fields}
+				return &generalStructDecoder{typ, fields, false}
 			}
 			knownHash[fieldHash] = struct{}{}
 			if fieldName1 == 0 {
@@ -199,13 +202,13 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldName5, fieldDecoder5,
 			fieldName6, fieldDecoder6}
 	case 7:
-		var fieldName1 int32
-		var fieldName2 int32
-		var fieldName3 int32
-		var fieldName4 int32
-		var fieldName5 int32
-		var fieldName6 int32
-		var fieldName7 int32
+		var fieldName1 int64
+		var fieldName2 int64
+		var fieldName3 int64
+		var fieldName4 int64
+		var fieldName5 int64
+		var fieldName6 int64
+		var fieldName7 int64
 		var fieldDecoder1 *structFieldDecoder
 		var fieldDecoder2 *structFieldDecoder
 		var fieldDecoder3 *structFieldDecoder
@@ -217,7 +220,7 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldHash := calcHash(fieldName)
 			_, known := knownHash[fieldHash]
 			if known {
-				return &generalStructDecoder{typ, fields}
+				return &generalStructDecoder{typ, fields, false}
 			}
 			knownHash[fieldHash] = struct{}{}
 			if fieldName1 == 0 {
@@ -252,14 +255,14 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldName6, fieldDecoder6,
 			fieldName7, fieldDecoder7}
 	case 8:
-		var fieldName1 int32
-		var fieldName2 int32
-		var fieldName3 int32
-		var fieldName4 int32
-		var fieldName5 int32
-		var fieldName6 int32
-		var fieldName7 int32
-		var fieldName8 int32
+		var fieldName1 int64
+		var fieldName2 int64
+		var fieldName3 int64
+		var fieldName4 int64
+		var fieldName5 int64
+		var fieldName6 int64
+		var fieldName7 int64
+		var fieldName8 int64
 		var fieldDecoder1 *structFieldDecoder
 		var fieldDecoder2 *structFieldDecoder
 		var fieldDecoder3 *structFieldDecoder
@@ -272,7 +275,7 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldHash := calcHash(fieldName)
 			_, known := knownHash[fieldHash]
 			if known {
-				return &generalStructDecoder{typ, fields}
+				return &generalStructDecoder{typ, fields, false}
 			}
 			knownHash[fieldHash] = struct{}{}
 			if fieldName1 == 0 {
@@ -311,15 +314,15 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldName7, fieldDecoder7,
 			fieldName8, fieldDecoder8}
 	case 9:
-		var fieldName1 int32
-		var fieldName2 int32
-		var fieldName3 int32
-		var fieldName4 int32
-		var fieldName5 int32
-		var fieldName6 int32
-		var fieldName7 int32
-		var fieldName8 int32
-		var fieldName9 int32
+		var fieldName1 int64
+		var fieldName2 int64
+		var fieldName3 int64
+		var fieldName4 int64
+		var fieldName5 int64
+		var fieldName6 int64
+		var fieldName7 int64
+		var fieldName8 int64
+		var fieldName9 int64
 		var fieldDecoder1 *structFieldDecoder
 		var fieldDecoder2 *structFieldDecoder
 		var fieldDecoder3 *structFieldDecoder
@@ -333,7 +336,7 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldHash := calcHash(fieldName)
 			_, known := knownHash[fieldHash]
 			if known {
-				return &generalStructDecoder{typ, fields}
+				return &generalStructDecoder{typ, fields, false}
 			}
 			knownHash[fieldHash] = struct{}{}
 			if fieldName1 == 0 {
@@ -376,16 +379,16 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldName8, fieldDecoder8,
 			fieldName9, fieldDecoder9}
 	case 10:
-		var fieldName1 int32
-		var fieldName2 int32
-		var fieldName3 int32
-		var fieldName4 int32
-		var fieldName5 int32
-		var fieldName6 int32
-		var fieldName7 int32
-		var fieldName8 int32
-		var fieldName9 int32
-		var fieldName10 int32
+		var fieldName1 int64
+		var fieldName2 int64
+		var fieldName3 int64
+		var fieldName4 int64
+		var fieldName5 int64
+		var fieldName6 int64
+		var fieldName7 int64
+		var fieldName8 int64
+		var fieldName9 int64
+		var fieldName10 int64
 		var fieldDecoder1 *structFieldDecoder
 		var fieldDecoder2 *structFieldDecoder
 		var fieldDecoder3 *structFieldDecoder
@@ -400,7 +403,7 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldHash := calcHash(fieldName)
 			_, known := knownHash[fieldHash]
 			if known {
-				return &generalStructDecoder{typ, fields}
+				return &generalStructDecoder{typ, fields, false}
 			}
 			knownHash[fieldHash] = struct{}{}
 			if fieldName1 == 0 {
@@ -447,59 +450,64 @@ func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder
 			fieldName9, fieldDecoder9,
 			fieldName10, fieldDecoder10}
 	}
-	return &generalStructDecoder{typ, fields}
+	return &generalStructDecoder{typ, fields, false}
 }
 
 type generalStructDecoder struct {
-	typ    reflect.Type
-	fields map[string]*structFieldDecoder
+	typ                   reflect.Type
+	fields                map[string]*structFieldDecoder
+	disallowUnknownFields bool
 }
 
 func (decoder *generalStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
 	if !iter.readObjectStart() {
 		return
 	}
-	var fieldBytes []byte
-	var field string
-	if iter.cfg.objectFieldMustBeSimpleString {
-		fieldBytes = iter.readObjectFieldAsBytes()
-		field = *(*string)(unsafe.Pointer(&fieldBytes))
-	} else {
-		field = iter.ReadString()
-		c := iter.nextToken()
-		if c != ':' {
-			iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
-		}
-	}
-	fieldDecoder := decoder.fields[strings.ToLower(field)]
-	if fieldDecoder == nil {
-		iter.Skip()
-	} else {
-		fieldDecoder.Decode(ptr, iter)
-	}
+	decoder.decodeOneField(ptr, iter)
 	for iter.nextToken() == ',' {
-		if iter.cfg.objectFieldMustBeSimpleString {
-			fieldBytes := iter.readObjectFieldAsBytes()
-			field = *(*string)(unsafe.Pointer(&fieldBytes))
-		} else {
-			field = iter.ReadString()
-			c := iter.nextToken()
-			if c != ':' {
-				iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
-			}
-		}
-		fieldDecoder = decoder.fields[strings.ToLower(field)]
-		if fieldDecoder == nil {
-			iter.Skip()
-		} else {
-			fieldDecoder.Decode(ptr, iter)
-		}
+		decoder.decodeOneField(ptr, iter)
 	}
 	if iter.Error != nil && iter.Error != io.EOF {
 		iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
 	}
 }
 
+func (decoder *generalStructDecoder) decodeOneField(ptr unsafe.Pointer, iter *Iterator) {
+	var field string
+	var fieldDecoder *structFieldDecoder
+	if iter.cfg.objectFieldMustBeSimpleString {
+		fieldBytes := iter.ReadStringAsSlice()
+		field = *(*string)(unsafe.Pointer(&fieldBytes))
+		fieldDecoder = decoder.fields[field]
+		if fieldDecoder == nil {
+			fieldDecoder = decoder.fields[strings.ToLower(field)]
+		}
+	} else {
+		field = iter.ReadString()
+		fieldDecoder = decoder.fields[field]
+		if fieldDecoder == nil {
+			fieldDecoder = decoder.fields[strings.ToLower(field)]
+		}
+	}
+	if fieldDecoder == nil {
+		msg := "found unknown field: " + field
+		if decoder.disallowUnknownFields {
+			iter.ReportError("ReadObject", msg)
+		}
+		c := iter.nextToken()
+		if c != ':' {
+			iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+		}
+		iter.Skip()
+		return
+	}
+	c := iter.nextToken()
+	if c != ':' {
+		iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+	}
+	fieldDecoder.Decode(ptr, iter)
+}
+
 type skipObjectDecoder struct {
 	typ reflect.Type
 }
@@ -515,7 +523,7 @@ func (decoder *skipObjectDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
 
 type oneFieldStructDecoder struct {
 	typ          reflect.Type
-	fieldHash    int32
+	fieldHash    int64
 	fieldDecoder *structFieldDecoder
 }
 
@@ -540,9 +548,9 @@ func (decoder *oneFieldStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator)
 
 type twoFieldsStructDecoder struct {
 	typ           reflect.Type
-	fieldHash1    int32
+	fieldHash1    int64
 	fieldDecoder1 *structFieldDecoder
-	fieldHash2    int32
+	fieldHash2    int64
 	fieldDecoder2 *structFieldDecoder
 }
 
@@ -570,11 +578,11 @@ func (decoder *twoFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator
 
 type threeFieldsStructDecoder struct {
 	typ           reflect.Type
-	fieldHash1    int32
+	fieldHash1    int64
 	fieldDecoder1 *structFieldDecoder
-	fieldHash2    int32
+	fieldHash2    int64
 	fieldDecoder2 *structFieldDecoder
-	fieldHash3    int32
+	fieldHash3    int64
 	fieldDecoder3 *structFieldDecoder
 }
 
@@ -604,13 +612,13 @@ func (decoder *threeFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterat
 
 type fourFieldsStructDecoder struct {
 	typ           reflect.Type
-	fieldHash1    int32
+	fieldHash1    int64
 	fieldDecoder1 *structFieldDecoder
-	fieldHash2    int32
+	fieldHash2    int64
 	fieldDecoder2 *structFieldDecoder
-	fieldHash3    int32
+	fieldHash3    int64
 	fieldDecoder3 *structFieldDecoder
-	fieldHash4    int32
+	fieldHash4    int64
 	fieldDecoder4 *structFieldDecoder
 }
 
@@ -642,15 +650,15 @@ func (decoder *fourFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterato
 
 type fiveFieldsStructDecoder struct {
 	typ           reflect.Type
-	fieldHash1    int32
+	fieldHash1    int64
 	fieldDecoder1 *structFieldDecoder
-	fieldHash2    int32
+	fieldHash2    int64
 	fieldDecoder2 *structFieldDecoder
-	fieldHash3    int32
+	fieldHash3    int64
 	fieldDecoder3 *structFieldDecoder
-	fieldHash4    int32
+	fieldHash4    int64
 	fieldDecoder4 *structFieldDecoder
-	fieldHash5    int32
+	fieldHash5    int64
 	fieldDecoder5 *structFieldDecoder
 }
 
@@ -684,17 +692,17 @@ func (decoder *fiveFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterato
 
 type sixFieldsStructDecoder struct {
 	typ           reflect.Type
-	fieldHash1    int32
+	fieldHash1    int64
 	fieldDecoder1 *structFieldDecoder
-	fieldHash2    int32
+	fieldHash2    int64
 	fieldDecoder2 *structFieldDecoder
-	fieldHash3    int32
+	fieldHash3    int64
 	fieldDecoder3 *structFieldDecoder
-	fieldHash4    int32
+	fieldHash4    int64
 	fieldDecoder4 *structFieldDecoder
-	fieldHash5    int32
+	fieldHash5    int64
 	fieldDecoder5 *structFieldDecoder
-	fieldHash6    int32
+	fieldHash6    int64
 	fieldDecoder6 *structFieldDecoder
 }
 
@@ -730,19 +738,19 @@ func (decoder *sixFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator
 
 type sevenFieldsStructDecoder struct {
 	typ           reflect.Type
-	fieldHash1    int32
+	fieldHash1    int64
 	fieldDecoder1 *structFieldDecoder
-	fieldHash2    int32
+	fieldHash2    int64
 	fieldDecoder2 *structFieldDecoder
-	fieldHash3    int32
+	fieldHash3    int64
 	fieldDecoder3 *structFieldDecoder
-	fieldHash4    int32
+	fieldHash4    int64
 	fieldDecoder4 *structFieldDecoder
-	fieldHash5    int32
+	fieldHash5    int64
 	fieldDecoder5 *structFieldDecoder
-	fieldHash6    int32
+	fieldHash6    int64
 	fieldDecoder6 *structFieldDecoder
-	fieldHash7    int32
+	fieldHash7    int64
 	fieldDecoder7 *structFieldDecoder
 }
 
@@ -780,21 +788,21 @@ func (decoder *sevenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterat
 
 type eightFieldsStructDecoder struct {
 	typ           reflect.Type
-	fieldHash1    int32
+	fieldHash1    int64
 	fieldDecoder1 *structFieldDecoder
-	fieldHash2    int32
+	fieldHash2    int64
 	fieldDecoder2 *structFieldDecoder
-	fieldHash3    int32
+	fieldHash3    int64
 	fieldDecoder3 *structFieldDecoder
-	fieldHash4    int32
+	fieldHash4    int64
 	fieldDecoder4 *structFieldDecoder
-	fieldHash5    int32
+	fieldHash5    int64
 	fieldDecoder5 *structFieldDecoder
-	fieldHash6    int32
+	fieldHash6    int64
 	fieldDecoder6 *structFieldDecoder
-	fieldHash7    int32
+	fieldHash7    int64
 	fieldDecoder7 *structFieldDecoder
-	fieldHash8    int32
+	fieldHash8    int64
 	fieldDecoder8 *structFieldDecoder
 }
 
@@ -834,23 +842,23 @@ func (decoder *eightFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterat
 
 type nineFieldsStructDecoder struct {
 	typ           reflect.Type
-	fieldHash1    int32
+	fieldHash1    int64
 	fieldDecoder1 *structFieldDecoder
-	fieldHash2    int32
+	fieldHash2    int64
 	fieldDecoder2 *structFieldDecoder
-	fieldHash3    int32
+	fieldHash3    int64
 	fieldDecoder3 *structFieldDecoder
-	fieldHash4    int32
+	fieldHash4    int64
 	fieldDecoder4 *structFieldDecoder
-	fieldHash5    int32
+	fieldHash5    int64
 	fieldDecoder5 *structFieldDecoder
-	fieldHash6    int32
+	fieldHash6    int64
 	fieldDecoder6 *structFieldDecoder
-	fieldHash7    int32
+	fieldHash7    int64
 	fieldDecoder7 *structFieldDecoder
-	fieldHash8    int32
+	fieldHash8    int64
 	fieldDecoder8 *structFieldDecoder
-	fieldHash9    int32
+	fieldHash9    int64
 	fieldDecoder9 *structFieldDecoder
 }
 
@@ -892,25 +900,25 @@ func (decoder *nineFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterato
 
 type tenFieldsStructDecoder struct {
 	typ            reflect.Type
-	fieldHash1     int32
+	fieldHash1     int64
 	fieldDecoder1  *structFieldDecoder
-	fieldHash2     int32
+	fieldHash2     int64
 	fieldDecoder2  *structFieldDecoder
-	fieldHash3     int32
+	fieldHash3     int64
 	fieldDecoder3  *structFieldDecoder
-	fieldHash4     int32
+	fieldHash4     int64
 	fieldDecoder4  *structFieldDecoder
-	fieldHash5     int32
+	fieldHash5     int64
 	fieldDecoder5  *structFieldDecoder
-	fieldHash6     int32
+	fieldHash6     int64
 	fieldDecoder6  *structFieldDecoder
-	fieldHash7     int32
+	fieldHash7     int64
 	fieldDecoder7  *structFieldDecoder
-	fieldHash8     int32
+	fieldHash8     int64
 	fieldDecoder8  *structFieldDecoder
-	fieldHash9     int32
+	fieldHash9     int64
 	fieldDecoder9  *structFieldDecoder
-	fieldHash10    int32
+	fieldHash10    int64
 	fieldDecoder10 *structFieldDecoder
 }
 

feature_stream.go

@@ -10,7 +10,6 @@ type Stream struct {
 	cfg        *frozenConfig
 	out        io.Writer
 	buf        []byte
-	n          int
 	Error      error
 	indention  int
 	Attachment interface{} // open for customized encoder
@@ -24,8 +23,7 @@ func NewStream(cfg API, out io.Writer, bufSize int) *Stream {
 	return &Stream{
 		cfg:       cfg.(*frozenConfig),
 		out:       out,
-		buf:       make([]byte, bufSize),
-		n:         0,
+		buf:       make([]byte, 0, bufSize),
 		Error:     nil,
 		indention: 0,
 	}
@@ -39,22 +37,22 @@ func (stream *Stream) Pool() StreamPool {
 // Reset reuse this stream instance by assign a new writer
 func (stream *Stream) Reset(out io.Writer) {
 	stream.out = out
-	stream.n = 0
+	stream.buf = stream.buf[:0]
 }
 
 // Available returns how many bytes are unused in the buffer.
 func (stream *Stream) Available() int {
-	return len(stream.buf) - stream.n
+	return cap(stream.buf) - len(stream.buf)
 }
 
 // Buffered returns the number of bytes that have been written into the current buffer.
 func (stream *Stream) Buffered() int {
-	return stream.n
+	return len(stream.buf)
 }
 
 // Buffer if writer is nil, use this method to take the result
 func (stream *Stream) Buffer() []byte {
-	return stream.buf[:stream.n]
+	return stream.buf
 }
 
 // Write writes the contents of p into the buffer.
@@ -62,97 +60,34 @@ func (stream *Stream) Buffer() []byte {
 // If nn < len(p), it also returns an error explaining
 // why the write is short.
 func (stream *Stream) Write(p []byte) (nn int, err error) {
-	for len(p) > stream.Available() && stream.Error == nil {
-		if stream.out == nil {
-			stream.growAtLeast(len(p))
-		} else {
-			var n int
-			if stream.Buffered() == 0 {
-				// Large write, empty buffer.
-				// Write directly from p to avoid copy.
-				n, stream.Error = stream.out.Write(p)
-			} else {
-				n = copy(stream.buf[stream.n:], p)
-				stream.n += n
-				stream.Flush()
-			}
-			nn += n
-			p = p[n:]
-		}
+	stream.buf = append(stream.buf, p...)
+	if stream.out != nil {
+		nn, err = stream.out.Write(stream.buf)
+		stream.buf = stream.buf[nn:]
+		return
 	}
-	if stream.Error != nil {
-		return nn, stream.Error
-	}
-	n := copy(stream.buf[stream.n:], p)
-	stream.n += n
-	nn += n
-	return nn, nil
+	return len(p), nil
 }
 
 // WriteByte writes a single byte.
 func (stream *Stream) writeByte(c byte) {
-	if stream.Error != nil {
-		return
-	}
-	if stream.Available() < 1 {
-		stream.growAtLeast(1)
-	}
-	stream.buf[stream.n] = c
-	stream.n++
+	stream.buf = append(stream.buf, c)
 }
 
 func (stream *Stream) writeTwoBytes(c1 byte, c2 byte) {
-	if stream.Error != nil {
-		return
-	}
-	if stream.Available() < 2 {
-		stream.growAtLeast(2)
-	}
-	stream.buf[stream.n] = c1
-	stream.buf[stream.n+1] = c2
-	stream.n += 2
+	stream.buf = append(stream.buf, c1, c2)
 }
 
 func (stream *Stream) writeThreeBytes(c1 byte, c2 byte, c3 byte) {
-	if stream.Error != nil {
-		return
-	}
-	if stream.Available() < 3 {
-		stream.growAtLeast(3)
-	}
-	stream.buf[stream.n] = c1
-	stream.buf[stream.n+1] = c2
-	stream.buf[stream.n+2] = c3
-	stream.n += 3
+	stream.buf = append(stream.buf, c1, c2, c3)
 }
 
 func (stream *Stream) writeFourBytes(c1 byte, c2 byte, c3 byte, c4 byte) {
-	if stream.Error != nil {
-		return
-	}
-	if stream.Available() < 4 {
-		stream.growAtLeast(4)
-	}
-	stream.buf[stream.n] = c1
-	stream.buf[stream.n+1] = c2
-	stream.buf[stream.n+2] = c3
-	stream.buf[stream.n+3] = c4
-	stream.n += 4
+	stream.buf = append(stream.buf, c1, c2, c3, c4)
 }
 
 func (stream *Stream) writeFiveBytes(c1 byte, c2 byte, c3 byte, c4 byte, c5 byte) {
-	if stream.Error != nil {
-		return
-	}
-	if stream.Available() < 5 {
-		stream.growAtLeast(5)
-	}
-	stream.buf[stream.n] = c1
-	stream.buf[stream.n+1] = c2
-	stream.buf[stream.n+2] = c3
-	stream.buf[stream.n+3] = c4
-	stream.buf[stream.n+4] = c5
-	stream.n += 5
+	stream.buf = append(stream.buf, c1, c2, c3, c4, c5)
 }
 
 // Flush writes any buffered data to the underlying io.Writer.
@@ -163,56 +98,20 @@ func (stream *Stream) Flush() error {
 	if stream.Error != nil {
 		return stream.Error
 	}
-	if stream.n == 0 {
-		return nil
-	}
-	n, err := stream.out.Write(stream.buf[0:stream.n])
-	if n < stream.n && err == nil {
-		err = io.ErrShortWrite
-	}
+	n, err := stream.out.Write(stream.buf)
 	if err != nil {
-		if n > 0 && n < stream.n {
-			copy(stream.buf[0:stream.n-n], stream.buf[n:stream.n])
+		if stream.Error == nil {
+			stream.Error = err
 		}
-		stream.n -= n
-		stream.Error = err
 		return err
 	}
-	stream.n = 0
+	stream.buf = stream.buf[n:]
 	return nil
 }
 
-func (stream *Stream) ensure(minimal int) {
-	available := stream.Available()
-	if available < minimal {
-		stream.growAtLeast(minimal)
-	}
-}
-
-func (stream *Stream) growAtLeast(minimal int) {
-	if stream.out != nil {
-		stream.Flush()
-		if stream.Available() >= minimal {
-			return
-		}
-	}
-	toGrow := len(stream.buf)
-	if toGrow < minimal {
-		toGrow = minimal
-	}
-	newBuf := make([]byte, len(stream.buf)+toGrow)
-	copy(newBuf, stream.Buffer())
-	stream.buf = newBuf
-}
-
 // WriteRaw write string out without quotes, just like []byte
 func (stream *Stream) WriteRaw(s string) {
-	stream.ensure(len(s))
-	if stream.Error != nil {
-		return
-	}
-	n := copy(stream.buf[stream.n:], s)
-	stream.n += n
+	stream.buf = append(stream.buf, s...)
 }
 
 // WriteNil write null to stream
@@ -273,6 +172,7 @@ func (stream *Stream) WriteEmptyObject() {
 func (stream *Stream) WriteMore() {
 	stream.writeByte(',')
 	stream.writeIndention(0)
+	stream.Flush()
 }
 
 // WriteArrayStart write [ with possible indention
@@ -300,9 +200,7 @@ func (stream *Stream) writeIndention(delta int) {
 	}
 	stream.writeByte('\n')
 	toWrite := stream.indention - delta
-	stream.ensure(toWrite)
-	for i := 0; i < toWrite && stream.n < len(stream.buf); i++ {
-		stream.buf[stream.n] = ' '
-		stream.n++
+	for i := 0; i < toWrite; i++ {
+		stream.buf = append(stream.buf, ' ')
 	}
 }

feature_stream_float.go

@@ -21,7 +21,7 @@ func (stream *Stream) WriteFloat32(val float32) {
 			fmt = 'e'
 		}
 	}
-	stream.WriteRaw(strconv.FormatFloat(float64(val), fmt, -1, 32))
+	stream.buf = strconv.AppendFloat(stream.buf, float64(val), fmt, -1, 32)
 }
 
 // WriteFloat32Lossy write float32 to stream with ONLY 6 digits precision although much much faster
@@ -43,13 +43,12 @@ func (stream *Stream) WriteFloat32Lossy(val float32) {
 		return
 	}
 	stream.writeByte('.')
-	stream.ensure(10)
 	for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
 		stream.writeByte('0')
 	}
 	stream.WriteUint64(fval)
-	for stream.buf[stream.n-1] == '0' {
-		stream.n--
+	for stream.buf[len(stream.buf)-1] == '0' {
+		stream.buf = stream.buf[:len(stream.buf)-1]
 	}
 }
 
@@ -63,7 +62,7 @@ func (stream *Stream) WriteFloat64(val float64) {
 			fmt = 'e'
 		}
 	}
-	stream.WriteRaw(strconv.FormatFloat(float64(val), fmt, -1, 64))
+	stream.buf = strconv.AppendFloat(stream.buf, float64(val), fmt, -1, 64)
 }
 
 // WriteFloat64Lossy write float64 to stream with ONLY 6 digits precision although much much faster
@@ -85,12 +84,11 @@ func (stream *Stream) WriteFloat64Lossy(val float64) {
 		return
 	}
 	stream.writeByte('.')
-	stream.ensure(10)
 	for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
 		stream.writeByte('0')
 	}
 	stream.WriteUint64(fval)
-	for stream.buf[stream.n-1] == '0' {
-		stream.n--
+	for stream.buf[len(stream.buf)-1] == '0' {
+		stream.buf = stream.buf[:len(stream.buf)-1]
 	}
 }

feature_stream_int.go

@@ -14,299 +14,169 @@ func init() {
 	}
 }
 
-func writeFirstBuf(buf []byte, v uint32, n int) int {
+func writeFirstBuf(space []byte, v uint32) []byte {
 	start := v >> 24
 	if start == 0 {
-		buf[n] = byte(v >> 16)
-		n++
-		buf[n] = byte(v >> 8)
-		n++
+		space = append(space, byte(v >> 16), byte(v >> 8))
 	} else if start == 1 {
-		buf[n] = byte(v >> 8)
-		n++
+		space = append(space, byte(v >> 8))
 	}
-	buf[n] = byte(v)
-	n++
-	return n
+	space = append(space, byte(v))
+	return space
 }
 
-func writeBuf(buf []byte, v uint32, n int) {
-	buf[n] = byte(v >> 16)
-	buf[n+1] = byte(v >> 8)
-	buf[n+2] = byte(v)
+func writeBuf(buf []byte, v uint32) []byte {
+	return append(buf, byte(v >> 16), byte(v >> 8), byte(v))
 }
 
 // WriteUint8 write uint8 to stream
 func (stream *Stream) WriteUint8(val uint8) {
-	stream.ensure(3)
-	stream.n = writeFirstBuf(stream.buf, digits[val], stream.n)
+	stream.buf = writeFirstBuf(stream.buf, digits[val])
 }
 
 // WriteInt8 write int8 to stream
 func (stream *Stream) WriteInt8(nval int8) {
-	stream.ensure(4)
-	n := stream.n
 	var val uint8
 	if nval < 0 {
 		val = uint8(-nval)
-		stream.buf[n] = '-'
-		n++
+		stream.buf = append(stream.buf, '-')
 	} else {
 		val = uint8(nval)
 	}
-	stream.n = writeFirstBuf(stream.buf, digits[val], n)
+	stream.buf = writeFirstBuf(stream.buf, digits[val])
 }
 
 // WriteUint16 write uint16 to stream
 func (stream *Stream) WriteUint16(val uint16) {
-	stream.ensure(5)
 	q1 := val / 1000
 	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, digits[val], stream.n)
+		stream.buf = writeFirstBuf(stream.buf, digits[val])
 		return
 	}
 	r1 := val - q1*1000
-	n := writeFirstBuf(stream.buf, digits[q1], stream.n)
-	writeBuf(stream.buf, digits[r1], n)
-	stream.n = n + 3
+	stream.buf = writeFirstBuf(stream.buf, digits[q1])
+	stream.buf = writeBuf(stream.buf, digits[r1])
 	return
 }
 
 // WriteInt16 write int16 to stream
 func (stream *Stream) WriteInt16(nval int16) {
-	stream.ensure(6)
-	n := stream.n
 	var val uint16
 	if nval < 0 {
 		val = uint16(-nval)
-		stream.buf[n] = '-'
-		n++
+		stream.buf = append(stream.buf, '-')
 	} else {
 		val = uint16(nval)
 	}
-	q1 := val / 1000
-	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, digits[val], n)
-		return
-	}
-	r1 := val - q1*1000
-	n = writeFirstBuf(stream.buf, digits[q1], n)
-	writeBuf(stream.buf, digits[r1], n)
-	stream.n = n + 3
-	return
+	stream.WriteUint16(val)
 }
 
 // WriteUint32 write uint32 to stream
 func (stream *Stream) WriteUint32(val uint32) {
-	stream.ensure(10)
-	n := stream.n
 	q1 := val / 1000
 	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, digits[val], n)
+		stream.buf = writeFirstBuf(stream.buf, digits[val])
 		return
 	}
 	r1 := val - q1*1000
 	q2 := q1 / 1000
 	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, digits[q1], n)
-		writeBuf(stream.buf, digits[r1], n)
-		stream.n = n + 3
+		stream.buf = writeFirstBuf(stream.buf, digits[q1])
+		stream.buf = writeBuf(stream.buf, digits[r1])
 		return
 	}
 	r2 := q1 - q2*1000
 	q3 := q2 / 1000
 	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, digits[q2], n)
+		stream.buf = writeFirstBuf(stream.buf, digits[q2])
 	} else {
 		r3 := q2 - q3*1000
-		stream.buf[n] = byte(q3 + '0')
-		n++
-		writeBuf(stream.buf, digits[r3], n)
-		n += 3
+		stream.buf = append(stream.buf, byte(q3 + '0'))
+		stream.buf = writeBuf(stream.buf, digits[r3])
 	}
-	writeBuf(stream.buf, digits[r2], n)
-	writeBuf(stream.buf, digits[r1], n+3)
-	stream.n = n + 6
+	stream.buf = writeBuf(stream.buf, digits[r2])
+	stream.buf = writeBuf(stream.buf, digits[r1])
 }
 
 // WriteInt32 write int32 to stream
 func (stream *Stream) WriteInt32(nval int32) {
-	stream.ensure(11)
-	n := stream.n
 	var val uint32
 	if nval < 0 {
 		val = uint32(-nval)
-		stream.buf[n] = '-'
-		n++
+		stream.buf = append(stream.buf, '-')
 	} else {
 		val = uint32(nval)
 	}
-	q1 := val / 1000
-	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, digits[val], n)
-		return
-	}
-	r1 := val - q1*1000
-	q2 := q1 / 1000
-	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, digits[q1], n)
-		writeBuf(stream.buf, digits[r1], n)
-		stream.n = n + 3
-		return
-	}
-	r2 := q1 - q2*1000
-	q3 := q2 / 1000
-	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, digits[q2], n)
-	} else {
-		r3 := q2 - q3*1000
-		stream.buf[n] = byte(q3 + '0')
-		n++
-		writeBuf(stream.buf, digits[r3], n)
-		n += 3
-	}
-	writeBuf(stream.buf, digits[r2], n)
-	writeBuf(stream.buf, digits[r1], n+3)
-	stream.n = n + 6
+	stream.WriteUint32(val)
 }
 
 // WriteUint64 write uint64 to stream
 func (stream *Stream) WriteUint64(val uint64) {
-	stream.ensure(20)
-	n := stream.n
 	q1 := val / 1000
 	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, digits[val], n)
+		stream.buf = writeFirstBuf(stream.buf, digits[val])
 		return
 	}
 	r1 := val - q1*1000
 	q2 := q1 / 1000
 	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, digits[q1], n)
-		writeBuf(stream.buf, digits[r1], n)
-		stream.n = n + 3
+		stream.buf = writeFirstBuf(stream.buf, digits[q1])
+		stream.buf = writeBuf(stream.buf, digits[r1])
 		return
 	}
 	r2 := q1 - q2*1000
 	q3 := q2 / 1000
 	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, digits[q2], n)
-		writeBuf(stream.buf, digits[r2], n)
-		writeBuf(stream.buf, digits[r1], n+3)
-		stream.n = n + 6
+		stream.buf = writeFirstBuf(stream.buf, digits[q2])
+		stream.buf = writeBuf(stream.buf, digits[r2])
+		stream.buf = writeBuf(stream.buf, digits[r1])
 		return
 	}
 	r3 := q2 - q3*1000
 	q4 := q3 / 1000
 	if q4 == 0 {
-		n = writeFirstBuf(stream.buf, digits[q3], n)
-		writeBuf(stream.buf, digits[r3], n)
-		writeBuf(stream.buf, digits[r2], n+3)
-		writeBuf(stream.buf, digits[r1], n+6)
-		stream.n = n + 9
+		stream.buf = writeFirstBuf(stream.buf, digits[q3])
+		stream.buf = writeBuf(stream.buf, digits[r3])
+		stream.buf = writeBuf(stream.buf, digits[r2])
+		stream.buf = writeBuf(stream.buf, digits[r1])
 		return
 	}
 	r4 := q3 - q4*1000
 	q5 := q4 / 1000
 	if q5 == 0 {
-		n = writeFirstBuf(stream.buf, digits[q4], n)
-		writeBuf(stream.buf, digits[r4], n)
-		writeBuf(stream.buf, digits[r3], n+3)
-		writeBuf(stream.buf, digits[r2], n+6)
-		writeBuf(stream.buf, digits[r1], n+9)
-		stream.n = n + 12
+		stream.buf = writeFirstBuf(stream.buf, digits[q4])
+		stream.buf = writeBuf(stream.buf, digits[r4])
+		stream.buf = writeBuf(stream.buf, digits[r3])
+		stream.buf = writeBuf(stream.buf, digits[r2])
+		stream.buf = writeBuf(stream.buf, digits[r1])
 		return
 	}
 	r5 := q4 - q5*1000
 	q6 := q5 / 1000
 	if q6 == 0 {
-		n = writeFirstBuf(stream.buf, digits[q5], n)
+		stream.buf = writeFirstBuf(stream.buf, digits[q5])
 	} else {
-		n = writeFirstBuf(stream.buf, digits[q6], n)
+		stream.buf = writeFirstBuf(stream.buf, digits[q6])
 		r6 := q5 - q6*1000
-		writeBuf(stream.buf, digits[r6], n)
-		n += 3
+		stream.buf = writeBuf(stream.buf, digits[r6])
 	}
-	writeBuf(stream.buf, digits[r5], n)
-	writeBuf(stream.buf, digits[r4], n+3)
-	writeBuf(stream.buf, digits[r3], n+6)
-	writeBuf(stream.buf, digits[r2], n+9)
-	writeBuf(stream.buf, digits[r1], n+12)
-	stream.n = n + 15
+	stream.buf = writeBuf(stream.buf, digits[r5])
+	stream.buf = writeBuf(stream.buf, digits[r4])
+	stream.buf = writeBuf(stream.buf, digits[r3])
+	stream.buf = writeBuf(stream.buf, digits[r2])
+	stream.buf = writeBuf(stream.buf, digits[r1])
 }
 
 // WriteInt64 write int64 to stream
 func (stream *Stream) WriteInt64(nval int64) {
-	stream.ensure(20)
-	n := stream.n
 	var val uint64
 	if nval < 0 {
 		val = uint64(-nval)
-		stream.buf[n] = '-'
-		n++
+		stream.buf = append(stream.buf, '-')
 	} else {
 		val = uint64(nval)
 	}
-	q1 := val / 1000
-	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, digits[val], n)
-		return
-	}
-	r1 := val - q1*1000
-	q2 := q1 / 1000
-	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, digits[q1], n)
-		writeBuf(stream.buf, digits[r1], n)
-		stream.n = n + 3
-		return
-	}
-	r2 := q1 - q2*1000
-	q3 := q2 / 1000
-	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, digits[q2], n)
-		writeBuf(stream.buf, digits[r2], n)
-		writeBuf(stream.buf, digits[r1], n+3)
-		stream.n = n + 6
-		return
-	}
-	r3 := q2 - q3*1000
-	q4 := q3 / 1000
-	if q4 == 0 {
-		n = writeFirstBuf(stream.buf, digits[q3], n)
-		writeBuf(stream.buf, digits[r3], n)
-		writeBuf(stream.buf, digits[r2], n+3)
-		writeBuf(stream.buf, digits[r1], n+6)
-		stream.n = n + 9
-		return
-	}
-	r4 := q3 - q4*1000
-	q5 := q4 / 1000
-	if q5 == 0 {
-		n = writeFirstBuf(stream.buf, digits[q4], n)
-		writeBuf(stream.buf, digits[r4], n)
-		writeBuf(stream.buf, digits[r3], n+3)
-		writeBuf(stream.buf, digits[r2], n+6)
-		writeBuf(stream.buf, digits[r1], n+9)
-		stream.n = n + 12
-		return
-	}
-	r5 := q4 - q5*1000
-	q6 := q5 / 1000
-	if q6 == 0 {
-		n = writeFirstBuf(stream.buf, digits[q5], n)
-	} else {
-		stream.buf[n] = byte(q6 + '0')
-		n++
-		r6 := q5 - q6*1000
-		writeBuf(stream.buf, digits[r6], n)
-		n += 3
-	}
-	writeBuf(stream.buf, digits[r5], n)
-	writeBuf(stream.buf, digits[r4], n+3)
-	writeBuf(stream.buf, digits[r3], n+6)
-	writeBuf(stream.buf, digits[r2], n+9)
-	writeBuf(stream.buf, digits[r1], n+12)
-	stream.n = n + 15
+	stream.WriteUint64(val)
 }
 
 // WriteInt write int to stream

feature_stream_string.go

@@ -219,34 +219,22 @@ var hex = "0123456789abcdef"
 
 // WriteStringWithHTMLEscaped write string to stream with html special characters escaped
 func (stream *Stream) WriteStringWithHTMLEscaped(s string) {
-	stream.ensure(32)
 	valLen := len(s)
-	toWriteLen := valLen
-	bufLengthMinusTwo := len(stream.buf) - 2 // make room for the quotes
-	if stream.n+toWriteLen > bufLengthMinusTwo {
-		toWriteLen = bufLengthMinusTwo - stream.n
-	}
-	n := stream.n
-	stream.buf[n] = '"'
-	n++
+	stream.buf = append(stream.buf, '"')
 	// write string, the fast path, without utf8 and escape support
 	i := 0
-	for ; i < toWriteLen; i++ {
+	for ; i < valLen; i++ {
 		c := s[i]
 		if c < utf8.RuneSelf && htmlSafeSet[c] {
-			stream.buf[n] = c
-			n++
+			stream.buf = append(stream.buf, c)
 		} else {
 			break
 		}
 	}
 	if i == valLen {
-		stream.buf[n] = '"'
-		n++
-		stream.n = n
+		stream.buf = append(stream.buf, '"')
 		return
 	}
-	stream.n = n
 	writeStringSlowPathWithHTMLEscaped(stream, i, s, valLen)
 }
 
@@ -321,34 +309,22 @@ func writeStringSlowPathWithHTMLEscaped(stream *Stream, i int, s string, valLen
 
 // WriteString write string to stream without html escape
 func (stream *Stream) WriteString(s string) {
-	stream.ensure(32)
 	valLen := len(s)
-	toWriteLen := valLen
-	bufLengthMinusTwo := len(stream.buf) - 2 // make room for the quotes
-	if stream.n+toWriteLen > bufLengthMinusTwo {
-		toWriteLen = bufLengthMinusTwo - stream.n
-	}
-	n := stream.n
-	stream.buf[n] = '"'
-	n++
+	stream.buf = append(stream.buf, '"')
 	// write string, the fast path, without utf8 and escape support
 	i := 0
-	for ; i < toWriteLen; i++ {
+	for ; i < valLen; i++ {
 		c := s[i]
 		if c > 31 && c != '"' && c != '\\' {
-			stream.buf[n] = c
-			n++
+			stream.buf = append(stream.buf, c)
 		} else {
 			break
 		}
 	}
 	if i == valLen {
-		stream.buf[n] = '"'
-		n++
-		stream.n = n
+		stream.buf = append(stream.buf, '"')
 		return
 	}
-	stream.n = n
 	writeStringSlowPath(stream, i, s, valLen)
 }
 

feature_stream_test.go

@@ -23,10 +23,10 @@ func Test_writeBytes_should_grow_buffer(t *testing.T) {
 	stream := NewStream(ConfigDefault, nil, 1)
 	stream.Write([]byte{'1', '2'})
 	should.Equal("12", string(stream.Buffer()))
-	should.Equal(3, len(stream.buf))
+	should.Equal(2, len(stream.buf))
 	stream.Write([]byte{'3', '4', '5', '6', '7'})
 	should.Equal("1234567", string(stream.Buffer()))
-	should.Equal(8, len(stream.buf))
+	should.Equal(7, len(stream.buf))
 }
 
 func Test_writeIndention_should_grow_buffer(t *testing.T) {
@@ -65,5 +65,5 @@ func Test_flush_buffer_should_stop_grow_buffer(t *testing.T) {
 	writer := new(NopWriter)
 	NewEncoder(writer).Encode(make([]int, 10000000))
 	should := require.New(t)
-	should.Equal(512, writer.bufferSize)
+	should.Equal(8, writer.bufferSize)
 }

jsoniter_adapter_test.go

@@ -1,84 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"encoding/json"
-	"github.com/stretchr/testify/require"
-	"io/ioutil"
-	"testing"
-)
-
-func Test_new_decoder(t *testing.T) {
-	should := require.New(t)
-	decoder1 := json.NewDecoder(bytes.NewBufferString(`[1][2]`))
-	decoder2 := 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 := 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)
-}
-
-func Test_use_number_for_unmarshal(t *testing.T) {
-	should := require.New(t)
-	api := Config{UseNumber: true}.Froze()
-	var obj interface{}
-	should.Nil(api.UnmarshalFromString("123", &obj))
-	should.Equal(json.Number("123"), obj)
-}
-
-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 = 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 = MarshalIndent(obj, "", "  ")
-	should.Nil(err)
-	should.Equal("{\n  \"1\": 2\n}", string(output))
-	output, err = ConfigCompatibleWithStandardLibrary.MarshalIndent(obj, "", "  ")
-	should.Nil(err)
-	should.Equal("{\n  \"1\": 2\n}", string(output))
-}

jsoniter_alias_test.go

@@ -1,62 +0,0 @@
-package jsoniter
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func Test_alias(t *testing.T) {
-	should := require.New(t)
-	type myint int
-	type myint8 int8
-	type myint16 int16
-	type myint32 int32
-	type myint64 int64
-	type myuint uint
-	type myuint8 uint8
-	type myuint16 uint16
-	type myuint32 uint32
-	type myuint64 uint64
-	type myfloat32 float32
-	type myfloat64 float64
-	type mystring string
-	type mybool bool
-	type myuintptr uintptr
-	var a struct {
-		A myint8    `json:"a"`
-		B myint16   `json:"stream"`
-		C myint32   `json:"c"`
-		D myint64   `json:"d"`
-		E myuint8   `json:"e"`
-		F myuint16  `json:"f"`
-		G myuint32  `json:"g"`
-		H myuint64  `json:"h"`
-		I myfloat32 `json:"i"`
-		J myfloat64 `json:"j"`
-		K mystring  `json:"k"`
-		L myint     `json:"l"`
-		M myuint    `json:"m"`
-		N mybool    `json:"n"`
-		O myuintptr `json:"o"`
-	}
-
-	should.Nil(UnmarshalFromString(`{"a" : 1, "stream" : 1, "c": 1, "d" : 1, "e" : 1, "f" : 1, "g" : 1, "h": 1, "i" : 1, "j" : 1, "k" :"xxxx", "l" : 1, "m":1, "n": true, "o" : 1}`, &a))
-	should.Equal(myfloat32(1), a.I)
-	should.Equal(myfloat64(1), a.J)
-	should.Equal(myint8(1), a.A)
-	should.Equal(myint16(1), a.B)
-	should.Equal(myint32(1), a.C)
-	should.Equal(myint64(1), a.D)
-	should.Equal(myuint8(1), a.E)
-	should.Equal(myuint16(1), a.F)
-	should.Equal(myuint32(1), a.G)
-	should.Equal(myuint64(1), a.H)
-	should.Equal(mystring("xxxx"), a.K)
-	should.Equal(mybool(true), a.N)
-	should.Equal(myuintptr(1), a.O)
-	b, err := Marshal(a)
-	should.Nil(err)
-	should.Equal(`{"a":1,"stream":1,"c":1,"d":1,"e":1,"f":1,"g":1,"h":1,"i":1,"j":1,"k":"xxxx","l":1,"m":1,"n":true,"o":1}`, string(b))
-
-}

jsoniter_any_map_test.go

@@ -1,14 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/stretchr/testify/require"
-	"testing"
-)
-
-func Test_wrap_map(t *testing.T) {
-	should := require.New(t)
-	any := Wrap(map[string]string{"Field1": "hello"})
-	should.Equal("hello", any.Get("Field1").ToString())
-	any = Wrap(map[string]string{"Field1": "hello"})
-	should.Equal(1, any.Size())
-}

jsoniter_bool_test.go

@@ -1,113 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func Test_true(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `true`)
-	should.True(iter.ReadBool())
-	iter = ParseString(ConfigDefault, `true`)
-	should.Equal(true, iter.Read())
-}
-
-func Test_false(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `false`)
-	should.False(iter.ReadBool())
-}
-
-func Test_write_true_false(t *testing.T) {
-	should := require.New(t)
-	buf := &bytes.Buffer{}
-	stream := NewStream(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 := NewStream(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())
-}
-
-func Test_encode_string_bool(t *testing.T) {
-	type TestObject struct {
-		Field bool `json:",omitempty,string"`
-	}
-	should := require.New(t)
-	output, err := json.Marshal(TestObject{true})
-	should.Nil(err)
-	should.Equal(`{"Field":"true"}`, string(output))
-	output, err = Marshal(TestObject{true})
-	should.Nil(err)
-	should.Equal(`{"Field":"true"}`, string(output))
-}
-
-func Test_decode_string_bool(t *testing.T) {
-	type TestObject struct {
-		Field bool `json:",omitempty,string"`
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	err := json.Unmarshal([]byte(`{"Field":"true"}`), &obj)
-	should.Nil(err)
-	should.True(obj.Field)
-
-	obj = TestObject{}
-	err = json.Unmarshal([]byte(`{"Field":true}`), &obj)
-	should.NotNil(err)
-
-	obj = TestObject{}
-	err = Unmarshal([]byte(`{"Field":"true"}`), &obj)
-	should.Nil(err)
-	should.True(obj.Field)
-
-	obj = TestObject{}
-	err = Unmarshal([]byte(`{"Field":true}`), &obj)
-	should.NotNil(err)
-}
-
-func Test_bool_can_be_null(t *testing.T) {
-	type TestData struct {
-		Field bool `json:"field"`
-	}
-	should := require.New(t)
-
-	obj := TestData{}
-	data1 := []byte(`{"field": true}`)
-	err := Unmarshal(data1, &obj)
-	should.NoError(err)
-	should.Equal(true, obj.Field)
-
-	data2 := []byte(`{"field": null}`)
-	err = Unmarshal(data2, &obj)
-	should.NoError(err)
-	// Same behavior as stdlib, not touching the existing value.
-	should.Equal(true, obj.Field)
-
-	// Checking stdlib behavior as well
-	obj2 := TestData{}
-	err = json.Unmarshal(data1, &obj2)
-	should.NoError(err)
-	should.Equal(true, obj2.Field)
-
-	err = json.Unmarshal(data2, &obj2)
-	should.NoError(err)
-	should.Equal(true, obj2.Field)
-}

jsoniter_customize_test.go

@@ -1,342 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"strconv"
-	"testing"
-	"time"
-	"unsafe"
-
-	"github.com/stretchr/testify/require"
-)
-
-func Test_customize_type_decoder(t *testing.T) {
-	RegisterTypeDecoderFunc("time.Time", func(ptr unsafe.Pointer, iter *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 ConfigDefault.(*frozenConfig).cleanDecoders()
-	val := time.Time{}
-	err := 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_type_encoder(t *testing.T) {
-	should := require.New(t)
-	RegisterTypeEncoderFunc("time.Time", func(ptr unsafe.Pointer, stream *Stream) {
-		t := *((*time.Time)(ptr))
-		stream.WriteString(t.UTC().Format("2006-01-02 15:04:05"))
-	}, nil)
-	defer ConfigDefault.(*frozenConfig).cleanEncoders()
-	val := time.Unix(0, 0)
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`"1970-01-01 00:00:00"`, str)
-}
-
-func Test_customize_byte_array_encoder(t *testing.T) {
-	ConfigDefault.(*frozenConfig).cleanEncoders()
-	should := require.New(t)
-	RegisterTypeEncoderFunc("[]uint8", func(ptr unsafe.Pointer, stream *Stream) {
-		t := *((*[]byte)(ptr))
-		stream.WriteString(string(t))
-	}, nil)
-	defer ConfigDefault.(*frozenConfig).cleanEncoders()
-	val := []byte("abc")
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`"abc"`, str)
-}
-
-func Test_customize_float_marshal(t *testing.T) {
-	should := require.New(t)
-	json := Config{MarshalFloatWith6Digits: true}.Froze()
-	str, err := json.MarshalToString(float32(1.23456789))
-	should.Nil(err)
-	should.Equal("1.234568", str)
-}
-
-type Tom struct {
-	field1 string
-}
-
-func Test_customize_field_decoder(t *testing.T) {
-	RegisterFieldDecoderFunc("jsoniter.Tom", "field1", func(ptr unsafe.Pointer, iter *Iterator) {
-		*((*string)(ptr)) = strconv.Itoa(iter.ReadInt())
-	})
-	defer ConfigDefault.(*frozenConfig).cleanDecoders()
-	tom := Tom{}
-	err := Unmarshal([]byte(`{"field1": 100}`), &tom)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-type TestObject1 struct {
-	Field1 string
-}
-
-type testExtension struct {
-	DummyExtension
-}
-
-func (extension *testExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
-	if structDescriptor.Type.String() != "jsoniter.TestObject1" {
-		return
-	}
-	binding := structDescriptor.GetField("Field1")
-	binding.Encoder = &funcEncoder{fun: func(ptr unsafe.Pointer, stream *Stream) {
-		str := *((*string)(ptr))
-		val, _ := strconv.Atoi(str)
-		stream.WriteInt(val)
-	}}
-	binding.Decoder = &funcDecoder{func(ptr unsafe.Pointer, iter *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 := 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)
-}
-
-type timeImplementedMarshaler time.Time
-
-func (obj timeImplementedMarshaler) MarshalJSON() ([]byte, error) {
-	seconds := time.Time(obj).Unix()
-	return []byte(strconv.FormatInt(seconds, 10)), nil
-}
-
-func Test_marshaler(t *testing.T) {
-	type TestObject struct {
-		Field timeImplementedMarshaler
-	}
-	should := require.New(t)
-	val := timeImplementedMarshaler(time.Unix(123, 0))
-	obj := TestObject{val}
-	bytes, err := json.Marshal(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":123}`, string(bytes))
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":123}`, str)
-}
-
-func Test_marshaler_and_encoder(t *testing.T) {
-	type TestObject struct {
-		Field *timeImplementedMarshaler
-	}
-	ConfigDefault.(*frozenConfig).cleanEncoders()
-	should := require.New(t)
-	RegisterTypeEncoderFunc("jsoniter.timeImplementedMarshaler", func(ptr unsafe.Pointer, stream *Stream) {
-		stream.WriteString("hello from encoder")
-	}, nil)
-	val := timeImplementedMarshaler(time.Unix(123, 0))
-	obj := TestObject{&val}
-	bytes, err := json.Marshal(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":123}`, string(bytes))
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":"hello from encoder"}`, str)
-}
-
-type ObjectImplementedUnmarshaler int
-
-func (obj *ObjectImplementedUnmarshaler) UnmarshalJSON(s []byte) error {
-	val, _ := strconv.ParseInt(string(s[1:len(s)-1]), 10, 64)
-	*obj = ObjectImplementedUnmarshaler(val)
-	return nil
-}
-
-func Test_unmarshaler(t *testing.T) {
-	should := require.New(t)
-	var obj ObjectImplementedUnmarshaler
-	err := json.Unmarshal([]byte(`   "100" `), &obj)
-	should.Nil(err)
-	should.Equal(100, int(obj))
-	iter := ParseString(ConfigDefault, `   "100" `)
-	iter.ReadVal(&obj)
-	should.Nil(err)
-	should.Equal(100, int(obj))
-}
-
-func Test_unmarshaler_and_decoder(t *testing.T) {
-	type TestObject struct {
-		Field  *ObjectImplementedUnmarshaler
-		Field2 string
-	}
-	ConfigDefault.(*frozenConfig).cleanDecoders()
-	should := require.New(t)
-	RegisterTypeDecoderFunc("jsoniter.ObjectImplementedUnmarshaler", func(ptr unsafe.Pointer, iter *Iterator) {
-		*(*ObjectImplementedUnmarshaler)(ptr) = 10
-		iter.Skip()
-	})
-	obj := TestObject{}
-	val := ObjectImplementedUnmarshaler(0)
-	obj.Field = &val
-	err := json.Unmarshal([]byte(`{"Field":"100"}`), &obj)
-	should.Nil(err)
-	should.Equal(100, int(*obj.Field))
-	err = Unmarshal([]byte(`{"Field":"100"}`), &obj)
-	should.Nil(err)
-	should.Equal(10, int(*obj.Field))
-}
-
-type tmString string
-type tmStruct struct {
-	String tmString
-}
-
-func (s tmStruct) MarshalJSON() ([]byte, error) {
-	var b []byte
-	b = append(b, '"')
-	b = append(b, s.String...)
-	b = append(b, '"')
-	return b, nil
-}
-
-func Test_marshaler_on_struct(t *testing.T) {
-	fixed := tmStruct{"hello"}
-	//json.Marshal(fixed)
-	Marshal(fixed)
-}
-
-type withChan struct {
-	F2 chan []byte
-}
-
-func (q withChan) MarshalJSON() ([]byte, error) {
-	return []byte(`""`), nil
-}
-
-func (q *withChan) UnmarshalJSON(value []byte) error {
-	return nil
-}
-
-func Test_marshal_json_with_chan(t *testing.T) {
-	type TestObject struct {
-		F1 withChan
-	}
-	should := require.New(t)
-	output, err := MarshalToString(TestObject{})
-	should.Nil(err)
-	should.Equal(`{"F1":""}`, output)
-}
-
-type withTime struct {
-	time.Time
-}
-
-func (t *withTime) UnmarshalJSON(b []byte) error {
-	return nil
-}
-func (t withTime) MarshalJSON() ([]byte, error) {
-	return []byte(`"fake"`), nil
-}
-
-func Test_marshal_json_with_time(t *testing.T) {
-	type S1 struct {
-		F1 withTime
-		F2 *withTime
-	}
-	type TestObject struct {
-		TF1 S1
-	}
-	should := require.New(t)
-	obj := TestObject{
-		S1{
-			F1: withTime{
-				time.Unix(0, 0),
-			},
-			F2: &withTime{
-				time.Unix(0, 0),
-			},
-		},
-	}
-	output, err := json.Marshal(obj)
-	should.Nil(err)
-	should.Equal(`{"TF1":{"F1":"fake","F2":"fake"}}`, string(output))
-	output, err = Marshal(obj)
-	should.Nil(err)
-	should.Equal(`{"TF1":{"F1":"fake","F2":"fake"}}`, string(output))
-	obj = TestObject{}
-	should.Nil(json.Unmarshal([]byte(`{"TF1":{"F1":"fake","F2":"fake"}}`), &obj))
-	should.NotNil(obj.TF1.F2)
-	obj = TestObject{}
-	should.Nil(Unmarshal([]byte(`{"TF1":{"F1":"fake","F2":"fake"}}`), &obj))
-	should.NotNil(obj.TF1.F2)
-}
-
-func Test_customize_tag_key(t *testing.T) {
-
-	type TestObject struct {
-		Field string `orm:"field"`
-	}
-
-	should := require.New(t)
-	json := Config{TagKey: "orm"}.Froze()
-	str, err := json.MarshalToString(TestObject{"hello"})
-	should.Nil(err)
-	should.Equal(`{"field":"hello"}`, str)
-}
-
-func Test_recursive_empty_interface_customization(t *testing.T) {
-	t.Skip()
-	var obj interface{}
-	RegisterTypeDecoderFunc("interface {}", func(ptr unsafe.Pointer, iter *Iterator) {
-		switch iter.WhatIsNext() {
-		case NumberValue:
-			*(*interface{})(ptr) = iter.ReadInt64()
-		default:
-			*(*interface{})(ptr) = iter.Read()
-		}
-	})
-	should := require.New(t)
-	Unmarshal([]byte("[100]"), &obj)
-	should.Equal([]interface{}{int64(100)}, obj)
-}
-
-type GeoLocation struct {
-	Id string `json:"id,omitempty" db:"id"`
-}
-
-func (p *GeoLocation) MarshalJSON() ([]byte, error) {
-	return []byte(`{}`), nil
-}
-
-func (p *GeoLocation) UnmarshalJSON(input []byte) error {
-	p.Id = "hello"
-	return nil
-}
-
-func Test_marshal_and_unmarshal_on_non_pointer(t *testing.T) {
-	should := require.New(t)
-	locations := []GeoLocation{{"000"}}
-	bytes, err := Marshal(locations)
-	should.Nil(err)
-	should.Equal("[{}]", string(bytes))
-	err = Unmarshal([]byte("[1]"), &locations)
-	should.Nil(err)
-	should.Equal("hello", locations[0].Id)
-}

jsoniter_demo_test.go

@@ -1,87 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func Test_bind_api_demo(t *testing.T) {
-	should := require.New(t)
-	val := []int{}
-	err := UnmarshalFromString(`[0,1,2,3]  `, &val)
-	should.Nil(err)
-	should.Equal([]int{0, 1, 2, 3}, val)
-}
-
-func Test_iterator_api_demo(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `[0,1,2,3]`)
-	total := 0
-	for iter.ReadArray() {
-		total += iter.ReadInt()
-	}
-	should.Equal(6, total)
-}
-
-type People struct {
-	Name    string
-	Gender  string
-	Age     int
-	Address string
-	Mobile  string
-	Country string
-	Height  int
-}
-
-func jsoniterMarshal(p *People) error {
-	_, err := Marshal(p)
-	if nil != err {
-		return err
-	}
-	return nil
-}
-func stdMarshal(p *People) error {
-	_, err := json.Marshal(p)
-	if nil != err {
-		return err
-	}
-	return nil
-}
-
-func BenchmarkJosniterMarshal(b *testing.B) {
-	var p People
-	p.Address = "上海市徐汇区漕宝路"
-	p.Age = 30
-	p.Country = "中国"
-	p.Gender = "male"
-	p.Height = 170
-	p.Mobile = "18502120533"
-	p.Name = "Elvin"
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		err := jsoniterMarshal(&p)
-		if nil != err {
-			b.Error(err)
-		}
-	}
-}
-
-func BenchmarkStdMarshal(b *testing.B) {
-	var p People
-	p.Address = "上海市徐汇区漕宝路"
-	p.Age = 30
-	p.Country = "中国"
-	p.Gender = "male"
-	p.Height = 170
-	p.Mobile = "18502120533"
-	p.Name = "Elvin"
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		err := stdMarshal(&p)
-		if nil != err {
-			b.Error(err)
-		}
-	}
-}

jsoniter_encode_interface_test.go

@@ -1,42 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func Test_encode_interface(t *testing.T) {
-	should := require.New(t)
-	var a interface{}
-	a = int8(10)
-	str, err := MarshalToString(a)
-	should.Nil(err)
-	should.Equal(str, "10")
-	a = float32(3)
-	str, err = MarshalToString(a)
-	should.Nil(err)
-	should.Equal(str, "3")
-	a = map[string]interface{}{"abc": 1}
-	str, err = MarshalToString(a)
-	should.Nil(err)
-	should.Equal(str, `{"abc":1}`)
-	a = uintptr(1)
-	str, err = MarshalToString(a)
-	should.Nil(err)
-	should.Equal(str, "1")
-	a = uint(1)
-	str, err = MarshalToString(a)
-	should.Nil(err)
-	should.Equal(str, "1")
-	a = uint8(1)
-	str, err = MarshalToString(a)
-	should.Nil(err)
-	should.Equal(str, "1")
-	a = json.RawMessage("abc")
-	MarshalToString(a)
-	str, err = MarshalToString(a)
-	should.Nil(err)
-	should.Equal(str, "abc")
-}

jsoniter_enum_marshaler_test.go

@@ -1,50 +0,0 @@
-package jsoniter
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-type MyEnum int64
-
-const (
-	MyEnumA MyEnum = iota
-	MyEnumB
-)
-
-func (m *MyEnum) MarshalJSON() ([]byte, error) {
-	return []byte(fmt.Sprintf(`"foo-%d"`, int(*m))), nil
-}
-
-func (m *MyEnum) UnmarshalJSON(jb []byte) error {
-	switch string(jb) {
-	case `"foo-1"`:
-		*m = MyEnumB
-	default:
-		*m = MyEnumA
-	}
-	return nil
-}
-
-func Test_custom_marshaler_on_enum(t *testing.T) {
-	type Wrapper struct {
-		Payload interface{}
-	}
-	type Wrapper2 struct {
-		Payload MyEnum
-	}
-	should := require.New(t)
-
-	w := Wrapper{Payload: MyEnumB}
-
-	jb, err := Marshal(w)
-	should.NoError(err)
-	should.Equal(`{"Payload":"foo-1"}`, string(jb))
-
-	var w2 Wrapper2
-	err = Unmarshal(jb, &w2)
-	should.NoError(err)
-	should.Equal(MyEnumB, w2.Payload)
-}

jsoniter_fixed_array_test.go

@@ -1,46 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"github.com/stretchr/testify/require"
-	"testing"
-)
-
-func Test_encode_fixed_array(t *testing.T) {
-	should := require.New(t)
-	type FixedArray [2]float64
-	fixed := FixedArray{0.1, 1.0}
-	output, err := MarshalToString(fixed)
-	should.Nil(err)
-	should.Equal("[0.1,1]", output)
-}
-
-func Test_encode_fixed_array_empty(t *testing.T) {
-	should := require.New(t)
-	type FixedArray [0]float64
-	fixed := FixedArray{}
-	output, err := MarshalToString(fixed)
-	should.Nil(err)
-	should.Equal("[]", output)
-}
-
-func Test_encode_fixed_array_of_map(t *testing.T) {
-	should := require.New(t)
-	type FixedArray [2]map[string]string
-	fixed := FixedArray{map[string]string{"1": "2"}, map[string]string{"3": "4"}}
-	output, err := MarshalToString(fixed)
-	should.Nil(err)
-	should.Equal(`[{"1":"2"},{"3":"4"}]`, output)
-}
-
-func Test_decode_fixed_array(t *testing.T) {
-	should := require.New(t)
-	type FixedArray [2]float64
-	var fixed FixedArray
-	should.Nil(json.Unmarshal([]byte("[1,2,3]"), &fixed))
-	should.Equal(float64(1), fixed[0])
-	should.Equal(float64(2), fixed[1])
-	should.Nil(Unmarshal([]byte("[1,2,3]"), &fixed))
-	should.Equal(float64(1), fixed[0])
-	should.Equal(float64(2), fixed[1])
-}

jsoniter_interface_test.go

@@ -1,576 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"fmt"
-	"testing"
-	"unsafe"
-
-	"github.com/stretchr/testify/require"
-	"reflect"
-)
-
-func Test_write_empty_interface_via_placeholder(t *testing.T) {
-	fmt.Println(^uint(0) >> 1)
-	should := require.New(t)
-	m := map[uint32]interface{}{1: "hello"}
-	inf := reflect.ValueOf(m).MapIndex(reflect.ValueOf(uint32(1))).Interface()
-	encoder := &placeholderEncoder{
-		cfg:      ConfigFastest.(*frozenConfig),
-		cacheKey: reflect.TypeOf(m).Elem(),
-	}
-	stream := ConfigFastest.BorrowStream(nil)
-	encoderOfType(ConfigFastest.(*frozenConfig), "", reflect.TypeOf(m).Elem())
-	encoder.EncodeInterface(inf, stream)
-	should.Equal(`"hello"`, string(stream.Buffer()))
-}
-
-func Test_write_array_of_interface(t *testing.T) {
-	should := require.New(t)
-	array := []interface{}{"hello"}
-	str, err := MarshalToString(array)
-	should.Nil(err)
-	should.Equal(`["hello"]`, str)
-}
-
-func Test_write_map_of_interface(t *testing.T) {
-	should := require.New(t)
-	val := map[string]interface{}{"hello": "world"}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"hello":"world"}`, str)
-}
-
-func Test_write_map_of_interface_in_struct(t *testing.T) {
-	type TestObject struct {
-		Field map[string]interface{}
-	}
-	should := require.New(t)
-	val := TestObject{map[string]interface{}{"hello": "world"}}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"Field":{"hello":"world"}}`, str)
-}
-
-func Test_write_map_of_interface_in_struct_with_two_fields(t *testing.T) {
-	type TestObject struct {
-		Field  map[string]interface{}
-		Field2 string
-	}
-	should := require.New(t)
-	val := TestObject{map[string]interface{}{"hello": "world"}, ""}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Contains(str, `"Field":{"hello":"world"}`)
-}
-
-type MyInterface interface {
-	Hello() string
-}
-
-type MyString string
-
-func (ms MyString) Hello() string {
-	return string(ms)
-}
-
-func Test_write_map_of_custom_interface(t *testing.T) {
-	should := require.New(t)
-	myStr := MyString("world")
-	should.Equal("world", myStr.Hello())
-	val := map[string]MyInterface{"hello": myStr}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"hello":"world"}`, str)
-}
-
-func Test_write_interface(t *testing.T) {
-	should := require.New(t)
-	var val interface{}
-	val = "hello"
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`"hello"`, str)
-}
-
-func Test_read_interface(t *testing.T) {
-	should := require.New(t)
-	var val interface{}
-	err := UnmarshalFromString(`"hello"`, &val)
-	should.Nil(err)
-	should.Equal("hello", val)
-	err = UnmarshalFromString(`1e1`, &val)
-	should.Nil(err)
-	should.Equal(float64(10), val)
-	err = UnmarshalFromString(`1.0e1`, &val)
-	should.Nil(err)
-	should.Equal(float64(10), val)
-	err = json.Unmarshal([]byte(`1.0e1`), &val)
-	should.Nil(err)
-	should.Equal(float64(10), val)
-}
-
-func Test_read_custom_interface(t *testing.T) {
-	should := require.New(t)
-	var val MyInterface
-	RegisterTypeDecoderFunc("jsoniter.MyInterface", func(ptr unsafe.Pointer, iter *Iterator) {
-		*((*MyInterface)(ptr)) = MyString(iter.ReadString())
-	})
-	err := UnmarshalFromString(`"hello"`, &val)
-	should.Nil(err)
-	should.Equal("hello", val.Hello())
-}
-
-func Test_decode_object_contain_empty_interface(t *testing.T) {
-	type TestObject struct {
-		Field interface{}
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	obj.Field = 1024
-	should.Nil(UnmarshalFromString(`{"Field": "hello"}`, &obj))
-	should.Equal("hello", obj.Field)
-}
-
-func Test_decode_object_contain_non_empty_interface(t *testing.T) {
-	type TestObject struct {
-		Field MyInterface
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	obj.Field = MyString("abc")
-	should.Nil(UnmarshalFromString(`{"Field": "hello"}`, &obj))
-	should.Equal(MyString("hello"), obj.Field)
-}
-
-func Test_encode_object_contain_empty_interface(t *testing.T) {
-	type TestObject struct {
-		Field interface{}
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	obj.Field = 1024
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":1024}`, str)
-}
-
-func Test_encode_object_contain_non_empty_interface(t *testing.T) {
-	type TestObject struct {
-		Field MyInterface
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	obj.Field = MyString("hello")
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":"hello"}`, str)
-}
-
-func Test_nil_non_empty_interface(t *testing.T) {
-	ConfigDefault.(*frozenConfig).cleanEncoders()
-	ConfigDefault.(*frozenConfig).cleanDecoders()
-	type TestObject struct {
-		Field []MyInterface
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	b := []byte(`{"Field":["AAA"]}`)
-	should.NotNil(json.Unmarshal(b, &obj))
-	should.NotNil(Unmarshal(b, &obj))
-}
-
-func Test_read_large_number_as_interface(t *testing.T) {
-	should := require.New(t)
-	var val interface{}
-	err := Config{UseNumber: true}.Froze().UnmarshalFromString(`123456789123456789123456789`, &val)
-	should.Nil(err)
-	output, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`123456789123456789123456789`, output)
-}
-
-func Test_nested_one_field_struct(t *testing.T) {
-	should := require.New(t)
-	type YetYetAnotherObject struct {
-		Field string
-	}
-	type YetAnotherObject struct {
-		Field *YetYetAnotherObject
-	}
-	type AnotherObject struct {
-		Field *YetAnotherObject
-	}
-	type TestObject struct {
-		Me *AnotherObject
-	}
-	obj := TestObject{&AnotherObject{&YetAnotherObject{&YetYetAnotherObject{"abc"}}}}
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Me":{"Field":{"Field":{"Field":"abc"}}}}`, str)
-	str, err = MarshalToString(&obj)
-	should.Nil(err)
-	should.Equal(`{"Me":{"Field":{"Field":{"Field":"abc"}}}}`, str)
-}
-
-func Test_struct_with_embedded_ptr_with_tag(t *testing.T) {
-	type O1 struct {
-		O1F string
-	}
-
-	type Option struct {
-		O1 *O1
-	}
-
-	type T struct {
-		Option `json:","`
-	}
-	var obj T
-	should := require.New(t)
-	output, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"O1":null}`, output)
-}
-
-func Test_struct_with_one_nil(t *testing.T) {
-	type TestObject struct {
-		F *float64
-	}
-	var obj TestObject
-	should := require.New(t)
-	output, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"F":null}`, output)
-}
-
-func Test_struct_with_one_nil_embedded(t *testing.T) {
-	type Parent struct {
-		Field1 string
-		Field2 string
-	}
-	type TestObject struct {
-		*Parent
-	}
-	obj := TestObject{}
-	should := require.New(t)
-	bytes, err := json.Marshal(obj)
-	should.Nil(err)
-	should.Equal("{}", string(bytes))
-	output, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{}`, output)
-}
-
-func Test_struct_with_not_nil_embedded(t *testing.T) {
-	type Parent struct {
-		Field0 string
-		Field1 []string
-		Field2 map[string]interface{}
-	}
-	type TestObject struct {
-		*Parent
-	}
-	should := require.New(t)
-	var obj TestObject
-	err := UnmarshalFromString(`{"Field0":"1","Field1":null,"Field2":{"K":"V"}}`, &obj)
-	should.Nil(err)
-	should.Nil(obj.Field1)
-	should.Equal(map[string]interface{}{"K": "V"}, obj.Field2)
-	should.Equal("1", obj.Field0)
-}
-
-func Test_array_with_one_nil_ptr(t *testing.T) {
-	obj := [1]*float64{nil}
-	should := require.New(t)
-	output, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`[null]`, output)
-}
-
-func Test_array_with_one_not_nil_ptr(t *testing.T) {
-	two := float64(2)
-	obj := [1]*float64{&two}
-	should := require.New(t)
-	output, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`[2]`, output)
-}
-
-func Test_embedded_array_with_one_nil(t *testing.T) {
-	type TestObject struct {
-		Field1 int
-		Field2 [1]*float64
-	}
-	var obj TestObject
-	should := require.New(t)
-	output, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Contains(output, `"Field2":[null]`)
-}
-
-func Test_array_with_nothing(t *testing.T) {
-	var obj [2]*float64
-	should := require.New(t)
-	output, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`[null,null]`, output)
-}
-
-func Test_unmarshal_ptr_to_interface(t *testing.T) {
-	type TestData struct {
-		Name string `json:"name"`
-	}
-	should := require.New(t)
-	var obj interface{} = &TestData{}
-	err := json.Unmarshal([]byte(`{"name":"value"}`), &obj)
-	should.Nil(err)
-	should.Equal("&{value}", fmt.Sprintf("%v", obj))
-	obj = interface{}(&TestData{})
-	err = Unmarshal([]byte(`{"name":"value"}`), &obj)
-	should.Nil(err)
-	should.Equal("&{value}", fmt.Sprintf("%v", 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 := Unmarshal(data1, &obj)
-	should.NoError(err)
-	should.Equal(true, *(obj.Field.(*bool)))
-
-	data2 := []byte(`{"field": null}`)
-
-	err = Unmarshal(data2, &obj)
-	should.NoError(err)
-	should.Equal(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_omitempty_nil_interface(t *testing.T) {
-	type TestData struct {
-		Field interface{} `json:"field,omitempty"`
-	}
-	should := require.New(t)
-
-	obj := TestData{
-		Field: nil,
-	}
-
-	js, err := json.Marshal(obj)
-	should.NoError(err)
-	should.Equal("{}", string(js))
-
-	str, err := MarshalToString(obj)
-	should.NoError(err)
-	should.Equal(string(js), str)
-}
-
-func Test_omitempty_nil_nonempty_interface(t *testing.T) {
-	type TestData struct {
-		Field MyInterface `json:"field,omitempty"`
-	}
-	should := require.New(t)
-
-	obj := TestData{
-		Field: nil,
-	}
-
-	js, err := json.Marshal(obj)
-	should.NoError(err)
-	should.Equal("{}", string(js))
-
-	str, err := MarshalToString(obj)
-	should.NoError(err)
-	should.Equal(string(js), str)
-
-	obj.Field = MyString("hello")
-	err = UnmarshalFromString(`{"field":null}`, &obj)
-	should.NoError(err)
-	should.Nil(obj.Field)
-}
-
-func Test_marshal_nil_marshaler_interface(t *testing.T) {
-	type TestData struct {
-		Field json.Marshaler `json:"field"`
-	}
-	should := require.New(t)
-
-	obj := TestData{
-		Field: nil,
-	}
-
-	js, err := json.Marshal(obj)
-	should.NoError(err)
-	should.Equal(`{"field":null}`, string(js))
-
-	str, err := MarshalToString(obj)
-	should.NoError(err)
-	should.Equal(string(js), str)
-}
-
-func Test_marshal_nil_nonempty_interface(t *testing.T) {
-	type TestData struct {
-		Field MyInterface `json:"field"`
-	}
-	should := require.New(t)
-
-	obj := TestData{
-		Field: nil,
-	}
-
-	js, err := json.Marshal(obj)
-	should.NoError(err)
-	should.Equal(`{"field":null}`, string(js))
-
-	str, err := MarshalToString(obj)
-	should.NoError(err)
-	should.Equal(string(js), str)
-
-	obj.Field = MyString("hello")
-	err = Unmarshal(js, &obj)
-	should.NoError(err)
-	should.Equal(nil, obj.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.Equal(nil, err)
-	should.Equal(&payload, wrapper.Payload)
-	should.Equal(42, (*(wrapper.Payload.(**Payload))).Value)
-
-	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
-	should.Equal(nil, err)
-	should.Equal(&payload, wrapper.Payload)
-	should.Equal((*Payload)(nil), payload)
-
-	payload = &Payload{}
-	wrapper = &Wrapper{
-		Payload: &payload,
-	}
-
-	err = Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
-	should.Equal(nil, err)
-	should.Equal(&payload, wrapper.Payload)
-	should.Equal(42, (*(wrapper.Payload.(**Payload))).Value)
-
-	err = Unmarshal([]byte(`{"payload": null}`), &wrapper)
-	should.Equal(nil, 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.Equal(nil, err)
-	should.Equal(42, (*(wrapper.Payload.(*Payload))).Value)
-
-	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
-	should.Equal(nil, err)
-	should.Equal(nil, wrapper.Payload)
-	should.Equal(42, payload.Value)
-
-	payload = &Payload{}
-	wrapper = &Wrapper{
-		Payload: payload,
-	}
-
-	err = Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
-	should.Equal(nil, err)
-	should.Equal(42, (*(wrapper.Payload.(*Payload))).Value)
-
-	err = 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.Nil(err)
-	should.NotNil(wrapper.Payload)
-	should.Nil(payload)
-
-	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
-	should.Nil(err)
-	should.Nil(wrapper.Payload)
-	should.Nil(payload)
-
-	payload = nil
-	wrapper = &Wrapper{
-		Payload: payload,
-	}
-
-	err = Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
-	should.Nil(err)
-	should.NotNil(wrapper.Payload)
-	should.Nil(payload)
-
-	err = Unmarshal([]byte(`{"payload": null}`), &wrapper)
-	should.Nil(err)
-	should.Nil(wrapper.Payload)
-	should.Nil(payload)
-}

jsoniter_io_test.go

@@ -1,65 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"github.com/stretchr/testify/require"
-	"io"
-	"testing"
-)
-
-func Test_read_by_one(t *testing.T) {
-	iter := Parse(ConfigDefault, bytes.NewBufferString("abc"), 1)
-	b := iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'a' {
-		t.Fatal(b)
-	}
-	iter.unreadByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	b = iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'a' {
-		t.Fatal(b)
-	}
-}
-
-func Test_read_by_two(t *testing.T) {
-	should := require.New(t)
-	iter := Parse(ConfigDefault, bytes.NewBufferString("abc"), 2)
-	b := iter.readByte()
-	should.Nil(iter.Error)
-	should.Equal(byte('a'), b)
-	b = iter.readByte()
-	should.Nil(iter.Error)
-	should.Equal(byte('b'), b)
-	iter.unreadByte()
-	should.Nil(iter.Error)
-	iter.unreadByte()
-	should.Nil(iter.Error)
-	b = iter.readByte()
-	should.Nil(iter.Error)
-	should.Equal(byte('a'), b)
-}
-
-func Test_read_until_eof(t *testing.T) {
-	iter := Parse(ConfigDefault, bytes.NewBufferString("abc"), 2)
-	iter.readByte()
-	iter.readByte()
-	b := iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'c' {
-		t.Fatal(b)
-	}
-	iter.readByte()
-	if iter.Error != io.EOF {
-		t.Fatal(iter.Error)
-	}
-}

jsoniter_map_test.go

@@ -1,160 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"math/big"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-	"strings"
-)
-
-func Test_read_map(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `{"hello": "world"}`)
-	m := map[string]string{"1": "2"}
-	iter.ReadVal(&m)
-	copy(iter.buf, []byte{0, 0, 0, 0, 0, 0})
-	should.Equal(map[string]string{"1": "2", "hello": "world"}, m)
-}
-
-func Test_read_map_of_interface(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `{"hello": "world"}`)
-	m := map[string]interface{}{"1": "2"}
-	iter.ReadVal(&m)
-	should.Equal(map[string]interface{}{"1": "2", "hello": "world"}, m)
-	iter = ParseString(ConfigDefault, `{"hello": "world"}`)
-	should.Equal(map[string]interface{}{"hello": "world"}, iter.Read())
-}
-
-func Test_map_wrapper_any_get_all(t *testing.T) {
-	should := require.New(t)
-	any := Wrap(map[string][]int{"Field1": {1, 2}})
-	should.Equal(`{"Field1":1}`, any.Get('*', 0).ToString())
-	should.Contains(any.Keys(), "Field1")
-
-	// map write to
-	stream := NewStream(ConfigDefault, nil, 0)
-	any.WriteTo(stream)
-	// TODO cannot pass
-	//should.Equal(string(stream.buf), "")
-}
-
-func Test_write_val_map(t *testing.T) {
-	should := require.New(t)
-	val := map[string]string{"1": "2"}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"1":"2"}`, str)
-}
-
-func Test_slice_of_map(t *testing.T) {
-	should := require.New(t)
-	val := []map[string]string{{"1": "2"}}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`[{"1":"2"}]`, str)
-	val = []map[string]string{}
-	should.Nil(UnmarshalFromString(str, &val))
-	should.Equal("2", val[0]["1"])
-}
-
-func Test_encode_int_key_map(t *testing.T) {
-	should := require.New(t)
-	val := map[int]string{1: "2"}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"1":"2"}`, str)
-}
-
-func Test_decode_int_key_map(t *testing.T) {
-	should := require.New(t)
-	var val map[int]string
-	should.Nil(UnmarshalFromString(`{"1":"2"}`, &val))
-	should.Equal(map[int]string{1: "2"}, val)
-}
-
-func Test_encode_TextMarshaler_key_map(t *testing.T) {
-	should := require.New(t)
-	f, _, _ := big.ParseFloat("1", 10, 64, big.ToZero)
-	val := map[*big.Float]string{f: "2"}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"1":"2"}`, str)
-}
-
-func Test_decode_TextMarshaler_key_map(t *testing.T) {
-	should := require.New(t)
-	var val map[*big.Float]string
-	should.Nil(UnmarshalFromString(`{"1":"2"}`, &val))
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"1":"2"}`, str)
-}
-
-func Test_map_key_with_escaped_char(t *testing.T) {
-	type Ttest struct {
-		Map map[string]string
-	}
-	var jsonBytes = []byte(`
-	{
-	    "Map":{
-		"k\"ey": "val"
-	    }
-	}`)
-	should := require.New(t)
-	{
-		var obj Ttest
-		should.Nil(json.Unmarshal(jsonBytes, &obj))
-		should.Equal(map[string]string{"k\"ey": "val"}, obj.Map)
-	}
-	{
-		var obj Ttest
-		should.Nil(Unmarshal(jsonBytes, &obj))
-		should.Equal(map[string]string{"k\"ey": "val"}, obj.Map)
-	}
-}
-
-func Test_encode_map_with_sorted_keys(t *testing.T) {
-	should := require.New(t)
-	m := map[string]interface{}{
-		"3": 3,
-		"1": 1,
-		"2": 2,
-	}
-	bytes, err := json.Marshal(m)
-	should.Nil(err)
-	output, err := ConfigCompatibleWithStandardLibrary.MarshalToString(m)
-	should.Nil(err)
-	should.Equal(string(bytes), output)
-}
-
-func Test_encode_map_uint_keys(t *testing.T) {
-	should := require.New(t)
-	m := map[uint64]interface{}{
-		uint64(1): "a",
-		uint64(2): "a",
-		uint64(4): "a",
-	}
-
-	bytes, err := json.Marshal(m)
-	should.Nil(err)
-
-	output, err := ConfigCompatibleWithStandardLibrary.MarshalToString(m)
-	should.Nil(err)
-	should.Equal(string(bytes), output)
-}
-
-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 := 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"])
-}

jsoniter_null_test.go

@@ -1,168 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"encoding/json"
-	"io"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func Test_read_null(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `null`)
-	should.True(iter.ReadNil())
-	iter = ParseString(ConfigDefault, `null`)
-	should.Nil(iter.Read())
-	iter = ParseString(ConfigDefault, `navy`)
-	iter.Read()
-	should.True(iter.Error != nil && iter.Error != io.EOF)
-	iter = ParseString(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 := NewStream(ConfigDefault, buf, 4096)
-	stream.WriteNil()
-	stream.Flush()
-	should.Nil(stream.Error)
-	should.Equal("null", buf.String())
-}
-
-func Test_encode_null(t *testing.T) {
-	should := require.New(t)
-	str, err := MarshalToString(nil)
-	should.Nil(err)
-	should.Equal("null", str)
-}
-
-func Test_decode_null_object_field(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(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(UnmarshalFromString("[null]", &objs))
-	should.Len(objs, 1)
-}
-
-func Test_decode_null_array_element(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `[null,"a"]`)
-	should.True(iter.ReadArray())
-	should.True(iter.ReadNil())
-	should.True(iter.ReadArray())
-	should.Equal("a", iter.ReadString())
-}
-
-func Test_decode_null_array(t *testing.T) {
-	should := require.New(t)
-	arr := []string{}
-	should.Nil(UnmarshalFromString("null", &arr))
-	should.Nil(arr)
-}
-
-func Test_decode_null_map(t *testing.T) {
-	should := require.New(t)
-	arr := map[string]string{}
-	should.Nil(UnmarshalFromString("null", &arr))
-	should.Nil(arr)
-}
-
-func Test_decode_null_string(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(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 := ParseString(ConfigDefault, `[null,"a"]`)
-	iter.ReadArray()
-	iter.Skip()
-	iter.ReadArray()
-	if iter.ReadString() != "a" {
-		t.FailNow()
-	}
-}
-
-func Test_encode_nil_map(t *testing.T) {
-	should := require.New(t)
-	type Ttest map[string]string
-	var obj1 Ttest
-	output, err := json.Marshal(obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = json.Marshal(&obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = Marshal(obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = Marshal(&obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-}
-
-func Test_encode_nil_array(t *testing.T) {
-	should := require.New(t)
-	type Ttest []string
-	var obj1 Ttest
-	output, err := json.Marshal(obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = json.Marshal(&obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = Marshal(obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = Marshal(&obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-}
-
-func Test_decode_nil_num(t *testing.T) {
-	type TestData struct {
-		Field int `json:"field"`
-	}
-	should := require.New(t)
-
-	data1 := []byte(`{"field": 42}`)
-	data2 := []byte(`{"field": null}`)
-
-	// Checking stdlib behavior as well
-	obj2 := TestData{}
-	err := json.Unmarshal(data1, &obj2)
-	should.Equal(nil, err)
-	should.Equal(42, obj2.Field)
-
-	err = json.Unmarshal(data2, &obj2)
-	should.Equal(nil, err)
-	should.Equal(42, obj2.Field)
-
-	obj := TestData{}
-
-	err = Unmarshal(data1, &obj)
-	should.Equal(nil, err)
-	should.Equal(42, obj.Field)
-
-	err = Unmarshal(data2, &obj)
-	should.Equal(nil, err)
-	should.Equal(42, obj.Field)
-}

jsoniter_object_test.go

@@ -1,364 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func Test_empty_object(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `{}`)
-	field := iter.ReadObject()
-	should.Equal("", field)
-	iter = ParseString(ConfigDefault, `{}`)
-	iter.ReadObjectCB(func(iter *Iterator, field string) bool {
-		should.FailNow("should not call")
-		return true
-	})
-}
-
-func Test_one_field(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `{"a": "stream"}`)
-	field := iter.ReadObject()
-	should.Equal("a", field)
-	value := iter.ReadString()
-	should.Equal("stream", value)
-	field = iter.ReadObject()
-	should.Equal("", field)
-	iter = ParseString(ConfigDefault, `{"a": "stream"}`)
-	should.True(iter.ReadObjectCB(func(iter *Iterator, field string) bool {
-		should.Equal("a", field)
-		iter.Skip()
-		return true
-	}))
-
-}
-
-func Test_two_field(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(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 = ParseString(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_object_wrapper_any_get_all(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 []int
-		Field2 []int
-	}
-	any := 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)
-}
-
-func Test_write_object(t *testing.T) {
-	should := require.New(t)
-	buf := &bytes.Buffer{}
-	stream := NewStream(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_write_val_zero_field_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-	}
-	obj := TestObject{}
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{}`, str)
-}
-
-func Test_write_val_one_field_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string `json:"field-1"`
-	}
-	obj := TestObject{"hello"}
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"field-1":"hello"}`, str)
-}
-
-func Test_mixed(t *testing.T) {
-	should := require.New(t)
-	type AA struct {
-		ID      int                    `json:"id"`
-		Payload map[string]interface{} `json:"payload"`
-		buf     *bytes.Buffer
-	}
-	aa := AA{}
-	err := UnmarshalFromString(` {"id":1, "payload":{"account":"123","password":"456"}}`, &aa)
-	should.Nil(err)
-	should.Equal(1, aa.ID)
-	should.Equal("123", aa.Payload["account"])
-}
-
-func Test_omit_empty(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string `json:"field-1,omitempty"`
-		Field2 string `json:"field-2,omitempty"`
-		Field3 string `json:"field-3,omitempty"`
-	}
-	obj := TestObject{}
-	obj.Field2 = "hello"
-	str, err := MarshalToString(&obj)
-	should.Nil(err)
-	should.Equal(`{"field-2":"hello"}`, str)
-}
-
-func Test_ignore_field_on_not_valid_type(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string `json:"field-1,omitempty"`
-		Field2 func() `json:"-"`
-	}
-	obj := TestObject{}
-	obj.Field1 = "hello world"
-	obj.Field2 = func() {}
-	str, err := MarshalToString(&obj)
-	should.Nil(err)
-	should.Equal(`{"field-1":"hello world"}`, str)
-}
-
-func Test_nested_field_omit_empty(t *testing.T) {
-	should := require.New(t)
-	type S1 struct {
-		F1 string `json:",omitempty"`
-	}
-
-	type S2 struct {
-		*S1
-		F2 string `json:",omitempty"`
-	}
-	s1 := &S1{
-		//F1: "abc",
-	}
-	s2 := &S2{
-		S1: s1,
-		F2: "123",
-	}
-	str, err := MarshalToString(s2)
-	should.Nil(err)
-	should.Equal(`{"F2":"123"}`, str)
-}
-
-func Test_recursive_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Me     *TestObject
-	}
-	obj := TestObject{}
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Contains(str, `"Field1":""`)
-	should.Contains(str, `"Me":null`)
-	err = UnmarshalFromString(str, &obj)
-	should.Nil(err)
-}
-
-func Test_encode_anonymous_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field string
-	}
-	str, err := MarshalToString(struct {
-		TestObject
-		Field int
-	}{
-		Field: 100,
-	})
-	should.Nil(err)
-	should.Equal(`{"Field":100}`, str)
-}
-
-func Test_decode_anonymous_struct(t *testing.T) {
-	should := require.New(t)
-	type Inner struct {
-		Key string `json:"key"`
-	}
-
-	type Outer struct {
-		Inner
-	}
-	var outer Outer
-	j := []byte("{\"key\":\"value\"}")
-	should.Nil(Unmarshal(j, &outer))
-	should.Equal("value", outer.Key)
-}
-
-func Test_multiple_level_anonymous_struct(t *testing.T) {
-	type Level1 struct {
-		Field1 string
-	}
-	type Level2 struct {
-		Level1
-		Field2 string
-	}
-	type Level3 struct {
-		Level2
-		Field3 string
-	}
-	should := require.New(t)
-	obj := Level3{Level2{Level1{"1"}, "2"}, "3"}
-	output, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Field1":"1","Field2":"2","Field3":"3"}`, output)
-}
-
-func Test_multiple_level_anonymous_struct_with_ptr(t *testing.T) {
-	type Level1 struct {
-		Field1 string
-		Field2 string
-		Field4 string
-	}
-	type Level2 struct {
-		*Level1
-		Field2 string
-		Field3 string
-	}
-	type Level3 struct {
-		*Level2
-		Field3 string
-	}
-	should := require.New(t)
-	obj := Level3{&Level2{&Level1{"1", "", "4"}, "2", ""}, "3"}
-	output, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Contains(output, `"Field1":"1"`)
-	should.Contains(output, `"Field2":"2"`)
-	should.Contains(output, `"Field3":"3"`)
-	should.Contains(output, `"Field4":"4"`)
-}
-
-func Test_shadow_struct_field(t *testing.T) {
-	should := require.New(t)
-	type omit *struct{}
-	type CacheItem struct {
-		Key    string `json:"key"`
-		MaxAge int    `json:"cacheAge"`
-	}
-	output, err := MarshalToString(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,
-	})
-	should.Nil(err)
-	should.Contains(output, `"key":"value"`)
-	should.Contains(output, `"max_age":20`)
-}
-
-func Test_embedded_order(t *testing.T) {
-	type A struct {
-		Field2 string
-	}
-
-	type C struct {
-		Field5 string
-	}
-
-	type B struct {
-		Field4 string
-		C
-		Field6 string
-	}
-
-	type TestObject struct {
-		Field1 string
-		A
-		Field3 string
-		B
-		Field7 string
-	}
-	should := require.New(t)
-	s := TestObject{}
-	output, err := MarshalToString(s)
-	should.Nil(err)
-	should.Equal(`{"Field1":"","Field2":"","Field3":"","Field4":"","Field5":"","Field6":"","Field7":""}`, output)
-}
-
-func Test_decode_nested(t *testing.T) {
-	type StructOfString struct {
-		Field1 string
-		Field2 string
-	}
-	iter := ParseString(ConfigDefault, `[{"field1": "hello"}, null, {"field2": "world"}]`)
-	slice := []*StructOfString{}
-	iter.ReadVal(&slice)
-	if len(slice) != 3 {
-		fmt.Println(iter.Error)
-		t.Fatal(len(slice))
-	}
-	if slice[0].Field1 != "hello" {
-		fmt.Println(iter.Error)
-		t.Fatal(slice[0])
-	}
-	if slice[1] != nil {
-		fmt.Println(iter.Error)
-		t.Fatal(slice[1])
-	}
-	if slice[2].Field2 != "world" {
-		fmt.Println(iter.Error)
-		t.Fatal(slice[2])
-	}
-}
-
-func Test_decode_field_with_escape(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-	}
-	var obj TestObject
-	should.Nil(ConfigCompatibleWithStandardLibrary.Unmarshal([]byte(`{"Field\"1":"hello"}`), &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(ConfigCompatibleWithStandardLibrary.Unmarshal([]byte(`{"\u0046ield1":"hello"}`), &obj))
-	should.Equal("hello", obj.Field1)
-}

jsoniter_optional_test.go

@@ -1,46 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/stretchr/testify/require"
-	"testing"
-)
-
-func Test_encode_optional_int_pointer(t *testing.T) {
-	should := require.New(t)
-	var ptr *int
-	str, err := MarshalToString(ptr)
-	should.Nil(err)
-	should.Equal("null", str)
-	val := 100
-	ptr = &val
-	str, err = MarshalToString(ptr)
-	should.Nil(err)
-	should.Equal("100", str)
-}
-
-func Test_decode_struct_with_optional_field(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 *string
-		Field2 *string
-	}
-	obj := TestObject{}
-	UnmarshalFromString(`{"field1": null, "field2": "world"}`, &obj)
-	should.Nil(obj.Field1)
-	should.Equal("world", *obj.Field2)
-}
-
-func Test_encode_struct_with_optional_field(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 *string
-		Field2 *string
-	}
-	obj := TestObject{}
-	world := "world"
-	obj.Field2 = &world
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Contains(str, `"Field1":null`)
-	should.Contains(str, `"Field2":"world"`)
-}

jsoniter_reader_test.go

@@ -1,57 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/stretchr/testify/require"
-	"strings"
-	"testing"
-	"time"
-)
-
-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 := ConfigCompatibleWithStandardLibrary.NewDecoder(reader)
-	obj := TestObject{}
-	should.Nil(decoder.Decode(&obj))
-}

jsoniter_reflect_native_test.go

@@ -1,154 +0,0 @@
-package jsoniter
-
-import (
-	"fmt"
-	"testing"
-)
-
-func Test_reflect_str(t *testing.T) {
-	iter := ParseString(ConfigDefault, `"hello"`)
-	str := ""
-	iter.ReadVal(&str)
-	if str != "hello" {
-		fmt.Println(iter.Error)
-		t.Fatal(str)
-	}
-}
-
-func Test_reflect_ptr_str(t *testing.T) {
-	iter := ParseString(ConfigDefault, `"hello"`)
-	var str *string
-	iter.ReadVal(&str)
-	if *str != "hello" {
-		t.Fatal(str)
-	}
-}
-
-func Test_reflect_int(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := int(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_int8(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := int8(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_int16(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := int16(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_int32(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := int32(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_int64(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := int64(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_uint(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := uint(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_uint8(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := uint8(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_uint16(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := uint16(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_uint32(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := uint32(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_uint64(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := uint64(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_byte(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := byte(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_float32(t *testing.T) {
-	iter := ParseString(ConfigDefault, `1.23`)
-	val := float32(0)
-	iter.ReadVal(&val)
-	if val != 1.23 {
-		fmt.Println(iter.Error)
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_float64(t *testing.T) {
-	iter := ParseString(ConfigDefault, `1.23`)
-	val := float64(0)
-	iter.ReadVal(&val)
-	if val != 1.23 {
-		fmt.Println(iter.Error)
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_bool(t *testing.T) {
-	iter := ParseString(ConfigDefault, `true`)
-	val := false
-	iter.ReadVal(&val)
-	if val != true {
-		fmt.Println(iter.Error)
-		t.Fatal(val)
-	}
-}

jsoniter_string_test.go

@@ -1,261 +0,0 @@
-// +build go1.8
-
-package jsoniter
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"testing"
-	"unicode/utf8"
-
-	"github.com/stretchr/testify/require"
-)
-
-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", Unmarshal)
-		testReadString(t, input, "", true, "jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal", 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})},
-	}
-
-	for _, tc := range goodInputs {
-		testReadString(t, tc.input, tc.expectValue, false, "json.Unmarshal", json.Unmarshal)
-		testReadString(t, tc.input, tc.expectValue, false, "jsoniter.Unmarshal", Unmarshal)
-		testReadString(t, tc.input, tc.expectValue, false, "jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal", 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
-	}
-}
-
-func Test_read_normal_string(t *testing.T) {
-	cases := map[string]string{
-		`"0123456789012345678901234567890123456789"`: `0123456789012345678901234567890123456789`,
-		`""`:      ``,
-		`"hello"`: `hello`,
-	}
-	for input, output := range cases {
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := ParseString(ConfigDefault, input)
-			should.Equal(output, iter.ReadString())
-		})
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := Parse(ConfigDefault, bytes.NewBufferString(input), 2)
-			should.Equal(output, iter.ReadString())
-		})
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := ParseString(ConfigDefault, input)
-			should.Equal(output, string(iter.ReadStringAsSlice()))
-		})
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := Parse(ConfigDefault, bytes.NewBufferString(input), 2)
-			should.Equal(output, string(iter.ReadStringAsSlice()))
-		})
-	}
-}
-
-func Test_read_exotic_string(t *testing.T) {
-	cases := map[string]string{
-		`"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", // surrogate
-	}
-	for input, output := range cases {
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := ParseString(ConfigDefault, input)
-			var v string
-			should.Nil(json.Unmarshal([]byte(input), &v))
-			should.Equal(v, iter.ReadString())
-		})
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := Parse(ConfigDefault, bytes.NewBufferString(input), 2)
-			should.Equal(output, iter.ReadString())
-		})
-	}
-}
-
-func Test_read_string_as_interface(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `"hello"`)
-	should.Equal("hello", iter.Read())
-}
-
-func Test_write_string(t *testing.T) {
-	should := require.New(t)
-	str, err := MarshalToString("hello")
-	should.Equal(`"hello"`, str)
-	should.Nil(err)
-	str, err = MarshalToString(`hel"lo`)
-	should.Equal(`"hel\"lo"`, str)
-	should.Nil(err)
-}
-
-func Test_write_val_string(t *testing.T) {
-	should := require.New(t)
-	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigDefault, buf, 4096)
-	stream.WriteVal("hello")
-	stream.Flush()
-	should.Nil(stream.Error)
-	should.Equal(`"hello"`, buf.String())
-}
-
-func Test_decode_slash(t *testing.T) {
-	should := require.New(t)
-	var obj interface{}
-	should.NotNil(json.Unmarshal([]byte("\\"), &obj))
-	should.NotNil(UnmarshalFromString("\\", &obj))
-}
-
-func Test_html_escape(t *testing.T) {
-	should := require.New(t)
-	output, err := json.Marshal(`>`)
-	should.Nil(err)
-	should.Equal(`"\u003e"`, string(output))
-	output, err = ConfigCompatibleWithStandardLibrary.Marshal(`>`)
-	should.Nil(err)
-	should.Equal(`"\u003e"`, string(output))
-	type MyString string
-	output, err = ConfigCompatibleWithStandardLibrary.Marshal(MyString(`>`))
-	should.Nil(err)
-	should.Equal(`"\u003e"`, string(output))
-}
-
-func Test_string_encode_with_std(t *testing.T) {
-	should := require.New(t)
-	for i := 0; i < utf8.RuneSelf; i++ {
-		input := string([]byte{byte(i)})
-		stdOutputBytes, err := json.Marshal(input)
-		should.Nil(err)
-		stdOutput := string(stdOutputBytes)
-		jsoniterOutputBytes, err := ConfigCompatibleWithStandardLibrary.Marshal(input)
-		should.Nil(err)
-		jsoniterOutput := string(jsoniterOutputBytes)
-		should.Equal(stdOutput, jsoniterOutput)
-	}
-}
-
-func Test_unicode(t *testing.T) {
-	should := require.New(t)
-	output, _ := MarshalToString(map[string]interface{}{"a": "数字山谷"})
-	should.Equal(`{"a":"数字山谷"}`, output)
-	output, _ = Config{EscapeHTML: false}.Froze().MarshalToString(map[string]interface{}{"a": "数字山谷"})
-	should.Equal(`{"a":"数字山谷"}`, output)
-}
-
-func Test_unicode_and_escape(t *testing.T) {
-	should := require.New(t)
-	output, err := MarshalToString(`"数字山谷"`)
-	should.Nil(err)
-	should.Equal(`"\"数字山谷\""`, output)
-	output, err = ConfigFastest.MarshalToString(`"数字山谷"`)
-	should.Nil(err)
-	should.Equal(`"\"数字山谷\""`, output)
-}
-
-func Test_unsafe_unicode(t *testing.T) {
-	ConfigDefault.(*frozenConfig).cleanEncoders()
-	should := require.New(t)
-	output, err := ConfigDefault.MarshalToString("he\u2029\u2028he")
-	should.Nil(err)
-	should.Equal(`"he\u2029\u2028he"`, output)
-	output, err = ConfigFastest.MarshalToString("he\u2029\u2028he")
-	should.Nil(err)
-	should.Equal("\"he\u2029\u2028he\"", output)
-}
-
-func Benchmark_jsoniter_unicode(b *testing.B) {
-	for n := 0; n < b.N; n++ {
-		iter := ParseString(ConfigDefault, `"\ud83d\udc4a"`)
-		iter.ReadString()
-	}
-}
-
-func Benchmark_jsoniter_ascii(b *testing.B) {
-	iter := NewIterator(ConfigDefault)
-	input := []byte(`"hello, world! hello, world!"`)
-	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
-		iter.ResetBytes(input)
-		iter.ReadString()
-	}
-}
-
-func Benchmark_jsoniter_string_as_bytes(b *testing.B) {
-	iter := ParseString(ConfigDefault, `"hello, world!"`)
-	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
-		iter.ResetBytes(iter.buf)
-		iter.ReadStringAsSlice()
-	}
-}
-
-func Benchmark_json_unicode(b *testing.B) {
-	for n := 0; n < b.N; n++ {
-		result := ""
-		json.Unmarshal([]byte(`"\ud83d\udc4a"`), &result)
-	}
-}
-
-func Benchmark_json_ascii(b *testing.B) {
-	for n := 0; n < b.N; n++ {
-		result := ""
-		json.Unmarshal([]byte(`"hello"`), &result)
-	}
-}

jsoniter_struct_decoder_test.go

@@ -1,267 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/stretchr/testify/require"
-	"testing"
-)
-
-func Test_decode_one_field_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"field1": "hello"}`, &obj))
-	should.Equal("hello", obj.Field1)
-}
-
-func Test_decode_two_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("stream", obj.Field2)
-}
-
-func Test_decode_three_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-		Field3 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("stream", obj.Field2)
-	should.Equal("c", obj.Field3)
-}
-
-func Test_decode_four_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-		Field3 string
-		Field4 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("stream", obj.Field2)
-	should.Equal("c", obj.Field3)
-	should.Equal("d", obj.Field4)
-}
-
-func Test_decode_five_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-		Field3 string
-		Field4 string
-		Field5 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("stream", obj.Field2)
-	should.Equal("c", obj.Field3)
-	should.Equal("d", obj.Field4)
-	should.Equal("e", obj.Field5)
-}
-
-func Test_decode_six_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-		Field3 string
-		Field4 string
-		Field5 string
-		Field6 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("stream", obj.Field2)
-	should.Equal("c", obj.Field3)
-	should.Equal("d", obj.Field4)
-	should.Equal("e", obj.Field5)
-	should.Equal("x", obj.Field6)
-}
-
-func Test_decode_seven_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-		Field3 string
-		Field4 string
-		Field5 string
-		Field6 string
-		Field7 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x", "Field7":"y"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("stream", obj.Field2)
-	should.Equal("c", obj.Field3)
-	should.Equal("d", obj.Field4)
-	should.Equal("e", obj.Field5)
-	should.Equal("x", obj.Field6)
-	should.Equal("y", obj.Field7)
-}
-
-func Test_decode_eight_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-		Field3 string
-		Field4 string
-		Field5 string
-		Field6 string
-		Field7 string
-		Field8 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field8":"1", "Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field6": "x", "Field7":"y"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("stream", obj.Field2)
-	should.Equal("c", obj.Field3)
-	should.Equal("d", obj.Field4)
-	should.Equal("e", obj.Field5)
-	should.Equal("x", obj.Field6)
-	should.Equal("y", obj.Field7)
-	should.Equal("1", obj.Field8)
-}
-
-func Test_decode_nine_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-		Field3 string
-		Field4 string
-		Field5 string
-		Field6 string
-		Field7 string
-		Field8 string
-		Field9 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field8" : "zzzzzzzzzzz", "Field7": "zz", "Field6" : "xx", "Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e", "Field9":"f"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("stream", obj.Field2)
-	should.Equal("c", obj.Field3)
-	should.Equal("d", obj.Field4)
-	should.Equal("e", obj.Field5)
-	should.Equal("xx", obj.Field6)
-	should.Equal("zz", obj.Field7)
-	should.Equal("zzzzzzzzzzz", obj.Field8)
-	should.Equal("f", obj.Field9)
-}
-
-func Test_decode_ten_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1  string
-		Field2  string
-		Field3  string
-		Field4  string
-		Field5  string
-		Field6  string
-		Field7  string
-		Field8  string
-		Field9  string
-		Field10 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field10":"x", "Field9": "x", "Field8":"x", "Field7":"x", "Field6":"x", "Field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("stream", obj.Field2)
-	should.Equal("c", obj.Field3)
-	should.Equal("d", obj.Field4)
-	should.Equal("e", obj.Field5)
-	should.Equal("x", obj.Field6)
-	should.Equal("x", obj.Field7)
-	should.Equal("x", obj.Field8)
-	should.Equal("x", obj.Field9)
-	should.Equal("x", obj.Field10)
-}
-
-func Test_decode_more_than_ten_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1  string
-		Field2  string
-		Field3  string
-		Field4  string
-		Field5  string
-		Field6  string
-		Field7  string
-		Field8  string
-		Field9  string
-		Field10 string
-		Field11 int
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"field11":1, "field1": "a", "Field2": "stream", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("stream", obj.Field2)
-	should.Equal("c", obj.Field3)
-	should.Equal("d", obj.Field4)
-	should.Equal("e", obj.Field5)
-	should.Equal(1, obj.Field11)
-}
-
-func Test_decode_struct_field_with_tag(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string `json:"field-1"`
-		Field2 string `json:"-"`
-		Field3 int    `json:",string"`
-	}
-	obj := TestObject{Field2: "world"}
-	UnmarshalFromString(`{"field-1": "hello", "field2": "", "Field3": "100"}`, &obj)
-	should.Equal("hello", obj.Field1)
-	should.Equal("world", obj.Field2)
-	should.Equal(100, obj.Field3)
-}
-
-func Test_decode_struct_field_with_tag_string(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 int `json:",string"`
-	}
-	obj := TestObject{Field1: 100}
-	should.Nil(UnmarshalFromString(`{"Field1": "100"}`, &obj))
-	should.Equal(100, obj.Field1)
-}

jsoniter_struct_encoder_test.go

@@ -1,52 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-)
-
-func Test_encode_unexported_field(t *testing.T) {
-	type TestData struct {
-		a int
-		b <-chan int
-		C int
-		d *time.Timer
-	}
-
-	should := require.New(t)
-
-	testChan := make(<-chan int, 10)
-	testTimer := time.NewTimer(10 * time.Second)
-
-	obj := &TestData{
-		a: 42,
-		b: testChan,
-		C: 21,
-		d: testTimer,
-	}
-
-	jb, err := json.Marshal(obj)
-	should.NoError(err)
-	should.Equal([]byte(`{"C":21}`), jb)
-
-	err = json.Unmarshal([]byte(`{"a": 444, "b":"bad", "C":55, "d":{"not": "a timer"}}`), obj)
-	should.NoError(err)
-	should.Equal(42, obj.a)
-	should.Equal(testChan, obj.b)
-	should.Equal(55, obj.C)
-	should.Equal(testTimer, obj.d)
-
-	jb, err = Marshal(obj)
-	should.NoError(err)
-	should.Equal(jb, []byte(`{"C":55}`))
-
-	err = Unmarshal([]byte(`{"a": 444, "b":"bad", "C":256, "d":{"not":"a timer"}}`), obj)
-	should.NoError(err)
-	should.Equal(42, obj.a)
-	should.Equal(testChan, obj.b)
-	should.Equal(256, obj.C)
-	should.Equal(testTimer, obj.d)
-}

misc_tests/jsoniter_array_test.go

@@ -1,19 +1,20 @@
-package jsoniter
+package misc_tests
 
 import (
 	"bytes"
 	"encoding/json"
 	"github.com/stretchr/testify/require"
 	"testing"
+	"github.com/json-iterator/go"
 )
 
 func Test_empty_array(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigDefault, `[]`)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[]`)
 	cont := iter.ReadArray()
 	should.False(cont)
-	iter = ParseString(ConfigDefault, `[]`)
-	iter.ReadArrayCB(func(iter *Iterator) bool {
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `[]`)
+	iter.ReadArrayCB(func(iter *jsoniter.Iterator) bool {
 		should.FailNow("should not call")
 		return true
 	})
@@ -21,12 +22,12 @@ func Test_empty_array(t *testing.T) {
 
 func Test_one_element(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigDefault, `[1]`)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[1]`)
 	should.True(iter.ReadArray())
 	should.Equal(1, iter.ReadInt())
 	should.False(iter.ReadArray())
-	iter = ParseString(ConfigDefault, `[1]`)
-	iter.ReadArrayCB(func(iter *Iterator) bool {
+	iter = jsoniter.ParseString(jsoniter.ConfigDefault, `[1]`)
+	iter.ReadArrayCB(func(iter *jsoniter.Iterator) bool {
 		should.Equal(1, iter.ReadInt())
 		return true
 	})
@@ -34,18 +35,18 @@ func Test_one_element(t *testing.T) {
 
 func Test_two_elements(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigDefault, `[1,2]`)
+	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 = ParseString(ConfigDefault, `[1,2]`)
+	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 := ParseString(ConfigDefault, ` [1]`)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, ` [1]`)
 	cont := iter.ReadArray()
 	if cont != true {
 		t.FailNow()
@@ -56,7 +57,7 @@ func Test_whitespace_in_head(t *testing.T) {
 }
 
 func Test_whitespace_after_array_start(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[ 1]`)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[ 1]`)
 	cont := iter.ReadArray()
 	if cont != true {
 		t.FailNow()
@@ -67,7 +68,7 @@ func Test_whitespace_after_array_start(t *testing.T) {
 }
 
 func Test_whitespace_before_array_end(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[1 ]`)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[1 ]`)
 	cont := iter.ReadArray()
 	if cont != true {
 		t.FailNow()
@@ -82,7 +83,7 @@ func Test_whitespace_before_array_end(t *testing.T) {
 }
 
 func Test_whitespace_before_comma(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[1 ,2]`)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `[1 ,2]`)
 	cont := iter.ReadArray()
 	if cont != true {
 		t.FailNow()
@@ -106,7 +107,7 @@ func Test_whitespace_before_comma(t *testing.T) {
 func Test_write_array(t *testing.T) {
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(Config{IndentionStep: 2}.Froze(), buf, 4096)
+	stream := jsoniter.NewStream(jsoniter.Config{IndentionStep: 2}.Froze(), buf, 4096)
 	stream.WriteArrayStart()
 	stream.WriteInt(1)
 	stream.WriteMore()
@@ -120,7 +121,7 @@ func Test_write_array(t *testing.T) {
 func Test_write_val_array(t *testing.T) {
 	should := require.New(t)
 	val := []int{1, 2, 3}
-	str, err := MarshalToString(&val)
+	str, err := jsoniter.MarshalToString(&val)
 	should.Nil(err)
 	should.Equal("[1,2,3]", str)
 }
@@ -128,7 +129,7 @@ func Test_write_val_array(t *testing.T) {
 func Test_write_val_empty_array(t *testing.T) {
 	should := require.New(t)
 	val := []int{}
-	str, err := MarshalToString(val)
+	str, err := jsoniter.MarshalToString(val)
 	should.Nil(err)
 	should.Equal("[]", str)
 }
@@ -140,7 +141,7 @@ func Test_write_array_of_interface_in_struct(t *testing.T) {
 		Field2 string
 	}
 	val := TestObject{[]interface{}{1, 2}, ""}
-	str, err := MarshalToString(val)
+	str, err := jsoniter.MarshalToString(val)
 	should.Nil(err)
 	should.Contains(str, `"Field":[1,2]`)
 	should.Contains(str, `"Field2":""`)
@@ -151,7 +152,7 @@ func Test_encode_byte_array(t *testing.T) {
 	bytes, err := json.Marshal([]byte{1, 2, 3})
 	should.Nil(err)
 	should.Equal(`"AQID"`, string(bytes))
-	bytes, err = Marshal([]byte{1, 2, 3})
+	bytes, err = jsoniter.Marshal([]byte{1, 2, 3})
 	should.Nil(err)
 	should.Equal(`"AQID"`, string(bytes))
 }
@@ -162,7 +163,7 @@ func Test_decode_byte_array_from_base64(t *testing.T) {
 	err := json.Unmarshal([]byte(`"AQID"`), &data)
 	should.Nil(err)
 	should.Equal([]byte{1, 2, 3}, data)
-	err = Unmarshal([]byte(`"AQID"`), &data)
+	err = jsoniter.Unmarshal([]byte(`"AQID"`), &data)
 	should.Nil(err)
 	should.Equal([]byte{1, 2, 3}, data)
 }
@@ -173,7 +174,7 @@ func Test_decode_byte_array_from_array(t *testing.T) {
 	err := json.Unmarshal([]byte(`[1,2,3]`), &data)
 	should.Nil(err)
 	should.Equal([]byte{1, 2, 3}, data)
-	err = Unmarshal([]byte(`[1,2,3]`), &data)
+	err = jsoniter.Unmarshal([]byte(`[1,2,3]`), &data)
 	should.Nil(err)
 	should.Equal([]byte{1, 2, 3}, data)
 }
@@ -181,21 +182,21 @@ func Test_decode_byte_array_from_array(t *testing.T) {
 func Test_decode_slice(t *testing.T) {
 	should := require.New(t)
 	slice := make([]string, 0, 5)
-	UnmarshalFromString(`["hello", "world"]`, &slice)
+	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)
-	UnmarshalFromString(`[1,2,3,4,5,6,7,8,9]`, &slice)
+	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 := ParseBytes(ConfigDefault, input)
+	iter := jsoniter.ParseBytes(jsoniter.ConfigDefault, input)
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		iter.ResetBytes(input)

misc_tests/jsoniter_bool_test.go

@@ -0,0 +1,47 @@
+package misc_tests
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+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())
+}

misc_tests/jsoniter_float_test.go

@@ -0,0 +1,95 @@
+package misc_tests
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+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.Nil(jsoniter.UnmarshalFromString(`1e1`, &obj))
+	should.Equal(float64(10), obj)
+	should.Nil(json.Unmarshal([]byte(`1e1`), &obj))
+	should.Equal(float64(10), obj)
+	should.Nil(jsoniter.UnmarshalFromString(`1.0e1`, &obj))
+	should.Equal(float64(10), obj)
+	should.Nil(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)
+	}
+}

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/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+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)
+	}
+}

misc_tests/jsoniter_interface_test.go

@@ -0,0 +1,224 @@
+package misc_tests
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+type MyInterface interface {
+	Hello() string
+}
+
+type MyString string
+
+func (ms MyString) Hello() string {
+	return string(ms)
+}
+
+func Test_decode_object_contain_non_empty_interface(t *testing.T) {
+	type TestObject struct {
+		Field MyInterface
+	}
+	should := require.New(t)
+	obj := TestObject{}
+	obj.Field = MyString("abc")
+	should.Nil(jsoniter.UnmarshalFromString(`{"Field": "hello"}`, &obj))
+	should.Equal(MyString("hello"), obj.Field)
+}
+
+func Test_nil_non_empty_interface(t *testing.T) {
+	type TestObject struct {
+		Field []MyInterface
+	}
+	should := require.New(t)
+	obj := TestObject{}
+	b := []byte(`{"Field":["AAA"]}`)
+	should.NotNil(json.Unmarshal(b, &obj))
+	should.NotNil(jsoniter.Unmarshal(b, &obj))
+}
+
+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)
+}
+
+func Test_unmarshal_ptr_to_interface(t *testing.T) {
+	type TestData struct {
+		Name string `json:"name"`
+	}
+	should := require.New(t)
+	var obj interface{} = &TestData{}
+	err := json.Unmarshal([]byte(`{"name":"value"}`), &obj)
+	should.Nil(err)
+	should.Equal("&{value}", fmt.Sprintf("%v", obj))
+	obj = interface{}(&TestData{})
+	err = jsoniter.Unmarshal([]byte(`{"name":"value"}`), &obj)
+	should.Nil(err)
+	should.Equal("&{value}", fmt.Sprintf("%v", 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.Equal(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.Equal(nil, err)
+	should.Equal(&payload, wrapper.Payload)
+	should.Equal(42, (*(wrapper.Payload.(**Payload))).Value)
+
+	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.Equal(nil, 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.Equal(nil, 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.Equal(nil, err)
+	should.Equal(42, (*(wrapper.Payload.(*Payload))).Value)
+
+	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.Equal(nil, 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.Nil(err)
+	should.NotNil(wrapper.Payload)
+	should.Nil(payload)
+
+	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.Nil(err)
+	should.Nil(wrapper.Payload)
+	should.Nil(payload)
+
+	payload = nil
+	wrapper = &Wrapper{
+		Payload: payload,
+	}
+
+	err = jsoniter.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.Nil(err)
+	should.NotNil(wrapper.Payload)
+	should.Nil(payload)
+
+	err = jsoniter.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.Nil(err)
+	should.Nil(wrapper.Payload)
+	should.Nil(payload)
+}

misc_tests/jsoniter_map_test.go

@@ -0,0 +1,33 @@
+package misc_tests
+
+import (
+	"encoding/json"
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"strings"
+	"github.com/json-iterator/go"
+)
+
+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"])
+}

misc_tests/jsoniter_nested_test.go

@@ -1,9 +1,10 @@
-package jsoniter
+package misc_tests
 
 import (
 	"encoding/json"
 	"reflect"
 	"testing"
+	"github.com/json-iterator/go"
 )
 
 type Level1 struct {
@@ -15,7 +16,7 @@ type Level2 struct {
 }
 
 func Test_nested(t *testing.T) {
-	iter := ParseString(ConfigDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
+	iter := jsoniter.ParseString(jsoniter.ConfigDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
 	l1 := Level1{}
 	for l1Field := iter.ReadObject(); l1Field != ""; l1Field = iter.ReadObject() {
 		switch l1Field {
@@ -50,7 +51,7 @@ func Test_nested(t *testing.T) {
 
 func Benchmark_jsoniter_nested(b *testing.B) {
 	for n := 0; n < b.N; n++ {
-		iter := ParseString(ConfigDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
+		iter := jsoniter.ParseString(jsoniter.ConfigDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
 		l1 := Level1{}
 		for l1Field := iter.ReadObject(); l1Field != ""; l1Field = iter.ReadObject() {
 			switch l1Field {
@@ -63,7 +64,7 @@ func Benchmark_jsoniter_nested(b *testing.B) {
 	}
 }
 
-func readLevel1Hello(iter *Iterator) []Level2 {
+func readLevel1Hello(iter *jsoniter.Iterator) []Level2 {
 	l2Array := make([]Level2, 0, 2)
 	for iter.ReadArray() {
 		l2 := Level2{}

misc_tests/jsoniter_null_test.go

@@ -0,0 +1,81 @@
+package misc_tests
+
+import (
+	"bytes"
+	"io"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+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()
+	}
+}

misc_tests/jsoniter_object_test.go

@@ -0,0 +1,132 @@
+package misc_tests
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+	"time"
+	"strings"
+)
+
+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))
+}

misc_tests/jsoniter_raw_message_test.go

@@ -1,75 +1,29 @@
-package jsoniter
+package misc_tests
 
 import (
 	"encoding/json"
 	"github.com/stretchr/testify/require"
 	"strings"
 	"testing"
+	"github.com/json-iterator/go"
 )
 
-func Test_json_RawMessage(t *testing.T) {
-	should := require.New(t)
-	var data json.RawMessage
-	should.Nil(Unmarshal([]byte(`[1,2,3]`), &data))
-	should.Equal(`[1,2,3]`, string(data))
-	str, err := MarshalToString(data)
-	should.Nil(err)
-	should.Equal(`[1,2,3]`, str)
-}
-
 func Test_jsoniter_RawMessage(t *testing.T) {
 	should := require.New(t)
-	var data RawMessage
-	should.Nil(Unmarshal([]byte(`[1,2,3]`), &data))
+	var data jsoniter.RawMessage
+	should.Nil(jsoniter.Unmarshal([]byte(`[1,2,3]`), &data))
 	should.Equal(`[1,2,3]`, string(data))
-	str, err := MarshalToString(data)
+	str, err := jsoniter.MarshalToString(data)
 	should.Nil(err)
 	should.Equal(`[1,2,3]`, str)
 }
 
-func Test_json_RawMessage_in_struct(t *testing.T) {
-	type TestObject struct {
-		Field1 string
-		Field2 json.RawMessage
-	}
-	should := require.New(t)
-	var data TestObject
-	should.Nil(Unmarshal([]byte(`{"field1": "hello", "field2": [1,2,3]}`), &data))
-	should.Equal(` [1,2,3]`, string(data.Field2))
-	should.Equal(`hello`, data.Field1)
-}
-
-func Test_decode_map_of_raw_message(t *testing.T) {
-	should := require.New(t)
-	type RawMap map[string]*json.RawMessage
-	b := []byte("{\"test\":[{\"key\":\"value\"}]}")
-	var rawMap RawMap
-	should.Nil(Unmarshal(b, &rawMap))
-	should.Equal(`[{"key":"value"}]`, string(*rawMap["test"]))
-	type Inner struct {
-		Key string `json:"key"`
-	}
-	var inner []Inner
-	Unmarshal(*rawMap["test"], &inner)
-	should.Equal("value", inner[0].Key)
-}
-
-func Test_encode_map_of_raw_message(t *testing.T) {
-	should := require.New(t)
-	type RawMap map[string]*json.RawMessage
-	value := json.RawMessage("[]")
-	rawMap := RawMap{"hello": &value}
-	output, err := MarshalToString(rawMap)
-	should.Nil(err)
-	should.Equal(`{"hello":[]}`, output)
-}
-
 func Test_encode_map_of_jsoniter_raw_message(t *testing.T) {
 	should := require.New(t)
-	type RawMap map[string]*RawMessage
-	value := RawMessage("[]")
+	type RawMap map[string]*jsoniter.RawMessage
+	value := jsoniter.RawMessage("[]")
 	rawMap := RawMap{"hello": &value}
-	output, err := MarshalToString(rawMap)
+	output, err := jsoniter.MarshalToString(rawMap)
 	should.Nil(err)
 	should.Equal(`{"hello":[]}`, output)
 }
@@ -82,8 +36,8 @@ func Test_marshal_invalid_json_raw_message(t *testing.T) {
 
 	a := A{}
 	should := require.New(t)
-	should.Nil(ConfigCompatibleWithStandardLibrary.Unmarshal(message, &a))
-	aout, aouterr := ConfigCompatibleWithStandardLibrary.Marshal(&a)
+	should.Nil(jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(message, &a))
+	aout, aouterr := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(&a)
 	should.Equal(`{"raw":null}`, string(aout))
 	should.Nil(aouterr)
 }
@@ -99,14 +53,14 @@ func Test_raw_message_memory_not_copied_issue(t *testing.T) {
 		BiddingMax  *float32    `json:"bidding_max"`
 		BiddingMin  *float32    `json:"bidding_min"`
 		BiddingType *string     `json:"bidding_type"`
-		Freq        *RawMessage `json:"freq"`
-		Targeting   *RawMessage `json:"targeting"`
-		Url         *RawMessage `json:"url"`
+		Freq        *jsoniter.RawMessage `json:"freq"`
+		Targeting   *jsoniter.RawMessage `json:"targeting"`
+		Url         *jsoniter.RawMessage `json:"url"`
 		Speed       *int        `json:"speed" db:"speed"`
 	}
 
 	obj := &IteratorObject{}
-	decoder := NewDecoder(strings.NewReader(jsonStream))
+	decoder := jsoniter.NewDecoder(strings.NewReader(jsonStream))
 	err := decoder.Decode(obj)
 	should := require.New(t)
 	should.Nil(err)

output_tests/array/array/bool/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/array/bool/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4][4]bool

output_tests/array/array/byte/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/array/byte/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4][4]byte

output_tests/array/array/float64/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/array/float64/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4][4]float64

output_tests/array/array/int32/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/array/int32/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4][4]int32

output_tests/array/array/ptr_string/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/array/ptr_string/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4][4]*string

output_tests/array/array/string/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/array/string/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4][4]string

output_tests/array/array/uint8/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/array/uint8/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4][4]uint8

output_tests/array/bool/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/bool/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4]bool

output_tests/array/byte/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/byte/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4]byte

output_tests/array/float64/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/float64/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4]float64

output_tests/array/int32/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/int32/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4]int32

output_tests/array/map/int32_string/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/map/int32_string/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4]map[int32]string

output_tests/array/map/string_string/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/map/string_string/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4]map[string]string

output_tests/array/ptr_bool/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/ptr_bool/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4]*bool

output_tests/array/ptr_float64/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/ptr_float64/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4]*float64

output_tests/array/ptr_int32/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}

output_tests/array/ptr_int32/types.go

@@ -1,3 +0,0 @@
-package test
-
-type typeForTest [4]*int32

output_tests/array/ptr_map/int32_string/json_test.go

@@ -1,152 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 100; i++ {
-		var before typeForTest
-		fz.Fuzz(&before)
-
-		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))
-		}
-
-		var afterStd typeForTest
-		err = json.Unmarshal(jbIter, &afterStd)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		var afterIter typeForTest
-		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
-		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
-				err, indent(jbIter, "    "))
-		}
-		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()
-}
-
-func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var obj typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&obj)
-	for i := 0; i < t.N; i++ {
-		jb, err := fn(obj)
-		if err != nil {
-			t.Fatalf("%s failed to marshal:\n input: %s\n  error: %v", name, dump(obj), err)
-		}
-		_ = jb
-	}
-}
-
-func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
-	t.ReportAllocs()
-	t.ResetTimer()
-
-	var before typeForTest
-	fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
-	fz.Fuzz(&before)
-	jb, err := json.Marshal(before)
-	if err != nil {
-		t.Fatalf("failed to marshal: %v", err)
-	}
-
-	for i := 0; i < t.N; i++ {
-		var after typeForTest
-		err = fn(jb, &after)
-		if err != nil {
-			t.Fatalf("%s failed to unmarshal:\n  input: %q\n  error: %v", name, string(jb), err)
-		}
-	}
-}
-
-func BenchmarkStandardMarshal(t *testing.B) {
-	benchmarkMarshal(t, "stdlib", json.Marshal)
-}
-
-func BenchmarkStandardUnmarshal(t *testing.B) {
-	benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalFastest(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalDefault(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
-}
-
-func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
-	benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
-}
-
-func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
-	benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
-}