#59 add ConfigFastest

feature_adapter.go

@@ -23,12 +23,12 @@ import (
 // Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v.
 // Refer to https://godoc.org/encoding/json#Unmarshal for more information
 func Unmarshal(data []byte, v interface{}) error {
-	return ConfigOfDefault.Unmarshal(data, v)
+	return ConfigDefault.Unmarshal(data, v)
 }
 
 // UnmarshalAny adapts to
 func UnmarshalAny(data []byte) (Any, error) {
-	return ConfigOfDefault.UnmarshalAny(data)
+	return ConfigDefault.UnmarshalAny(data)
 }
 
 func lastNotSpacePos(data []byte) int {
@@ -41,11 +41,11 @@ func lastNotSpacePos(data []byte) int {
 }
 
 func UnmarshalFromString(str string, v interface{}) error {
-	return ConfigOfDefault.UnmarshalFromString(str, v)
+	return ConfigDefault.UnmarshalFromString(str, v)
 }
 
 func UnmarshalAnyFromString(str string) (Any, error) {
-	return ConfigOfDefault.UnmarshalAnyFromString(str)
+	return ConfigDefault.UnmarshalAnyFromString(str)
 }
 
 // Marshal adapts to json/encoding Marshal API
@@ -53,11 +53,11 @@ func UnmarshalAnyFromString(str string) (Any, error) {
 // Marshal returns the JSON encoding of v, adapts to json/encoding Marshal API
 // Refer to https://godoc.org/encoding/json#Marshal for more information
 func Marshal(v interface{}) ([]byte, error) {
-	return ConfigOfDefault.Marshal(v)
+	return ConfigDefault.Marshal(v)
 }
 
 func MarshalToString(v interface{}) (string, error) {
-	return ConfigOfDefault.MarshalToString(v)
+	return ConfigDefault.MarshalToString(v)
 }
 
 // NewDecoder adapts to json/stream NewDecoder API.
@@ -67,7 +67,7 @@ func MarshalToString(v interface{}) (string, error) {
 // Instead of a json/encoding Decoder, an AdaptedDecoder is returned
 // Refer to https://godoc.org/encoding/json#NewDecoder for more information
 func NewDecoder(reader io.Reader) *AdaptedDecoder {
-	return ConfigOfDefault.NewDecoder(reader)
+	return ConfigDefault.NewDecoder(reader)
 }
 
 // AdaptedDecoder reads and decodes JSON values from an input stream.
@@ -105,7 +105,7 @@ func (decoder *AdaptedDecoder) UseNumber() {
 }
 
 func NewEncoder(writer io.Writer) *AdaptedEncoder {
-	return ConfigOfDefault.NewEncoder(writer)
+	return ConfigDefault.NewEncoder(writer)
 }
 
 type AdaptedEncoder struct {

feature_any_array.go

@@ -22,7 +22,7 @@ func (any *arrayLazyAny) ValueType() ValueType {
 func (any *arrayLazyAny) Parse() *Iterator {
 	iter := any.iter
 	if iter == nil {
-		iter = NewIterator(ConfigOfDefault)
+		iter = NewIterator(ConfigDefault)
 		any.iter = iter
 	}
 	iter.ResetBytes(any.remaining)
@@ -287,7 +287,7 @@ func (any *arrayLazyAny) IterateArray() (func() (Any, bool), bool) {
 			// read from buffer
 			iter := any.iter
 			if iter == nil {
-				iter = NewIterator(ConfigOfDefault)
+				iter = NewIterator(ConfigDefault)
 				any.iter = iter
 			}
 			iter.ResetBytes(remaining)

feature_any_float.go

@@ -17,7 +17,7 @@ type float64LazyAny struct {
 func (any *float64LazyAny) Parse() *Iterator {
 	iter := any.iter
 	if iter == nil {
-		iter = NewIterator(ConfigOfDefault)
+		iter = NewIterator(ConfigDefault)
 	}
 	iter.ResetBytes(any.buf)
 	return iter

feature_any_int64.go

@@ -21,7 +21,7 @@ func (any *int64LazyAny) ValueType() ValueType {
 func (any *int64LazyAny) Parse() *Iterator {
 	iter := any.iter
 	if iter == nil {
-		iter = NewIterator(ConfigOfDefault)
+		iter = NewIterator(ConfigDefault)
 	}
 	iter.ResetBytes(any.buf)
 	return iter

feature_any_object.go

@@ -22,7 +22,7 @@ func (any *objectLazyAny) ValueType() ValueType {
 func (any *objectLazyAny) Parse() *Iterator {
 	iter := any.iter
 	if iter == nil {
-		iter = NewIterator(ConfigOfDefault)
+		iter = NewIterator(ConfigDefault)
 		any.iter = iter
 	}
 	iter.ResetBytes(any.remaining)
@@ -308,7 +308,7 @@ func (any *objectLazyAny) IterateObject() (func() (string, Any, bool), bool) {
 			// read from buffer
 			iter := any.iter
 			if iter == nil {
-				iter = NewIterator(ConfigOfDefault)
+				iter = NewIterator(ConfigDefault)
 				any.iter = iter
 			}
 			iter.ResetBytes(remaining)

feature_any_string.go

@@ -20,7 +20,7 @@ func (any *stringLazyAny) ValueType() ValueType {
 func (any *stringLazyAny) Parse() *Iterator {
 	iter := any.iter
 	if iter == nil {
-		iter = NewIterator(ConfigOfDefault)
+		iter = NewIterator(ConfigDefault)
 		any.iter = iter
 	}
 	iter.ResetBytes(any.buf)

feature_any_uint64.go

@@ -21,7 +21,7 @@ func (any *uint64LazyAny) ValueType() ValueType {
 func (any *uint64LazyAny) Parse() *Iterator {
 	iter := any.iter
 	if iter == nil {
-		iter = NewIterator(ConfigOfDefault)
+		iter = NewIterator(ConfigDefault)
 	}
 	iter.ResetBytes(any.buf)
 	return iter

feature_config.go

@@ -25,7 +25,7 @@ type frozenConfig struct {
 	extensions         []ExtensionFunc
 }
 
-var ConfigOfDefault = Config{}.Froze()
+var ConfigDefault = Config{}.Froze()
 
 // Trying to be 100% compatible with standard library behavior
 var ConfigCompatibleWithStandardLibrary = Config{
@@ -33,9 +33,13 @@ var ConfigCompatibleWithStandardLibrary = Config{
 	SortMapKeys: true,
 }.Froze()
 
+var ConfigFastest = Config{
+	MarshalFloatWith6Digits: true,
+}.Froze()
+
 func (cfg Config) Froze() *frozenConfig {
 	frozenConfig := &frozenConfig{
-		sortMapKeys: cfg.SortMapKeys,
+		sortMapKeys:   cfg.SortMapKeys,
 		indentionStep: cfg.IndentionStep,
 	}
 	atomic.StorePointer(&frozenConfig.decoderCache, unsafe.Pointer(&map[string]Decoder{}))

jsoniter_array_test.go

@@ -10,10 +10,10 @@ import (
 
 func Test_empty_array(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `[]`)
+	iter := ParseString(ConfigDefault, `[]`)
 	cont := iter.ReadArray()
 	should.False(cont)
-	iter = ParseString(ConfigOfDefault, `[]`)
+	iter = ParseString(ConfigDefault, `[]`)
 	iter.ReadArrayCB(func(iter *Iterator) bool {
 		should.FailNow("should not call")
 		return true
@@ -22,11 +22,11 @@ func Test_empty_array(t *testing.T) {
 
 func Test_one_element(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `[1]`)
+	iter := ParseString(ConfigDefault, `[1]`)
 	should.True(iter.ReadArray())
 	should.Equal(1, iter.ReadInt())
 	should.False(iter.ReadArray())
-	iter = ParseString(ConfigOfDefault, `[1]`)
+	iter = ParseString(ConfigDefault, `[1]`)
 	iter.ReadArrayCB(func(iter *Iterator) bool {
 		should.Equal(1, iter.ReadInt())
 		return true
@@ -35,13 +35,13 @@ func Test_one_element(t *testing.T) {
 
 func Test_two_elements(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `[1,2]`)
+	iter := ParseString(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(ConfigOfDefault, `[1,2]`)
+	iter = ParseString(ConfigDefault, `[1,2]`)
 	should.Equal([]interface{}{float64(1), float64(2)}, iter.Read())
 }
 
@@ -152,7 +152,7 @@ func Test_invalid_array(t *testing.T) {
 }
 
 func Test_whitespace_in_head(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, ` [1]`)
+	iter := ParseString(ConfigDefault, ` [1]`)
 	cont := iter.ReadArray()
 	if cont != true {
 		t.FailNow()
@@ -163,7 +163,7 @@ func Test_whitespace_in_head(t *testing.T) {
 }
 
 func Test_whitespace_after_array_start(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[ 1]`)
+	iter := ParseString(ConfigDefault, `[ 1]`)
 	cont := iter.ReadArray()
 	if cont != true {
 		t.FailNow()
@@ -174,7 +174,7 @@ func Test_whitespace_after_array_start(t *testing.T) {
 }
 
 func Test_whitespace_before_array_end(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[1 ]`)
+	iter := ParseString(ConfigDefault, `[1 ]`)
 	cont := iter.ReadArray()
 	if cont != true {
 		t.FailNow()
@@ -189,7 +189,7 @@ func Test_whitespace_before_array_end(t *testing.T) {
 }
 
 func Test_whitespace_before_comma(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[1 ,2]`)
+	iter := ParseString(ConfigDefault, `[1 ,2]`)
 	cont := iter.ReadArray()
 	if cont != true {
 		t.FailNow()
@@ -287,7 +287,7 @@ func Test_decode_byte_array(t *testing.T) {
 func Benchmark_jsoniter_array(b *testing.B) {
 	b.ReportAllocs()
 	input := []byte(`[1,2,3,4,5,6,7,8,9]`)
-	iter := ParseBytes(ConfigOfDefault, input)
+	iter := ParseBytes(ConfigDefault, input)
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		iter.ResetBytes(input)

jsoniter_bool_test.go

@@ -8,15 +8,15 @@ import (
 
 func Test_true(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `true`)
+	iter := ParseString(ConfigDefault, `true`)
 	should.True(iter.ReadBool())
-	iter = ParseString(ConfigOfDefault, `true`)
+	iter = ParseString(ConfigDefault, `true`)
 	should.Equal(true, iter.Read())
 }
 
 func Test_false(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `false`)
+	iter := ParseString(ConfigDefault, `false`)
 	should.False(iter.ReadBool())
 }
 
@@ -30,7 +30,7 @@ func Test_read_bool_as_any(t *testing.T) {
 func Test_write_true_false(t *testing.T) {
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 4096)
+	stream := NewStream(ConfigDefault, buf, 4096)
 	stream.WriteTrue()
 	stream.WriteFalse()
 	stream.Flush()
@@ -41,7 +41,7 @@ func Test_write_true_false(t *testing.T) {
 func Test_write_val_bool(t *testing.T) {
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 4096)
+	stream := NewStream(ConfigDefault, buf, 4096)
 	stream.WriteVal(true)
 	stream.Flush()
 	should.Nil(stream.Error)

jsoniter_customize_test.go

@@ -19,7 +19,7 @@ func Test_customize_type_decoder(t *testing.T) {
 		}
 		*((*time.Time)(ptr)) = t
 	})
-	defer ConfigOfDefault.CleanDecoders()
+	defer ConfigDefault.CleanDecoders()
 	val := time.Time{}
 	err := Unmarshal([]byte(`"2016-12-05 08:43:28"`), &val)
 	if err != nil {
@@ -37,7 +37,7 @@ func Test_customize_type_encoder(t *testing.T) {
 		t := *((*time.Time)(ptr))
 		stream.WriteString(t.UTC().Format("2006-01-02 15:04:05"))
 	})
-	defer ConfigOfDefault.CleanEncoders()
+	defer ConfigDefault.CleanEncoders()
 	val := time.Unix(0, 0)
 	str, err := MarshalToString(val)
 	should.Nil(err)
@@ -45,13 +45,13 @@ func Test_customize_type_encoder(t *testing.T) {
 }
 
 func Test_customize_byte_array_encoder(t *testing.T) {
-	ConfigOfDefault.CleanEncoders()
+	ConfigDefault.CleanEncoders()
 	should := require.New(t)
 	RegisterTypeEncoder("[]uint8", func(ptr unsafe.Pointer, stream *Stream) {
 		t := *((*[]byte)(ptr))
 		stream.WriteString(string(t))
 	})
-	defer ConfigOfDefault.CleanEncoders()
+	defer ConfigDefault.CleanEncoders()
 	val := []byte("abc")
 	str, err := MarshalToString(val)
 	should.Nil(err)
@@ -74,7 +74,7 @@ func Test_customize_field_decoder(t *testing.T) {
 	RegisterFieldDecoder("jsoniter.Tom", "field1", func(ptr unsafe.Pointer, iter *Iterator) {
 		*((*string)(ptr)) = strconv.Itoa(iter.ReadInt())
 	})
-	defer ConfigOfDefault.CleanDecoders()
+	defer ConfigDefault.CleanDecoders()
 	tom := Tom{}
 	err := Unmarshal([]byte(`{"field1": 100}`), &tom)
 	if err != nil {

jsoniter_demo_test.go

@@ -16,7 +16,7 @@ func Test_bind_api_demo(t *testing.T) {
 }
 
 func Test_iterator_api_demo(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[0,1,2,3]`)
+	iter := ParseString(ConfigDefault, `[0,1,2,3]`)
 	total := 0
 	for iter.ReadArray() {
 		total += iter.ReadInt()

jsoniter_find_end_test.go

@@ -7,56 +7,56 @@ import (
 )
 
 func Test_string_end(t *testing.T) {
-	end, escaped := ParseString(ConfigOfDefault, `abc"`).findStringEnd()
+	end, escaped := ParseString(ConfigDefault, `abc"`).findStringEnd()
 	if end != 4 {
 		t.Fatal(end)
 	}
 	if escaped != false {
 		t.Fatal(escaped)
 	}
-	end, escaped = ParseString(ConfigOfDefault, `abc\\"`).findStringEnd()
+	end, escaped = ParseString(ConfigDefault, `abc\\"`).findStringEnd()
 	if end != 6 {
 		t.Fatal(end)
 	}
 	if escaped != true {
 		t.Fatal(escaped)
 	}
-	end, escaped = ParseString(ConfigOfDefault, `abc\\\\"`).findStringEnd()
+	end, escaped = ParseString(ConfigDefault, `abc\\\\"`).findStringEnd()
 	if end != 8 {
 		t.Fatal(end)
 	}
 	if escaped != true {
 		t.Fatal(escaped)
 	}
-	end, escaped = ParseString(ConfigOfDefault, `abc\"`).findStringEnd()
+	end, escaped = ParseString(ConfigDefault, `abc\"`).findStringEnd()
 	if end != -1 {
 		t.Fatal(end)
 	}
 	if escaped != false {
 		t.Fatal(escaped)
 	}
-	end, escaped = ParseString(ConfigOfDefault, `abc\`).findStringEnd()
+	end, escaped = ParseString(ConfigDefault, `abc\`).findStringEnd()
 	if end != -1 {
 		t.Fatal(end)
 	}
 	if escaped != true {
 		t.Fatal(escaped)
 	}
-	end, escaped = ParseString(ConfigOfDefault, `abc\\`).findStringEnd()
+	end, escaped = ParseString(ConfigDefault, `abc\\`).findStringEnd()
 	if end != -1 {
 		t.Fatal(end)
 	}
 	if escaped != false {
 		t.Fatal(escaped)
 	}
-	end, escaped = ParseString(ConfigOfDefault, `\\`).findStringEnd()
+	end, escaped = ParseString(ConfigDefault, `\\`).findStringEnd()
 	if end != -1 {
 		t.Fatal(end)
 	}
 	if escaped != false {
 		t.Fatal(escaped)
 	}
-	end, escaped = ParseString(ConfigOfDefault, `\`).findStringEnd()
+	end, escaped = ParseString(ConfigDefault, `\`).findStringEnd()
 	if end != -1 {
 		t.Fatal(end)
 	}
@@ -91,54 +91,54 @@ func (reader *StagedReader) Read(p []byte) (n int, err error) {
 
 func Test_skip_string(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `"abc`)
+	iter := ParseString(ConfigDefault, `"abc`)
 	iter.skipString()
 	should.Equal(1, iter.head)
-	iter = ParseString(ConfigOfDefault, `\""abc`)
+	iter = ParseString(ConfigDefault, `\""abc`)
 	iter.skipString()
 	should.Equal(3, iter.head)
 	reader := &StagedReader{
 		r1: `abc`,
 		r2: `"`,
 	}
-	iter = Parse(ConfigOfDefault, reader, 4096)
+	iter = Parse(ConfigDefault, reader, 4096)
 	iter.skipString()
 	should.Equal(1, iter.head)
 	reader = &StagedReader{
 		r1: `abc`,
 		r2: `1"`,
 	}
-	iter = Parse(ConfigOfDefault, reader, 4096)
+	iter = Parse(ConfigDefault, reader, 4096)
 	iter.skipString()
 	should.Equal(2, iter.head)
 	reader = &StagedReader{
 		r1: `abc\`,
 		r2: `"`,
 	}
-	iter = Parse(ConfigOfDefault, reader, 4096)
+	iter = Parse(ConfigDefault, reader, 4096)
 	iter.skipString()
 	should.NotNil(iter.Error)
 	reader = &StagedReader{
 		r1: `abc\`,
 		r2: `""`,
 	}
-	iter = Parse(ConfigOfDefault, reader, 4096)
+	iter = Parse(ConfigDefault, reader, 4096)
 	iter.skipString()
 	should.Equal(2, iter.head)
 }
 
 func Test_skip_object(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `}`)
+	iter := ParseString(ConfigDefault, `}`)
 	iter.skipObject()
 	if iter.head != 1 {
 		t.Fatal(iter.head)
 	}
-	iter = ParseString(ConfigOfDefault, `a}`)
+	iter = ParseString(ConfigDefault, `a}`)
 	iter.skipObject()
 	if iter.head != 2 {
 		t.Fatal(iter.head)
 	}
-	iter = ParseString(ConfigOfDefault, `{}}a`)
+	iter = ParseString(ConfigDefault, `{}}a`)
 	iter.skipObject()
 	if iter.head != 3 {
 		t.Fatal(iter.head)
@@ -147,12 +147,12 @@ func Test_skip_object(t *testing.T) {
 		r1: `{`,
 		r2: `}}a`,
 	}
-	iter = Parse(ConfigOfDefault, reader, 4096)
+	iter = Parse(ConfigDefault, reader, 4096)
 	iter.skipObject()
 	if iter.head != 2 {
 		t.Fatal(iter.head)
 	}
-	iter = ParseString(ConfigOfDefault, `"}"}a`)
+	iter = ParseString(ConfigDefault, `"}"}a`)
 	iter.skipObject()
 	if iter.head != 4 {
 		t.Fatal(iter.head)

jsoniter_float_test.go

@@ -11,7 +11,7 @@ import (
 
 func Test_read_big_float(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `12.3`)
+	iter := ParseString(ConfigDefault, `12.3`)
 	val := iter.ReadBigFloat()
 	val64, _ := val.Float64()
 	should.Equal(12.3, val64)
@@ -19,7 +19,7 @@ func Test_read_big_float(t *testing.T) {
 
 func Test_read_big_int(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `92233720368547758079223372036854775807`)
+	iter := ParseString(ConfigDefault, `92233720368547758079223372036854775807`)
 	val := iter.ReadBigInt()
 	should.NotNil(val)
 	should.Equal(`92233720368547758079223372036854775807`, val.String())
@@ -31,14 +31,14 @@ func Test_read_float(t *testing.T) {
 		// non-streaming
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := ParseString(ConfigOfDefault, input+",")
+			iter := ParseString(ConfigDefault, input+",")
 			expected, err := strconv.ParseFloat(input, 32)
 			should.Nil(err)
 			should.Equal(float32(expected), iter.ReadFloat32())
 		})
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := ParseString(ConfigOfDefault, input+",")
+			iter := ParseString(ConfigDefault, input+",")
 			expected, err := strconv.ParseFloat(input, 64)
 			should.Nil(err)
 			should.Equal(expected, iter.ReadFloat64())
@@ -46,14 +46,14 @@ func Test_read_float(t *testing.T) {
 		// streaming
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := Parse(ConfigOfDefault, bytes.NewBufferString(input+","), 2)
+			iter := Parse(ConfigDefault, bytes.NewBufferString(input+","), 2)
 			expected, err := strconv.ParseFloat(input, 32)
 			should.Nil(err)
 			should.Equal(float32(expected), iter.ReadFloat32())
 		})
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := Parse(ConfigOfDefault, bytes.NewBufferString(input+","), 2)
+			iter := Parse(ConfigDefault, bytes.NewBufferString(input+","), 2)
 			expected, err := strconv.ParseFloat(input, 64)
 			should.Nil(err)
 			should.Equal(expected, iter.ReadFloat64())
@@ -63,7 +63,7 @@ func Test_read_float(t *testing.T) {
 
 func Test_read_float_as_interface(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `12.3`)
+	iter := ParseString(ConfigDefault, `12.3`)
 	should.Equal(float64(12.3), iter.Read())
 }
 
@@ -90,7 +90,7 @@ func Test_write_float32(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteFloat32Lossy(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -99,7 +99,7 @@ func Test_write_float32(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteVal(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -108,7 +108,7 @@ func Test_write_float32(t *testing.T) {
 	}
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 10)
+	stream := NewStream(ConfigDefault, buf, 10)
 	stream.WriteRaw("abcdefg")
 	stream.WriteFloat32Lossy(1.123456)
 	stream.Flush()
@@ -123,7 +123,7 @@ func Test_write_float64(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteFloat64Lossy(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -132,7 +132,7 @@ func Test_write_float64(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteVal(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -141,7 +141,7 @@ func Test_write_float64(t *testing.T) {
 	}
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 10)
+	stream := NewStream(ConfigDefault, buf, 10)
 	stream.WriteRaw("abcdefg")
 	stream.WriteFloat64Lossy(1.123456)
 	stream.Flush()
@@ -151,7 +151,7 @@ func Test_write_float64(t *testing.T) {
 
 func Test_read_float64_cursor(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, "[1.23456789\n,2,3]")
+	iter := ParseString(ConfigDefault, "[1.23456789\n,2,3]")
 	should.True(iter.ReadArray())
 	should.Equal(1.23456789, iter.Read())
 	should.True(iter.ReadArray())
@@ -174,7 +174,7 @@ func Test_read_float_scientific(t *testing.T) {
 func Benchmark_jsoniter_float(b *testing.B) {
 	b.ReportAllocs()
 	input := []byte(`1.1123,`)
-	iter := NewIterator(ConfigOfDefault)
+	iter := NewIterator(ConfigDefault)
 	for n := 0; n < b.N; n++ {
 		iter.ResetBytes(input)
 		iter.ReadFloat64()

jsoniter_int_test.go

@@ -13,7 +13,7 @@ import (
 
 func Test_read_uint64_invalid(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, ",")
+	iter := ParseString(ConfigDefault, ",")
 	iter.ReadUint64()
 	should.NotNil(iter.Error)
 }
@@ -23,7 +23,7 @@ func Test_read_int8(t *testing.T) {
 	for _, input := range inputs {
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := ParseString(ConfigOfDefault, input)
+			iter := ParseString(ConfigDefault, input)
 			expected, err := strconv.ParseInt(input, 10, 8)
 			should.Nil(err)
 			should.Equal(int8(expected), iter.ReadInt8())
@@ -36,7 +36,7 @@ func Test_read_int16(t *testing.T) {
 	for _, input := range inputs {
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := ParseString(ConfigOfDefault, input)
+			iter := ParseString(ConfigDefault, input)
 			expected, err := strconv.ParseInt(input, 10, 16)
 			should.Nil(err)
 			should.Equal(int16(expected), iter.ReadInt16())
@@ -49,14 +49,14 @@ func Test_read_int32(t *testing.T) {
 	for _, input := range inputs {
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := ParseString(ConfigOfDefault, input)
+			iter := ParseString(ConfigDefault, input)
 			expected, err := strconv.ParseInt(input, 10, 32)
 			should.Nil(err)
 			should.Equal(int32(expected), iter.ReadInt32())
 		})
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := Parse(ConfigOfDefault, bytes.NewBufferString(input), 2)
+			iter := Parse(ConfigDefault, bytes.NewBufferString(input), 2)
 			expected, err := strconv.ParseInt(input, 10, 32)
 			should.Nil(err)
 			should.Equal(int32(expected), iter.ReadInt32())
@@ -83,7 +83,7 @@ func Test_read_int64_array(t *testing.T) {
 func Test_read_int32_overflow(t *testing.T) {
 	should := require.New(t)
 	input := "123456789123456789,"
-	iter := ParseString(ConfigOfDefault, input)
+	iter := ParseString(ConfigDefault, input)
 	iter.ReadInt32()
 	should.NotNil(iter.Error)
 }
@@ -93,14 +93,14 @@ func Test_read_int64(t *testing.T) {
 	for _, input := range inputs {
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := ParseString(ConfigOfDefault, input)
+			iter := ParseString(ConfigDefault, input)
 			expected, err := strconv.ParseInt(input, 10, 64)
 			should.Nil(err)
 			should.Equal(expected, iter.ReadInt64())
 		})
 		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
 			should := require.New(t)
-			iter := Parse(ConfigOfDefault, bytes.NewBufferString(input), 2)
+			iter := Parse(ConfigDefault, bytes.NewBufferString(input), 2)
 			expected, err := strconv.ParseInt(input, 10, 64)
 			should.Nil(err)
 			should.Equal(expected, iter.ReadInt64())
@@ -111,7 +111,7 @@ func Test_read_int64(t *testing.T) {
 func Test_read_int64_overflow(t *testing.T) {
 	should := require.New(t)
 	input := "123456789123456789123456789123456789,"
-	iter := ParseString(ConfigOfDefault, input)
+	iter := ParseString(ConfigDefault, input)
 	iter.ReadInt64()
 	should.NotNil(iter.Error)
 }
@@ -146,7 +146,7 @@ func Test_write_uint8(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteUint8(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -155,7 +155,7 @@ func Test_write_uint8(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteVal(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -164,7 +164,7 @@ func Test_write_uint8(t *testing.T) {
 	}
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 3)
+	stream := NewStream(ConfigDefault, buf, 3)
 	stream.WriteRaw("a")
 	stream.WriteUint8(100) // should clear buffer
 	stream.Flush()
@@ -178,7 +178,7 @@ func Test_write_int8(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteInt8(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -187,7 +187,7 @@ func Test_write_int8(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteVal(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -196,7 +196,7 @@ func Test_write_int8(t *testing.T) {
 	}
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 4)
+	stream := NewStream(ConfigDefault, buf, 4)
 	stream.WriteRaw("a")
 	stream.WriteInt8(-100) // should clear buffer
 	stream.Flush()
@@ -210,7 +210,7 @@ func Test_write_uint16(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteUint16(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -219,7 +219,7 @@ func Test_write_uint16(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteVal(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -228,7 +228,7 @@ func Test_write_uint16(t *testing.T) {
 	}
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 5)
+	stream := NewStream(ConfigDefault, buf, 5)
 	stream.WriteRaw("a")
 	stream.WriteUint16(10000) // should clear buffer
 	stream.Flush()
@@ -242,7 +242,7 @@ func Test_write_int16(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteInt16(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -251,7 +251,7 @@ func Test_write_int16(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteVal(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -260,7 +260,7 @@ func Test_write_int16(t *testing.T) {
 	}
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 6)
+	stream := NewStream(ConfigDefault, buf, 6)
 	stream.WriteRaw("a")
 	stream.WriteInt16(-10000) // should clear buffer
 	stream.Flush()
@@ -274,7 +274,7 @@ func Test_write_uint32(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteUint32(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -283,7 +283,7 @@ func Test_write_uint32(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteVal(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -292,7 +292,7 @@ func Test_write_uint32(t *testing.T) {
 	}
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 10)
+	stream := NewStream(ConfigDefault, buf, 10)
 	stream.WriteRaw("a")
 	stream.WriteUint32(0xffffffff) // should clear buffer
 	stream.Flush()
@@ -306,7 +306,7 @@ func Test_write_int32(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteInt32(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -315,7 +315,7 @@ func Test_write_int32(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteVal(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -324,7 +324,7 @@ func Test_write_int32(t *testing.T) {
 	}
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 11)
+	stream := NewStream(ConfigDefault, buf, 11)
 	stream.WriteRaw("a")
 	stream.WriteInt32(-0x7fffffff) // should clear buffer
 	stream.Flush()
@@ -340,7 +340,7 @@ func Test_write_uint64(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteUint64(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -349,7 +349,7 @@ func Test_write_uint64(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteVal(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -358,7 +358,7 @@ func Test_write_uint64(t *testing.T) {
 	}
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 10)
+	stream := NewStream(ConfigDefault, buf, 10)
 	stream.WriteRaw("a")
 	stream.WriteUint64(0xffffffff) // should clear buffer
 	stream.Flush()
@@ -374,7 +374,7 @@ func Test_write_int64(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteInt64(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -383,7 +383,7 @@ func Test_write_int64(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
 			should := require.New(t)
 			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigOfDefault, buf, 4096)
+			stream := NewStream(ConfigDefault, buf, 4096)
 			stream.WriteVal(val)
 			stream.Flush()
 			should.Nil(stream.Error)
@@ -392,7 +392,7 @@ func Test_write_int64(t *testing.T) {
 	}
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 10)
+	stream := NewStream(ConfigDefault, buf, 10)
 	stream.WriteRaw("a")
 	stream.WriteInt64(0xffffffff) // should clear buffer
 	stream.Flush()
@@ -403,7 +403,7 @@ func Test_write_int64(t *testing.T) {
 func Test_write_val_int(t *testing.T) {
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 4096)
+	stream := NewStream(ConfigDefault, buf, 4096)
 	stream.WriteVal(1001)
 	stream.Flush()
 	should.Nil(stream.Error)
@@ -413,7 +413,7 @@ func Test_write_val_int(t *testing.T) {
 func Test_write_val_int_ptr(t *testing.T) {
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 4096)
+	stream := NewStream(ConfigDefault, buf, 4096)
 	val := 1001
 	stream.WriteVal(&val)
 	stream.Flush()
@@ -433,7 +433,7 @@ func Test_json_number(t *testing.T) {
 }
 
 func Benchmark_jsoniter_encode_int(b *testing.B) {
-	stream := NewStream(ConfigOfDefault, ioutil.Discard, 64)
+	stream := NewStream(ConfigDefault, ioutil.Discard, 64)
 	for n := 0; n < b.N; n++ {
 		stream.n = 0
 		stream.WriteUint64(0xffffffff)
@@ -447,7 +447,7 @@ func Benchmark_itoa(b *testing.B) {
 }
 
 func Benchmark_jsoniter_int(b *testing.B) {
-	iter := NewIterator(ConfigOfDefault)
+	iter := NewIterator(ConfigDefault)
 	input := []byte(`100`)
 	for n := 0; n < b.N; n++ {
 		iter.ResetBytes(input)

jsoniter_interface_test.go

@@ -141,8 +141,8 @@ func Test_encode_object_contain_non_empty_interface(t *testing.T) {
 }
 
 func Test_nil_non_empty_interface(t *testing.T) {
-	ConfigOfDefault.CleanEncoders()
-	ConfigOfDefault.CleanDecoders()
+	ConfigDefault.CleanEncoders()
+	ConfigDefault.CleanDecoders()
 	type TestObject struct {
 		Field []MyInterface
 	}

jsoniter_io_test.go

@@ -7,7 +7,7 @@ import (
 )
 
 func Test_read_by_one(t *testing.T) {
-	iter := Parse(ConfigOfDefault, bytes.NewBufferString("abc"), 1)
+	iter := Parse(ConfigDefault, bytes.NewBufferString("abc"), 1)
 	b := iter.readByte()
 	if iter.Error != nil {
 		t.Fatal(iter.Error)
@@ -34,7 +34,7 @@ func Test_read_by_one(t *testing.T) {
 }
 
 func Test_read_by_two(t *testing.T) {
-	iter := Parse(ConfigOfDefault, bytes.NewBufferString("abc"), 2)
+	iter := Parse(ConfigDefault, bytes.NewBufferString("abc"), 2)
 	b := iter.readByte()
 	if iter.Error != nil {
 		t.Fatal(iter.Error)
@@ -67,7 +67,7 @@ func Test_read_by_two(t *testing.T) {
 }
 
 func Test_read_until_eof(t *testing.T) {
-	iter := Parse(ConfigOfDefault, bytes.NewBufferString("abc"), 2)
+	iter := Parse(ConfigDefault, bytes.NewBufferString("abc"), 2)
 	iter.readByte()
 	iter.readByte()
 	b := iter.readByte()

jsoniter_large_file_test.go

@@ -27,7 +27,7 @@ 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(ConfigOfDefault, file, 4096)
+		iter := Parse(ConfigDefault, file, 4096)
 		count := 0
 		for iter.ReadArray() {
 			iter.Skip()

jsoniter_map_test.go

@@ -9,7 +9,7 @@ import (
 
 func Test_read_map(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `{"hello": "world"}`)
+	iter := ParseString(ConfigDefault, `{"hello": "world"}`)
 	m := map[string]string{"1": "2"}
 	iter.ReadVal(&m)
 	copy(iter.buf, []byte{0, 0, 0, 0, 0, 0})
@@ -18,11 +18,11 @@ func Test_read_map(t *testing.T) {
 
 func Test_read_map_of_interface(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `{"hello": "world"}`)
+	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(ConfigOfDefault, `{"hello": "world"}`)
+	iter = ParseString(ConfigDefault, `{"hello": "world"}`)
 	should.Equal(map[string]interface{}{"hello": "world"}, iter.Read())
 }
 

jsoniter_nested_test.go

@@ -15,7 +15,7 @@ type Level2 struct {
 }
 
 func Test_nested(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
+	iter := ParseString(ConfigDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
 	l1 := Level1{}
 	for l1Field := iter.ReadObject(); l1Field != ""; l1Field = iter.ReadObject() {
 		switch l1Field {
@@ -50,7 +50,7 @@ func Test_nested(t *testing.T) {
 
 func Benchmark_jsoniter_nested(b *testing.B) {
 	for n := 0; n < b.N; n++ {
-		iter := ParseString(ConfigOfDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
+		iter := ParseString(ConfigDefault, `{"hello": [{"world": "value1"}, {"world": "value2"}]}`)
 		l1 := Level1{}
 		for l1Field := iter.ReadObject(); l1Field != ""; l1Field = iter.ReadObject() {
 			switch l1Field {

jsoniter_null_test.go

@@ -9,11 +9,11 @@ import (
 
 func Test_read_null(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `null`)
+	iter := ParseString(ConfigDefault, `null`)
 	should.True(iter.ReadNil())
-	iter = ParseString(ConfigOfDefault, `null`)
+	iter = ParseString(ConfigDefault, `null`)
 	should.Nil(iter.Read())
-	iter = ParseString(ConfigOfDefault, `null`)
+	iter = ParseString(ConfigDefault, `null`)
 	any, err := UnmarshalAnyFromString(`null`)
 	should.Nil(err)
 	should.Equal(0, any.ToInt())
@@ -25,7 +25,7 @@ func Test_read_null(t *testing.T) {
 func Test_write_null(t *testing.T) {
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 4096)
+	stream := NewStream(ConfigDefault, buf, 4096)
 	stream.WriteNil()
 	stream.Flush()
 	should.Nil(stream.Error)
@@ -41,7 +41,7 @@ func Test_encode_null(t *testing.T) {
 
 func Test_decode_null_object(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `[null,"a"]`)
+	iter := ParseString(ConfigDefault, `[null,"a"]`)
 	iter.ReadArray()
 	if iter.ReadObject() != "" {
 		t.FailNow()
@@ -59,7 +59,7 @@ func Test_decode_null_object(t *testing.T) {
 }
 
 func Test_decode_null_array(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[null,"a"]`)
+	iter := ParseString(ConfigDefault, `[null,"a"]`)
 	iter.ReadArray()
 	if iter.ReadArray() != false {
 		t.FailNow()
@@ -72,7 +72,7 @@ func Test_decode_null_array(t *testing.T) {
 
 func Test_decode_null_string(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `[null,"a"]`)
+	iter := ParseString(ConfigDefault, `[null,"a"]`)
 	should.True(iter.ReadArray())
 	should.Equal("", iter.ReadString())
 	should.True(iter.ReadArray())
@@ -80,7 +80,7 @@ func Test_decode_null_string(t *testing.T) {
 }
 
 func Test_decode_null_skip(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[null,"a"]`)
+	iter := ParseString(ConfigDefault, `[null,"a"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()

jsoniter_object_test.go

@@ -9,10 +9,10 @@ import (
 
 func Test_empty_object(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `{}`)
+	iter := ParseString(ConfigDefault, `{}`)
 	field := iter.ReadObject()
 	should.Equal("", field)
-	iter = ParseString(ConfigOfDefault, `{}`)
+	iter = ParseString(ConfigDefault, `{}`)
 	iter.ReadObjectCB(func(iter *Iterator, field string) bool {
 		should.FailNow("should not call")
 		return true
@@ -21,14 +21,14 @@ func Test_empty_object(t *testing.T) {
 
 func Test_one_field(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `{"a": "b"}`)
+	iter := ParseString(ConfigDefault, `{"a": "b"}`)
 	field := iter.ReadObject()
 	should.Equal("a", field)
 	value := iter.ReadString()
 	should.Equal("b", value)
 	field = iter.ReadObject()
 	should.Equal("", field)
-	iter = ParseString(ConfigOfDefault, `{"a": "b"}`)
+	iter = ParseString(ConfigDefault, `{"a": "b"}`)
 	should.True(iter.ReadObjectCB(func(iter *Iterator, field string) bool {
 		should.Equal("a", field)
 		return true
@@ -37,7 +37,7 @@ func Test_one_field(t *testing.T) {
 
 func Test_two_field(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `{ "a": "b" , "c": "d" }`)
+	iter := ParseString(ConfigDefault, `{ "a": "b" , "c": "d" }`)
 	field := iter.ReadObject()
 	should.Equal("a", field)
 	value := iter.ReadString()
@@ -48,7 +48,7 @@ func Test_two_field(t *testing.T) {
 	should.Equal("d", value)
 	field = iter.ReadObject()
 	should.Equal("", field)
-	iter = ParseString(ConfigOfDefault, `{"field1": "1", "field2": 2}`)
+	iter = ParseString(ConfigDefault, `{"field1": "1", "field2": 2}`)
 	for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
 		switch field {
 		case "field1":
@@ -229,7 +229,7 @@ func Benchmark_jsoniter_object(b *testing.B) {
 		Field2 uint64
 	}
 	for n := 0; n < b.N; n++ {
-		iter := ParseString(ConfigOfDefault, `{"field1": "1", "field2": 2}`)
+		iter := ParseString(ConfigDefault, `{"field1": "1", "field2": 2}`)
 		obj := TestObj{}
 		for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
 			switch field {

jsoniter_reflect_native_test.go

@@ -6,7 +6,7 @@ import (
 )
 
 func Test_reflect_str(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `"hello"`)
+	iter := ParseString(ConfigDefault, `"hello"`)
 	str := ""
 	iter.ReadVal(&str)
 	if str != "hello" {
@@ -16,7 +16,7 @@ func Test_reflect_str(t *testing.T) {
 }
 
 func Test_reflect_ptr_str(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `"hello"`)
+	iter := ParseString(ConfigDefault, `"hello"`)
 	var str *string
 	iter.ReadVal(&str)
 	if *str != "hello" {
@@ -25,7 +25,7 @@ func Test_reflect_ptr_str(t *testing.T) {
 }
 
 func Test_reflect_int(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `123`)
+	iter := ParseString(ConfigDefault, `123`)
 	val := int(0)
 	iter.ReadVal(&val)
 	if val != 123 {
@@ -34,7 +34,7 @@ func Test_reflect_int(t *testing.T) {
 }
 
 func Test_reflect_int8(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `123`)
+	iter := ParseString(ConfigDefault, `123`)
 	val := int8(0)
 	iter.ReadVal(&val)
 	if val != 123 {
@@ -43,7 +43,7 @@ func Test_reflect_int8(t *testing.T) {
 }
 
 func Test_reflect_int16(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `123`)
+	iter := ParseString(ConfigDefault, `123`)
 	val := int16(0)
 	iter.ReadVal(&val)
 	if val != 123 {
@@ -52,7 +52,7 @@ func Test_reflect_int16(t *testing.T) {
 }
 
 func Test_reflect_int32(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `123`)
+	iter := ParseString(ConfigDefault, `123`)
 	val := int32(0)
 	iter.ReadVal(&val)
 	if val != 123 {
@@ -61,7 +61,7 @@ func Test_reflect_int32(t *testing.T) {
 }
 
 func Test_reflect_int64(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `123`)
+	iter := ParseString(ConfigDefault, `123`)
 	val := int64(0)
 	iter.ReadVal(&val)
 	if val != 123 {
@@ -70,7 +70,7 @@ func Test_reflect_int64(t *testing.T) {
 }
 
 func Test_reflect_uint(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `123`)
+	iter := ParseString(ConfigDefault, `123`)
 	val := uint(0)
 	iter.ReadVal(&val)
 	if val != 123 {
@@ -79,7 +79,7 @@ func Test_reflect_uint(t *testing.T) {
 }
 
 func Test_reflect_uint8(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `123`)
+	iter := ParseString(ConfigDefault, `123`)
 	val := uint8(0)
 	iter.ReadVal(&val)
 	if val != 123 {
@@ -88,7 +88,7 @@ func Test_reflect_uint8(t *testing.T) {
 }
 
 func Test_reflect_uint16(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `123`)
+	iter := ParseString(ConfigDefault, `123`)
 	val := uint16(0)
 	iter.ReadVal(&val)
 	if val != 123 {
@@ -97,7 +97,7 @@ func Test_reflect_uint16(t *testing.T) {
 }
 
 func Test_reflect_uint32(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `123`)
+	iter := ParseString(ConfigDefault, `123`)
 	val := uint32(0)
 	iter.ReadVal(&val)
 	if val != 123 {
@@ -106,7 +106,7 @@ func Test_reflect_uint32(t *testing.T) {
 }
 
 func Test_reflect_uint64(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `123`)
+	iter := ParseString(ConfigDefault, `123`)
 	val := uint64(0)
 	iter.ReadVal(&val)
 	if val != 123 {
@@ -115,7 +115,7 @@ func Test_reflect_uint64(t *testing.T) {
 }
 
 func Test_reflect_byte(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `123`)
+	iter := ParseString(ConfigDefault, `123`)
 	val := byte(0)
 	iter.ReadVal(&val)
 	if val != 123 {
@@ -124,7 +124,7 @@ func Test_reflect_byte(t *testing.T) {
 }
 
 func Test_reflect_float32(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `1.23`)
+	iter := ParseString(ConfigDefault, `1.23`)
 	val := float32(0)
 	iter.ReadVal(&val)
 	if val != 1.23 {
@@ -134,7 +134,7 @@ func Test_reflect_float32(t *testing.T) {
 }
 
 func Test_reflect_float64(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `1.23`)
+	iter := ParseString(ConfigDefault, `1.23`)
 	val := float64(0)
 	iter.ReadVal(&val)
 	if val != 1.23 {
@@ -144,7 +144,7 @@ func Test_reflect_float64(t *testing.T) {
 }
 
 func Test_reflect_bool(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `true`)
+	iter := ParseString(ConfigDefault, `true`)
 	val := false
 	iter.ReadVal(&val)
 	if val != true {

jsoniter_reflect_test.go

@@ -27,7 +27,7 @@ func Test_decode_nested(t *testing.T) {
 		Field1 string
 		Field2 string
 	}
-	iter := ParseString(ConfigOfDefault, `[{"field1": "hello"}, null, {"field2": "world"}]`)
+	iter := ParseString(ConfigDefault, `[{"field1": "hello"}, null, {"field2": "world"}]`)
 	slice := []*StructOfString{}
 	iter.ReadVal(&slice)
 	if len(slice) != 3 {
@@ -49,12 +49,12 @@ func Test_decode_nested(t *testing.T) {
 }
 
 func Test_decode_base64(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `"YWJj"`)
+	iter := ParseString(ConfigDefault, `"YWJj"`)
 	val := []byte{}
 	RegisterTypeDecoder("[]uint8", func(ptr unsafe.Pointer, iter *Iterator) {
 		*((*[]byte)(ptr)) = iter.ReadBase64()
 	})
-	defer ConfigOfDefault.CleanDecoders()
+	defer ConfigDefault.CleanDecoders()
 	iter.ReadVal(&val)
 	if "abc" != string(val) {
 		t.Fatal(string(val))
@@ -70,7 +70,7 @@ type StructOfTagOne struct {
 
 func Benchmark_jsoniter_reflect(b *testing.B) {
 	b.ReportAllocs()
-	iter := NewIterator(ConfigOfDefault)
+	iter := NewIterator(ConfigDefault)
 	Struct := &StructOfTagOne{}
 	//var Struct *StructOfTagOne
 	input := []byte(`{"field3": "100", "field4": "100"}`)
@@ -96,7 +96,7 @@ func Benchmark_jsoniter_direct(b *testing.B) {
 		//		iter.Skip()
 		//	}
 		//}
-		iter := ParseString(ConfigOfDefault, `["hello", "world"]`)
+		iter := ParseString(ConfigDefault, `["hello", "world"]`)
 		array := make([]string, 0, 2)
 		for iter.ReadArray() {
 			array = append(array, iter.ReadString())

jsoniter_skip_test.go

@@ -6,7 +6,7 @@ import (
 )
 
 func Test_skip_number(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[-0.12, "b"]`)
+	iter := ParseString(ConfigDefault, `[-0.12, "b"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
@@ -16,7 +16,7 @@ func Test_skip_number(t *testing.T) {
 }
 
 func Test_skip_null(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[null , "b"]`)
+	iter := ParseString(ConfigDefault, `[null , "b"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
@@ -26,7 +26,7 @@ func Test_skip_null(t *testing.T) {
 }
 
 func Test_skip_true(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[true , "b"]`)
+	iter := ParseString(ConfigDefault, `[true , "b"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
@@ -36,7 +36,7 @@ func Test_skip_true(t *testing.T) {
 }
 
 func Test_skip_false(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[false , "b"]`)
+	iter := ParseString(ConfigDefault, `[false , "b"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
@@ -46,7 +46,7 @@ func Test_skip_false(t *testing.T) {
 }
 
 func Test_skip_array(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[[1, [2, [3], 4]], "b"]`)
+	iter := ParseString(ConfigDefault, `[[1, [2, [3], 4]], "b"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
@@ -56,7 +56,7 @@ func Test_skip_array(t *testing.T) {
 }
 
 func Test_skip_empty_array(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[ [ ], "b"]`)
+	iter := ParseString(ConfigDefault, `[ [ ], "b"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
@@ -66,7 +66,7 @@ func Test_skip_empty_array(t *testing.T) {
 }
 
 func Test_skip_nested(t *testing.T) {
-	iter := ParseString(ConfigOfDefault, `[ {"a" : [{"b": "c"}], "d": 102 }, "b"]`)
+	iter := ParseString(ConfigDefault, `[ {"a" : [{"b": "c"}], "d": 102 }, "b"]`)
 	iter.ReadArray()
 	iter.Skip()
 	iter.ReadArray()
@@ -106,7 +106,7 @@ func Benchmark_jsoniter_skip(b *testing.B) {
 }`)
 	for n := 0; n < b.N; n++ {
 		result := TestResp{}
-		iter := ParseBytes(ConfigOfDefault, input)
+		iter := ParseBytes(ConfigDefault, input)
 		for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
 			switch field {
 			case "code":

jsoniter_stream_test.go

@@ -7,7 +7,7 @@ import (
 
 func Test_writeByte_should_grow_buffer(t *testing.T) {
 	should := require.New(t)
-	stream := NewStream(ConfigOfDefault, nil, 1)
+	stream := NewStream(ConfigDefault, nil, 1)
 	stream.writeByte('1')
 	should.Equal("1", string(stream.Buffer()))
 	should.Equal(1, len(stream.buf))
@@ -20,7 +20,7 @@ func Test_writeByte_should_grow_buffer(t *testing.T) {
 
 func Test_writeBytes_should_grow_buffer(t *testing.T) {
 	should := require.New(t)
-	stream := NewStream(ConfigOfDefault, nil, 1)
+	stream := NewStream(ConfigDefault, nil, 1)
 	stream.Write([]byte{'1', '2'})
 	should.Equal("12", string(stream.Buffer()))
 	should.Equal(3, len(stream.buf))
@@ -38,7 +38,7 @@ func Test_writeIndention_should_grow_buffer(t *testing.T) {
 
 func Test_writeRaw_should_grow_buffer(t *testing.T) {
 	should := require.New(t)
-	stream := NewStream(ConfigOfDefault, nil, 1)
+	stream := NewStream(ConfigDefault, nil, 1)
 	stream.WriteRaw("123")
 	should.Nil(stream.Error)
 	should.Equal("123", string(stream.Buffer()))
@@ -46,7 +46,7 @@ func Test_writeRaw_should_grow_buffer(t *testing.T) {
 
 func Test_writeString_should_grow_buffer(t *testing.T) {
 	should := require.New(t)
-	stream := NewStream(ConfigOfDefault, nil, 0)
+	stream := NewStream(ConfigDefault, nil, 0)
 	stream.WriteString("123")
 	should.Nil(stream.Error)
 	should.Equal(`"123"`, string(stream.Buffer()))

jsoniter_string_test.go

@@ -18,22 +18,22 @@ func Test_read_normal_string(t *testing.T) {
 	for input, output := range cases {
 		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
 			should := require.New(t)
-			iter := ParseString(ConfigOfDefault, input)
+			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(ConfigOfDefault, bytes.NewBufferString(input), 2)
+			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(ConfigOfDefault, input)
+			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(ConfigOfDefault, bytes.NewBufferString(input), 2)
+			iter := Parse(ConfigDefault, bytes.NewBufferString(input), 2)
 			should.Equal(output, string(iter.ReadStringAsSlice()))
 		})
 	}
@@ -49,12 +49,12 @@ func Test_read_exotic_string(t *testing.T) {
 	for input, output := range cases {
 		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
 			should := require.New(t)
-			iter := ParseString(ConfigOfDefault, input)
+			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(ConfigOfDefault, bytes.NewBufferString(input), 2)
+			iter := Parse(ConfigDefault, bytes.NewBufferString(input), 2)
 			should.Equal(output, iter.ReadString())
 		})
 	}
@@ -62,7 +62,7 @@ func Test_read_exotic_string(t *testing.T) {
 
 func Test_read_string_as_interface(t *testing.T) {
 	should := require.New(t)
-	iter := ParseString(ConfigOfDefault, `"hello"`)
+	iter := ParseString(ConfigDefault, `"hello"`)
 	should.Equal("hello", iter.Read())
 }
 
@@ -99,7 +99,7 @@ func Test_write_string(t *testing.T) {
 func Test_write_val_string(t *testing.T) {
 	should := require.New(t)
 	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigOfDefault, buf, 4096)
+	stream := NewStream(ConfigDefault, buf, 4096)
 	stream.WriteVal("hello")
 	stream.Flush()
 	should.Nil(stream.Error)
@@ -157,13 +157,13 @@ func Test_string_encode_with_std_without_html_escape(t *testing.T) {
 
 func Benchmark_jsoniter_unicode(b *testing.B) {
 	for n := 0; n < b.N; n++ {
-		iter := ParseString(ConfigOfDefault, `"\ud83d\udc4a"`)
+		iter := ParseString(ConfigDefault, `"\ud83d\udc4a"`)
 		iter.ReadString()
 	}
 }
 
 func Benchmark_jsoniter_ascii(b *testing.B) {
-	iter := NewIterator(ConfigOfDefault)
+	iter := NewIterator(ConfigDefault)
 	input := []byte(`"hello, world! hello, world!"`)
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
@@ -173,7 +173,7 @@ func Benchmark_jsoniter_ascii(b *testing.B) {
 }
 
 func Benchmark_jsoniter_string_as_bytes(b *testing.B) {
-	iter := ParseString(ConfigOfDefault, `"hello, world!"`)
+	iter := ParseString(ConfigDefault, `"hello, world!"`)
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		iter.ResetBytes(iter.buf)