update README

fix #308 do NOT skip embedded structs without tag when OnlyTaggedFiel…

Gopkg.lock

@@ -10,12 +10,12 @@
 [[projects]]
   name = "github.com/modern-go/reflect2"
   packages = ["."]
-  revision = "1df9eeb2bb81f327b96228865c5687bc2194af3f"
-  version = "1.0.0"
+  revision = "4b7aa43c6742a2c18fdef89dd197aaae7dac7ccd"
+  version = "1.0.1"
 
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "ac7003b5a981716353a43055ab7d4c5357403cb30a60de2dbdeb446c1544beaa"
+  inputs-digest = "ea54a775e5a354cb015502d2e7aa4b74230fc77e894f34a838b268c25ec8eeb8"
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -23,4 +23,4 @@ ignored = ["github.com/davecgh/go-spew*","github.com/google/gofuzz*","github.com
 
 [[constraint]]
   name = "github.com/modern-go/reflect2"
-  version = "1.0.0"
+  version = "1.0.1"

README.md

@@ -10,10 +10,6 @@ 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
-```
-
 # Benchmark
 
 ![benchmark](http://jsoniter.com/benchmarks/go-benchmark.png)
@@ -31,6 +27,9 @@ Raw Result (easyjson requires static code generation)
 | easyjson encode | 883 ns/op | 576 B/op | 3 allocs/op |
 | jsoniter encode | 837 ns/op | 384 B/op | 4 allocs/op |
 
+Always benchmark with your own workload. 
+The result depends heavily on the data input.
+
 # Usage
 
 100% compatibility with standard lib

adapter.go

@@ -77,7 +77,16 @@ func (adapter *Decoder) Decode(obj interface{}) error {
 
 // More is there more?
 func (adapter *Decoder) More() bool {
-	return adapter.iter.head != adapter.iter.tail
+	iter := adapter.iter
+	if iter.Error != nil {
+		return false
+	}
+	c := iter.nextToken()
+	if c == 0 {
+		return false
+	}
+	iter.unreadByte()
+	return c != ']' && c != '}'
 }
 
 // Buffered remaining buffer
@@ -91,7 +100,7 @@ func (adapter *Decoder) Buffered() io.Reader {
 func (adapter *Decoder) UseNumber() {
 	cfg := adapter.iter.cfg.configBeforeFrozen
 	cfg.UseNumber = true
-	adapter.iter.cfg = cfg.frozeWithCacheReuse()
+	adapter.iter.cfg = cfg.frozeWithCacheReuse(adapter.iter.cfg.extraExtensions)
 }
 
 // DisallowUnknownFields causes the Decoder to return an error when the destination
@@ -100,7 +109,7 @@ func (adapter *Decoder) UseNumber() {
 func (adapter *Decoder) DisallowUnknownFields() {
 	cfg := adapter.iter.cfg.configBeforeFrozen
 	cfg.DisallowUnknownFields = true
-	adapter.iter.cfg = cfg.frozeWithCacheReuse()
+	adapter.iter.cfg = cfg.frozeWithCacheReuse(adapter.iter.cfg.extraExtensions)
 }
 
 // NewEncoder same as json.NewEncoder
@@ -125,14 +134,14 @@ func (adapter *Encoder) Encode(val interface{}) error {
 func (adapter *Encoder) SetIndent(prefix, indent string) {
 	config := adapter.stream.cfg.configBeforeFrozen
 	config.IndentionStep = len(indent)
-	adapter.stream.cfg = config.frozeWithCacheReuse()
+	adapter.stream.cfg = config.frozeWithCacheReuse(adapter.stream.cfg.extraExtensions)
 }
 
 // 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.frozeWithCacheReuse()
+	adapter.stream.cfg = config.frozeWithCacheReuse(adapter.stream.cfg.extraExtensions)
 }
 
 // Valid reports whether data is a valid JSON encoding.

any.go

@@ -312,6 +312,10 @@ func (codec *directAnyCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
 
 func (codec *directAnyCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
 	any := *(*Any)(ptr)
+	if any == nil {
+		stream.WriteNil()
+		return
+	}
 	any.WriteTo(stream)
 }
 

any_tests/jsoniter_any_float_test.go

@@ -82,10 +82,8 @@ func Test_read_float_to_any(t *testing.T) {
 	should := require.New(t)
 	any := jsoniter.WrapFloat64(12.3)
 	anyFloat64 := float64(12.3)
-	//negaAnyFloat64 := float64(-1.1)
 	any2 := jsoniter.WrapFloat64(-1.1)
 	should.Equal(float64(12.3), any.ToFloat64())
-	//should.Equal("12.3", any.ToString())
 	should.True(any.ToBool())
 	should.Equal(float32(anyFloat64), any.ToFloat32())
 	should.Equal(int(anyFloat64), any.ToInt())

any_tests/jsoniter_any_object_test.go

@@ -118,6 +118,4 @@ func Test_object_wrapper_any_get_all(t *testing.T) {
 	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

@@ -8,24 +8,24 @@ import (
 )
 
 var stringConvertMap = map[string]string{
-	"null":      "",
-	"321.1":     "321.1",
-	`"1.1"`:     "1.1",
-	`"-123.1"`:  "-123.1",
-	"0.0":       "0.0",
-	"0":         "0",
-	`"0"`:       "0",
-	`"0.0"`:     "0.0",
-	`"00.0"`:    "00.0",
-	"true":      "true",
-	"false":     "false",
-	`"true"`:    "true",
-	`"false"`:   "false",
-	`"true123"`: "true123",
-	`"+1"`:      "+1",
-	"[]":        "[]",
-	"[1,2]":     "[1,2]",
-	"{}":        "{}",
+	"null":                   "",
+	"321.1":                  "321.1",
+	`"1.1"`:                  "1.1",
+	`"-123.1"`:               "-123.1",
+	"0.0":                    "0.0",
+	"0":                      "0",
+	`"0"`:                    "0",
+	`"0.0"`:                  "0.0",
+	`"00.0"`:                 "00.0",
+	"true":                   "true",
+	"false":                  "false",
+	`"true"`:                 "true",
+	`"false"`:                "false",
+	`"true123"`:              "true123",
+	`"+1"`:                   "+1",
+	"[]":                     "[]",
+	"[1,2]":                  "[1,2]",
+	"{}":                     "{}",
 	`{"a":1, "stream":true}`: `{"a":1, "stream":true}`,
 }
 

api_tests/config_test.go

@@ -2,9 +2,10 @@ package test
 
 import (
 	"encoding/json"
+	"testing"
+
 	"github.com/json-iterator/go"
 	"github.com/stretchr/testify/require"
-	"testing"
 )
 
 func Test_use_number_for_unmarshal(t *testing.T) {
@@ -45,3 +46,184 @@ func Test_read_large_number_as_interface(t *testing.T) {
 	should.Nil(err)
 	should.Equal(`123456789123456789123456789`, output)
 }
+
+type caseSensitiveStruct struct {
+	A string `json:"a"`
+	B string `json:"b,omitempty"`
+	C *C     `json:"C,omitempty"`
+}
+
+type C struct {
+	D int64 `json:"D,omitempty"`
+	E *E    `json:"e,omitempty"`
+}
+
+type E struct {
+	F string `json:"F,omitempty"`
+}
+
+func Test_CaseSensitive(t *testing.T) {
+	should := require.New(t)
+
+	testCases := []struct {
+		input          string
+		expectedOutput string
+		caseSensitive  bool
+	}{
+		{
+			input:          `{"A":"foo","B":"bar"}`,
+			expectedOutput: `{"a":"foo","b":"bar"}`,
+			caseSensitive:  false,
+		},
+		{
+			input:          `{"a":"foo","b":"bar"}`,
+			expectedOutput: `{"a":"foo","b":"bar"}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"foo","b":"bar","C":{"D":10}}`,
+			expectedOutput: `{"a":"foo","b":"bar","C":{"D":10}}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"foo","B":"bar","c":{"d":10}}`,
+			expectedOutput: `{"a":"foo"}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"foo","C":{"d":10}}`,
+			expectedOutput: `{"a":"foo","C":{}}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"foo","C":{"D":10,"e":{"f":"baz"}}}`,
+			expectedOutput: `{"a":"foo","C":{"D":10,"e":{}}}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"foo","C":{"D":10,"e":{"F":"baz"}}}`,
+			expectedOutput: `{"a":"foo","C":{"D":10,"e":{"F":"baz"}}}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"A":"foo","c":{"d":10,"E":{"f":"baz"}}}`,
+			expectedOutput: `{"a":"foo","C":{"D":10,"e":{"F":"baz"}}}`,
+			caseSensitive:  false,
+		},
+	}
+
+	for _, tc := range testCases {
+		val := caseSensitiveStruct{}
+		err := jsoniter.Config{CaseSensitive: tc.caseSensitive}.Froze().UnmarshalFromString(tc.input, &val)
+		should.Nil(err)
+
+		output, err := jsoniter.MarshalToString(val)
+		should.Nil(err)
+		should.Equal(tc.expectedOutput, output)
+	}
+}
+
+type structWithElevenFields struct {
+	A string `json:"A,omitempty"`
+	B string `json:"B,omitempty"`
+	C string `json:"C,omitempty"`
+	D string `json:"d,omitempty"`
+	E string `json:"e,omitempty"`
+	F string `json:"f,omitempty"`
+	G string `json:"g,omitempty"`
+	H string `json:"h,omitempty"`
+	I string `json:"i,omitempty"`
+	J string `json:"j,omitempty"`
+	K string `json:"k,omitempty"`
+}
+
+func Test_CaseSensitive_MoreThanTenFields(t *testing.T) {
+	should := require.New(t)
+
+	testCases := []struct {
+		input          string
+		expectedOutput string
+		caseSensitive  bool
+	}{
+		{
+			input:          `{"A":"1","B":"2","C":"3","d":"4","e":"5","f":"6","g":"7","h":"8","i":"9","j":"10","k":"11"}`,
+			expectedOutput: `{"A":"1","B":"2","C":"3","d":"4","e":"5","f":"6","g":"7","h":"8","i":"9","j":"10","k":"11"}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"1","b":"2","c":"3","D":"4","E":"5","F":"6"}`,
+			expectedOutput: `{"A":"1","B":"2","C":"3","d":"4","e":"5","f":"6"}`,
+			caseSensitive:  false,
+		},
+		{
+			input:          `{"A":"1","b":"2","d":"4","E":"5"}`,
+			expectedOutput: `{"A":"1","d":"4"}`,
+			caseSensitive:  true,
+		},
+	}
+
+	for _, tc := range testCases {
+		val := structWithElevenFields{}
+		err := jsoniter.Config{CaseSensitive: tc.caseSensitive}.Froze().UnmarshalFromString(tc.input, &val)
+		should.Nil(err)
+
+		output, err := jsoniter.MarshalToString(val)
+		should.Nil(err)
+		should.Equal(tc.expectedOutput, output)
+	}
+}
+
+type onlyTaggedFieldStruct struct {
+	A      string `json:"a"`
+	B      string
+	FSimpl F `json:"f_simpl"`
+	ISimpl I
+	FPtr   *F `json:"f_ptr"`
+	IPtr   *I
+	F
+	*I
+}
+
+type F struct {
+	G string `json:"g"`
+	H string
+}
+
+type I struct {
+	J string `json:"j"`
+	K string
+}
+
+func Test_OnlyTaggedField(t *testing.T) {
+	should := require.New(t)
+
+	obj := onlyTaggedFieldStruct{
+		A:      "a",
+		B:      "b",
+		FSimpl: F{G: "g", H: "h"},
+		ISimpl: I{J: "j", K: "k"},
+		FPtr:   &F{G: "g", H: "h"},
+		IPtr:   &I{J: "j", K: "k"},
+		F:      F{G: "g", H: "h"},
+		I:      &I{J: "j", K: "k"},
+	}
+
+	output, err := jsoniter.Config{OnlyTaggedField: true}.Froze().Marshal(obj)
+	should.Nil(err)
+
+	m := make(map[string]interface{})
+	err = jsoniter.Unmarshal(output, &m)
+	should.Nil(err)
+
+	should.Equal(map[string]interface{}{
+		"a": "a",
+		"f_simpl": map[string]interface{}{
+			"g": "g",
+		},
+		"f_ptr": map[string]interface{}{
+			"g": "g",
+		},
+		"g": "g",
+		"j": "j",
+	}, m)
+}

api_tests/decoder_test.go

@@ -56,3 +56,9 @@ func Test_use_number(t *testing.T) {
 	should.Nil(decoder2.Decode(&obj2))
 	should.Equal(json.Number("123"), obj2)
 }
+
+func Test_decoder_more(t *testing.T) {
+	should := require.New(t)
+	decoder := jsoniter.NewDecoder(bytes.NewBufferString("abcde"))
+	should.True(decoder.More())
+}

api_tests/marshal_json_test.go

@@ -0,0 +1,36 @@
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"testing"
+	"github.com/stretchr/testify/require"
+)
+
+
+type Foo struct {
+	Bar interface{}
+}
+
+func (f Foo) MarshalJSON() ([]byte, error) {
+	var buf bytes.Buffer
+	err := json.NewEncoder(&buf).Encode(f.Bar)
+	return buf.Bytes(), err
+}
+
+
+// Standard Encoder has trailing newline.
+func TestEncodeMarshalJSON(t *testing.T) {
+
+	foo := Foo {
+		Bar: 123,
+	}
+	should := require.New(t)
+	var buf, stdbuf bytes.Buffer
+	enc := jsoniter.ConfigCompatibleWithStandardLibrary.NewEncoder(&buf)
+	enc.Encode(foo)
+	stdenc := json.NewEncoder(&stdbuf)
+	stdenc.Encode(foo)
+	should.Equal(stdbuf.Bytes(), buf.Bytes())
+}

config.go

@@ -2,12 +2,13 @@ package jsoniter
 
 import (
 	"encoding/json"
-	"github.com/modern-go/concurrent"
-	"github.com/modern-go/reflect2"
 	"io"
 	"reflect"
 	"sync"
 	"unsafe"
+
+	"github.com/modern-go/concurrent"
+	"github.com/modern-go/reflect2"
 )
 
 // Config customize how the API should behave.
@@ -23,6 +24,7 @@ type Config struct {
 	OnlyTaggedField               bool
 	ValidateJsonRawMessage        bool
 	ObjectFieldMustBeSimpleString bool
+	CaseSensitive                 bool
 }
 
 // API the public interface of this package.
@@ -72,9 +74,12 @@ type frozenConfig struct {
 	disallowUnknownFields         bool
 	decoderCache                  *concurrent.Map
 	encoderCache                  *concurrent.Map
-	extensions                    []Extension
+	encoderExtension              Extension
+	decoderExtension              Extension
+	extraExtensions               []Extension
 	streamPool                    *sync.Pool
 	iteratorPool                  *sync.Pool
+	caseSensitive                 bool
 }
 
 func (cfg *frozenConfig) initCache() {
@@ -128,6 +133,7 @@ func (cfg Config) Froze() API {
 		objectFieldMustBeSimpleString: cfg.ObjectFieldMustBeSimpleString,
 		onlyTaggedField:               cfg.OnlyTaggedField,
 		disallowUnknownFields:         cfg.DisallowUnknownFields,
+		caseSensitive:                 cfg.CaseSensitive,
 	}
 	api.streamPool = &sync.Pool{
 		New: func() interface{} {
@@ -154,22 +160,21 @@ func (cfg Config) Froze() API {
 	if cfg.ValidateJsonRawMessage {
 		api.validateJsonRawMessage(encoderExtension)
 	}
-	if len(encoderExtension) > 0 {
-		api.extensions = append(api.extensions, encoderExtension)
-	}
-	if len(decoderExtension) > 0 {
-		api.extensions = append(api.extensions, decoderExtension)
-	}
+	api.encoderExtension = encoderExtension
+	api.decoderExtension = decoderExtension
 	api.configBeforeFrozen = cfg
 	return api
 }
 
-func (cfg Config) frozeWithCacheReuse() *frozenConfig {
+func (cfg Config) frozeWithCacheReuse(extraExtensions []Extension) *frozenConfig {
 	api := getFrozenConfigFromCache(cfg)
 	if api != nil {
 		return api
 	}
 	api = cfg.Froze().(*frozenConfig)
+	for _, extension := range extraExtensions {
+		api.RegisterExtension(extension)
+	}
 	addFrozenConfigToCache(cfg, api)
 	return api
 }
@@ -186,7 +191,7 @@ func (cfg *frozenConfig) validateJsonRawMessage(extension EncoderExtension) {
 			stream.WriteRaw(string(rawMessage))
 		}
 	}, func(ptr unsafe.Pointer) bool {
-		return false
+		return len(*((*json.RawMessage)(ptr))) == 0
 	}}
 	extension[reflect2.TypeOfPtr((*json.RawMessage)(nil)).Elem()] = encoder
 	extension[reflect2.TypeOfPtr((*RawMessage)(nil)).Elem()] = encoder
@@ -215,7 +220,9 @@ func (cfg *frozenConfig) getTagKey() string {
 }
 
 func (cfg *frozenConfig) RegisterExtension(extension Extension) {
-	cfg.extensions = append(cfg.extensions, extension)
+	cfg.extraExtensions = append(cfg.extraExtensions, extension)
+	copied := cfg.configBeforeFrozen
+	cfg.configBeforeFrozen = copied
 }
 
 type lossyFloat32Encoder struct {
@@ -310,7 +317,7 @@ func (cfg *frozenConfig) MarshalIndent(v interface{}, prefix, indent string) ([]
 	}
 	newCfg := cfg.configBeforeFrozen
 	newCfg.IndentionStep = len(indent)
-	return newCfg.frozeWithCacheReuse().Marshal(v)
+	return newCfg.frozeWithCacheReuse(cfg.extraExtensions).Marshal(v)
 }
 
 func (cfg *frozenConfig) UnmarshalFromString(str string, v interface{}) error {

example_test.go

@@ -95,7 +95,7 @@ func ExampleGet() {
 	// Crimson
 }
 
-func ExampleMapKey() {
+func ExampleMyKey() {
 	hello := MyKey("hello")
 	output, _ := Marshal(map[*MyKey]string{&hello: "world"})
 	fmt.Println(string(output))

extension_tests/decoder_test.go

@@ -1,6 +1,7 @@
 package test
 
 import (
+	"bytes"
 	"github.com/json-iterator/go"
 	"github.com/stretchr/testify/require"
 	"strconv"
@@ -98,3 +99,92 @@ func Test_read_custom_interface(t *testing.T) {
 	should.Nil(err)
 	should.Equal("hello", val.Hello())
 }
+
+const flow1 = `
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}`
+
+const flow2 = `
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}
+`
+
+type (
+	Type1 struct {
+		A string
+	}
+
+	Type2 struct {
+		A string
+	}
+)
+
+func (t *Type2) UnmarshalJSON(data []byte) error {
+	return nil
+}
+
+func (t *Type2) MarshalJSON() ([]byte, error) {
+	return nil, nil
+}
+
+func TestType1NoFinalLF(t *testing.T) {
+	reader := bytes.NewReader([]byte(flow1))
+	dec := jsoniter.NewDecoder(reader)
+
+	i := 0
+	for dec.More() {
+		data := &Type1{}
+		if err := dec.Decode(data); err != nil {
+			t.Errorf("at %v got %v", i, err)
+		}
+		i++
+	}
+}
+
+func TestType1FinalLF(t *testing.T) {
+	reader := bytes.NewReader([]byte(flow2))
+	dec := jsoniter.NewDecoder(reader)
+
+	i := 0
+	for dec.More() {
+		data := &Type1{}
+		if err := dec.Decode(data); err != nil {
+			t.Errorf("at %v got %v", i, err)
+		}
+		i++
+	}
+}
+
+func TestType2NoFinalLF(t *testing.T) {
+	reader := bytes.NewReader([]byte(flow1))
+	dec := jsoniter.NewDecoder(reader)
+
+	i := 0
+	for dec.More() {
+		data := &Type2{}
+		if err := dec.Decode(data); err != nil {
+			t.Errorf("at %v got %v", i, err)
+		}
+		i++
+	}
+}
+
+func TestType2FinalLF(t *testing.T) {
+	reader := bytes.NewReader([]byte(flow2))
+	dec := jsoniter.NewDecoder(reader)
+
+	i := 0
+	for dec.More() {
+		data := &Type2{}
+		if err := dec.Decode(data); err != nil {
+			t.Errorf("at %v got %v", i, err)
+		}
+		i++
+	}
+}

extra/binary_as_string_codec.go

@@ -153,7 +153,7 @@ func (codec *binaryAsStringCodec) Decode(ptr unsafe.Pointer, iter *jsoniter.Iter
 			}
 			b4 := rawBytes[i+3]
 			b5 := rawBytes[i+4]
-			i = i + 4
+			i += 4
 			b = readHex(iter, b4, b5)
 		}
 		bytes = append(bytes, b)
@@ -178,7 +178,7 @@ func readHex(iter *jsoniter.Iterator, b1, b2 byte) byte {
 		iter.ReportError("read hex", "expects 0~9 or a~f, but found "+string([]byte{b1}))
 		return 0
 	}
-	ret = ret * 16
+	ret *= 16
 	if b2 >= '0' && b2 <= '9' {
 		ret = b2 - '0'
 	} else if b2 >= 'a' && b2 <= 'f' {

extra/fuzzy_decoder.go

@@ -217,6 +217,9 @@ func (decoder *fuzzyIntegerDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.It
 	default:
 		iter.ReportError("fuzzyIntegerDecoder", "not number or string")
 	}
+	if len(str) == 0 {
+		str = "0"
+	}
 	newIter := iter.Pool().BorrowIterator([]byte(str))
 	defer iter.Pool().ReturnIterator(newIter)
 	isFloat := strings.IndexByte(str, '.') != -1

extra/fuzzy_decoder_test.go

@@ -37,6 +37,8 @@ func Test_any_to_int64(t *testing.T) {
 	should.Equal(int64(10), val)
 	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
 	should.Equal(int64(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`""`, &val))
+	should.Equal(int64(0), val)
 
 	// bool part
 	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))

extra/naming_strategy.go

@@ -2,6 +2,7 @@ package extra
 
 import (
 	"github.com/json-iterator/go"
+	"strings"
 	"unicode"
 )
 
@@ -17,6 +18,16 @@ type namingStrategyExtension struct {
 
 func (extension *namingStrategyExtension) UpdateStructDescriptor(structDescriptor *jsoniter.StructDescriptor) {
 	for _, binding := range structDescriptor.Fields {
+		tag, hastag := binding.Field.Tag().Lookup("json")
+		if hastag {
+			tagParts := strings.Split(tag, ",")
+			if tagParts[0] == "-" {
+				continue // hidden field
+			}
+			if tagParts[0] != "" {
+				continue // field explicitly named
+			}
+		}
 		binding.ToNames = []string{extension.translate(binding.Field.Name())}
 		binding.FromNames = []string{extension.translate(binding.Field.Name())}
 	}

extra/naming_strategy_test.go

@@ -21,3 +21,30 @@ func Test_lower_case_with_underscores(t *testing.T) {
 	should.Nil(err)
 	should.Equal(`{"user_name":"taowen","first_language":"Chinese"}`, string(output))
 }
+
+func Test_set_naming_strategy_with_overrides(t *testing.T) {
+	should := require.New(t)
+	SetNamingStrategy(LowerCaseWithUnderscores)
+	output, err := jsoniter.Marshal(struct {
+		UserName      string `json:"UserName"`
+		FirstLanguage string
+	}{
+		UserName:      "taowen",
+		FirstLanguage: "Chinese",
+	})
+	should.Nil(err)
+	should.Equal(`{"UserName":"taowen","first_language":"Chinese"}`, string(output))
+}
+
+func Test_set_naming_strategy_with_omitempty(t *testing.T) {
+	should := require.New(t)
+	SetNamingStrategy(LowerCaseWithUnderscores)
+	output, err := jsoniter.Marshal(struct {
+		UserName      string
+		FirstLanguage string `json:",omitempty"`
+	}{
+		UserName: "taowen",
+	})
+	should.Nil(err)
+	should.Equal(`{"user_name":"taowen"}`, string(output))
+}

extra/privat_fields.go

@@ -2,6 +2,7 @@ package extra
 
 import (
 	"github.com/json-iterator/go"
+	"strings"
 	"unicode"
 )
 
@@ -18,8 +19,36 @@ func (extension *privateFieldsExtension) UpdateStructDescriptor(structDescriptor
 	for _, binding := range structDescriptor.Fields {
 		isPrivate := unicode.IsLower(rune(binding.Field.Name()[0]))
 		if isPrivate {
-			binding.FromNames = []string{binding.Field.Name()}
-			binding.ToNames = []string{binding.Field.Name()}
+			tag, hastag := binding.Field.Tag().Lookup("json")
+			if !hastag {
+				binding.FromNames = []string{binding.Field.Name()}
+				binding.ToNames = []string{binding.Field.Name()}
+				continue
+			}
+			tagParts := strings.Split(tag, ",")
+			names := calcFieldNames(binding.Field.Name(), tagParts[0], tag)
+			binding.FromNames = names
+			binding.ToNames = names
 		}
 	}
 }
+
+func calcFieldNames(originalFieldName string, tagProvidedFieldName string, wholeTag string) []string {
+	// ignore?
+	if wholeTag == "-" {
+		return []string{}
+	}
+	// rename?
+	var fieldNames []string
+	if tagProvidedFieldName == "" {
+		fieldNames = []string{originalFieldName}
+	} else {
+		fieldNames = []string{tagProvidedFieldName}
+	}
+	// private?
+	isNotExported := unicode.IsLower(rune(originalFieldName[0]))
+	if isNotExported {
+		fieldNames = []string{}
+	}
+	return fieldNames
+}

iter_float.go

@@ -77,14 +77,12 @@ func (iter *Iterator) ReadFloat32() (ret float32) {
 }
 
 func (iter *Iterator) readPositiveFloat32() (ret float32) {
-	value := uint64(0)
-	c := byte(' ')
 	i := iter.head
 	// first char
 	if i == iter.tail {
 		return iter.readFloat32SlowPath()
 	}
-	c = iter.buf[i]
+	c := iter.buf[i]
 	i++
 	ind := floatDigits[c]
 	switch ind {
@@ -107,7 +105,7 @@ func (iter *Iterator) readPositiveFloat32() (ret float32) {
 			return
 		}
 	}
-	value = uint64(ind)
+	value := uint64(ind)
 	// chars before dot
 non_decimal_loop:
 	for ; i < iter.tail; i++ {
@@ -145,9 +143,7 @@ non_decimal_loop:
 				}
 				// too many decimal places
 				return iter.readFloat32SlowPath()
-			case invalidCharForNumber:
-				fallthrough
-			case dotInNumber:
+			case invalidCharForNumber, dotInNumber:
 				return iter.readFloat32SlowPath()
 			}
 			decimalPlaces++
@@ -218,14 +214,12 @@ func (iter *Iterator) ReadFloat64() (ret float64) {
 }
 
 func (iter *Iterator) readPositiveFloat64() (ret float64) {
-	value := uint64(0)
-	c := byte(' ')
 	i := iter.head
 	// first char
 	if i == iter.tail {
 		return iter.readFloat64SlowPath()
 	}
-	c = iter.buf[i]
+	c := iter.buf[i]
 	i++
 	ind := floatDigits[c]
 	switch ind {
@@ -248,7 +242,7 @@ func (iter *Iterator) readPositiveFloat64() (ret float64) {
 			return
 		}
 	}
-	value = uint64(ind)
+	value := uint64(ind)
 	// chars before dot
 non_decimal_loop:
 	for ; i < iter.tail; i++ {
@@ -286,9 +280,7 @@ non_decimal_loop:
 				}
 				// too many decimal places
 				return iter.readFloat64SlowPath()
-			case invalidCharForNumber:
-				fallthrough
-			case dotInNumber:
+			case invalidCharForNumber, dotInNumber:
 				return iter.readFloat64SlowPath()
 			}
 			decimalPlaces++

iter_object.go

@@ -2,7 +2,7 @@ package jsoniter
 
 import (
 	"fmt"
-	"unicode"
+	"strings"
 )
 
 // ReadObject read one field from object.
@@ -60,7 +60,7 @@ func (iter *Iterator) readFieldHash() int64 {
 			if b == '\\' {
 				iter.head = i
 				for _, b := range iter.readStringSlowPath() {
-					if 'A' <= b && b <= 'Z' {
+					if 'A' <= b && b <= 'Z' && !iter.cfg.caseSensitive {
 						b += 'a' - 'A'
 					}
 					hash ^= int64(b)
@@ -82,7 +82,7 @@ func (iter *Iterator) readFieldHash() int64 {
 				}
 				return hash
 			}
-			if 'A' <= b && b <= 'Z' {
+			if 'A' <= b && b <= 'Z' && !iter.cfg.caseSensitive {
 				b += 'a' - 'A'
 			}
 			hash ^= int64(b)
@@ -95,10 +95,13 @@ func (iter *Iterator) readFieldHash() int64 {
 	}
 }
 
-func calcHash(str string) int64 {
+func calcHash(str string, caseSensitive bool) int64 {
+	if !caseSensitive {
+		str = strings.ToLower(str)
+	}
 	hash := int64(0x811c9dc5)
-	for _, b := range str {
-		hash ^= int64(unicode.ToLower(b))
+	for _, b := range []byte(str) {
+		hash ^= int64(b)
 		hash *= 0x1000193
 	}
 	return int64(hash)

iter_skip_strict.go

@@ -2,12 +2,22 @@
 
 package jsoniter
 
-import "fmt"
+import (
+	"fmt"
+	"io"
+)
 
 func (iter *Iterator) skipNumber() {
 	if !iter.trySkipNumber() {
 		iter.unreadByte()
-		iter.ReadFloat32()
+		if iter.Error != nil && iter.Error != io.EOF {
+			return
+		}
+		iter.ReadFloat64()
+		if iter.Error != nil && iter.Error != io.EOF {
+			iter.Error = nil
+			iter.ReadBigFloat()
+		}
 	}
 }
 

misc_tests/jsoniter_array_test.go

@@ -3,9 +3,10 @@ package misc_tests
 import (
 	"bytes"
 	"encoding/json"
+	"testing"
+
 	"github.com/json-iterator/go"
 	"github.com/stretchr/testify/require"
-	"testing"
 )
 
 func Test_empty_array(t *testing.T) {
@@ -168,6 +169,17 @@ func Test_decode_byte_array_from_base64(t *testing.T) {
 	should.Equal([]byte{1, 2, 3}, data)
 }
 
+func Test_decode_byte_array_from_base64_with_newlines(t *testing.T) {
+	should := require.New(t)
+	data := []byte{}
+	err := json.Unmarshal([]byte(`"A\rQ\nID"`), &data)
+	should.Nil(err)
+	should.Equal([]byte{1, 2, 3}, data)
+	err = jsoniter.Unmarshal([]byte(`"A\rQ\nID"`), &data)
+	should.Nil(err)
+	should.Equal([]byte{1, 2, 3}, data)
+}
+
 func Test_decode_byte_array_from_array(t *testing.T) {
 	should := require.New(t)
 	data := []byte{}

misc_tests/jsoniter_interface_test.go

@@ -114,7 +114,7 @@ func Test_overwrite_interface_value_with_nil(t *testing.T) {
 
 	err := json.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
 	should.NoError(err)
-	should.Equal(42, (*(wrapper.Payload.(*Payload))).Value)
+	should.Equal(42, wrapper.Payload.(*Payload).Value)
 
 	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
 	should.NoError(err)
@@ -128,7 +128,7 @@ func Test_overwrite_interface_value_with_nil(t *testing.T) {
 
 	err = jsoniter.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
 	should.Equal(nil, err)
-	should.Equal(42, (*(wrapper.Payload.(*Payload))).Value)
+	should.Equal(42, wrapper.Payload.(*Payload).Value)
 
 	err = jsoniter.Unmarshal([]byte(`{"payload": null}`), &wrapper)
 	should.Equal(nil, err)

pool.go

@@ -23,6 +23,7 @@ func (cfg *frozenConfig) BorrowStream(writer io.Writer) *Stream {
 }
 
 func (cfg *frozenConfig) ReturnStream(stream *Stream) {
+	stream.out = nil
 	stream.Error = nil
 	stream.Attachment = nil
 	cfg.streamPool.Put(stream)

reflect.go

@@ -2,9 +2,10 @@ package jsoniter
 
 import (
 	"fmt"
-	"github.com/modern-go/reflect2"
 	"reflect"
 	"unsafe"
+
+	"github.com/modern-go/reflect2"
 )
 
 // ValDecoder is an internal type registered to cache as needed.
@@ -40,6 +41,14 @@ type ctx struct {
 	decoders map[reflect2.Type]ValDecoder
 }
 
+func (b *ctx) caseSensitive() bool {
+	if b.frozenConfig == nil {
+		// default is case-insensitive
+		return false
+	}
+	return b.frozenConfig.caseSensitive
+}
+
 func (b *ctx) append(prefix string) *ctx {
 	return &ctx{
 		frozenConfig: b.frozenConfig,
@@ -111,7 +120,8 @@ func decoderOfType(ctx *ctx, typ reflect2.Type) ValDecoder {
 	for _, extension := range extensions {
 		decoder = extension.DecorateDecoder(typ, decoder)
 	}
-	for _, extension := range ctx.extensions {
+	decoder = ctx.decoderExtension.DecorateDecoder(typ, decoder)
+	for _, extension := range ctx.extraExtensions {
 		decoder = extension.DecorateDecoder(typ, decoder)
 	}
 	return decoder
@@ -213,7 +223,8 @@ func encoderOfType(ctx *ctx, typ reflect2.Type) ValEncoder {
 	for _, extension := range extensions {
 		encoder = extension.DecorateEncoder(typ, encoder)
 	}
-	for _, extension := range ctx.extensions {
+	encoder = ctx.encoderExtension.DecorateEncoder(typ, encoder)
+	for _, extension := range ctx.extraExtensions {
 		encoder = extension.DecorateEncoder(typ, encoder)
 	}
 	return encoder

reflect_extension.go

@@ -246,7 +246,8 @@ func getTypeDecoderFromExtension(ctx *ctx, typ reflect2.Type) ValDecoder {
 		for _, extension := range extensions {
 			decoder = extension.DecorateDecoder(typ, decoder)
 		}
-		for _, extension := range ctx.extensions {
+		decoder = ctx.decoderExtension.DecorateDecoder(typ, decoder)
+		for _, extension := range ctx.extraExtensions {
 			decoder = extension.DecorateDecoder(typ, decoder)
 		}
 	}
@@ -259,14 +260,18 @@ func _getTypeDecoderFromExtension(ctx *ctx, typ reflect2.Type) ValDecoder {
 			return decoder
 		}
 	}
-	for _, extension := range ctx.extensions {
+	decoder := ctx.decoderExtension.CreateDecoder(typ)
+	if decoder != nil {
+		return decoder
+	}
+	for _, extension := range ctx.extraExtensions {
 		decoder := extension.CreateDecoder(typ)
 		if decoder != nil {
 			return decoder
 		}
 	}
 	typeName := typ.String()
-	decoder := typeDecoders[typeName]
+	decoder = typeDecoders[typeName]
 	if decoder != nil {
 		return decoder
 	}
@@ -286,7 +291,8 @@ func getTypeEncoderFromExtension(ctx *ctx, typ reflect2.Type) ValEncoder {
 		for _, extension := range extensions {
 			encoder = extension.DecorateEncoder(typ, encoder)
 		}
-		for _, extension := range ctx.extensions {
+		encoder = ctx.encoderExtension.DecorateEncoder(typ, encoder)
+		for _, extension := range ctx.extraExtensions {
 			encoder = extension.DecorateEncoder(typ, encoder)
 		}
 	}
@@ -300,14 +306,18 @@ func _getTypeEncoderFromExtension(ctx *ctx, typ reflect2.Type) ValEncoder {
 			return encoder
 		}
 	}
-	for _, extension := range ctx.extensions {
+	encoder := ctx.encoderExtension.CreateEncoder(typ)
+	if encoder != nil {
+		return encoder
+	}
+	for _, extension := range ctx.extraExtensions {
 		encoder := extension.CreateEncoder(typ)
 		if encoder != nil {
 			return encoder
 		}
 	}
 	typeName := typ.String()
-	encoder := typeEncoders[typeName]
+	encoder = typeEncoders[typeName]
 	if encoder != nil {
 		return encoder
 	}
@@ -328,7 +338,7 @@ func describeStruct(ctx *ctx, typ reflect2.Type) *StructDescriptor {
 	for i := 0; i < structType.NumField(); i++ {
 		field := structType.Field(i)
 		tag, hastag := field.Tag().Lookup(ctx.getTagKey())
-		if ctx.onlyTaggedField && !hastag {
+		if ctx.onlyTaggedField && !hastag && !field.Anonymous() {
 			continue
 		}
 		tagParts := strings.Split(tag, ",")
@@ -393,7 +403,9 @@ func createStructDescriptor(ctx *ctx, typ reflect2.Type, bindings []*Binding, em
 	for _, extension := range extensions {
 		extension.UpdateStructDescriptor(structDescriptor)
 	}
-	for _, extension := range ctx.extensions {
+	ctx.encoderExtension.UpdateStructDescriptor(structDescriptor)
+	ctx.decoderExtension.UpdateStructDescriptor(structDescriptor)
+	for _, extension := range ctx.extraExtensions {
 		extension.UpdateStructDescriptor(structDescriptor)
 	}
 	processTags(structDescriptor, ctx.frozenConfig)

reflect_map.go

@@ -39,7 +39,11 @@ func encoderOfMap(ctx *ctx, typ reflect2.Type) ValEncoder {
 }
 
 func decoderOfMapKey(ctx *ctx, typ reflect2.Type) ValDecoder {
-	for _, extension := range ctx.extensions {
+	decoder := ctx.decoderExtension.CreateMapKeyDecoder(typ)
+	if decoder != nil {
+		return decoder
+	}
+	for _, extension := range ctx.extraExtensions {
 		decoder := extension.CreateMapKeyDecoder(typ)
 		if decoder != nil {
 			return decoder
@@ -60,14 +64,26 @@ func decoderOfMapKey(ctx *ctx, typ reflect2.Type) ValDecoder {
 		return &numericMapKeyDecoder{decoderOfType(ctx, typ)}
 	default:
 		ptrType := reflect2.PtrTo(typ)
-		if ptrType.Implements(textMarshalerType) {
+		if ptrType.Implements(unmarshalerType) {
+			return &referenceDecoder{
+				&unmarshalerDecoder{
+					valType: ptrType,
+				},
+			}
+		}
+		if typ.Implements(unmarshalerType) {
+			return &unmarshalerDecoder{
+				valType: typ,
+			}
+		}
+		if ptrType.Implements(textUnmarshalerType) {
 			return &referenceDecoder{
 				&textUnmarshalerDecoder{
 					valType: ptrType,
 				},
 			}
 		}
-		if typ.Implements(textMarshalerType) {
+		if typ.Implements(textUnmarshalerType) {
 			return &textUnmarshalerDecoder{
 				valType: typ,
 			}
@@ -77,7 +93,11 @@ func decoderOfMapKey(ctx *ctx, typ reflect2.Type) ValDecoder {
 }
 
 func encoderOfMapKey(ctx *ctx, typ reflect2.Type) ValEncoder {
-	for _, extension := range ctx.extensions {
+	encoder := ctx.encoderExtension.CreateMapKeyEncoder(typ)
+	if encoder != nil {
+		return encoder
+	}
+	for _, extension := range ctx.extraExtensions {
 		encoder := extension.CreateMapKeyEncoder(typ)
 		if encoder != nil {
 			return encoder

reflect_marshaler.go

@@ -93,8 +93,7 @@ func (encoder *marshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
 		stream.WriteNil()
 		return
 	}
-	marshaler := obj.(json.Marshaler)
-	bytes, err := marshaler.MarshalJSON()
+	bytes, err := json.Marshal(obj)
 	if err != nil {
 		stream.Error = err
 	} else {

reflect_native.go

@@ -2,10 +2,11 @@ package jsoniter
 
 import (
 	"encoding/base64"
-	"github.com/modern-go/reflect2"
 	"reflect"
 	"strconv"
 	"unsafe"
+
+	"github.com/modern-go/reflect2"
 )
 
 const ptrSize = 32 << uintptr(^uintptr(0)>>63)
@@ -416,16 +417,11 @@ func (codec *base64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
 	}
 	switch iter.WhatIsNext() {
 	case StringValue:
-		encoding := base64.StdEncoding
-		src := iter.SkipAndReturnBytes()
-		src = src[1 : len(src)-1]
-		decodedLen := encoding.DecodedLen(len(src))
-		dst := make([]byte, decodedLen)
-		len, err := encoding.Decode(dst, src)
+		src := iter.ReadString()
+		dst, err := base64.StdEncoding.DecodeString(src)
 		if err != nil {
 			iter.ReportError("decode base64", err.Error())
 		} else {
-			dst = dst[:len]
 			codec.sliceType.UnsafeSet(ptr, unsafe.Pointer(&dst))
 		}
 	case ArrayValue:

reflect_struct_decoder.go

@@ -2,10 +2,11 @@ package jsoniter
 
 import (
 	"fmt"
-	"github.com/modern-go/reflect2"
 	"io"
 	"strings"
 	"unsafe"
+
+	"github.com/modern-go/reflect2"
 )
 
 func decoderOfStruct(ctx *ctx, typ reflect2.Type) ValDecoder {
@@ -31,6 +32,15 @@ func decoderOfStruct(ctx *ctx, typ reflect2.Type) ValDecoder {
 	for k, binding := range bindings {
 		fields[k] = binding.Decoder.(*structFieldDecoder)
 	}
+
+	if !ctx.caseSensitive() {
+		for k, binding := range bindings {
+			if _, found := fields[strings.ToLower(k)]; !found {
+				fields[strings.ToLower(k)] = binding.Decoder.(*structFieldDecoder)
+			}
+		}
+	}
+
 	return createStructDecoder(ctx, typ, fields)
 }
 
@@ -41,12 +51,13 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
 	knownHash := map[int64]struct{}{
 		0: {},
 	}
+
 	switch len(fields) {
 	case 0:
 		return &skipObjectDecoder{typ}
 	case 1:
 		for fieldName, fieldDecoder := range fields {
-			fieldHash := calcHash(fieldName)
+			fieldHash := calcHash(fieldName, ctx.caseSensitive())
 			_, known := knownHash[fieldHash]
 			if known {
 				return &generalStructDecoder{typ, fields, false}
@@ -60,7 +71,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
 		var fieldDecoder1 *structFieldDecoder
 		var fieldDecoder2 *structFieldDecoder
 		for fieldName, fieldDecoder := range fields {
-			fieldHash := calcHash(fieldName)
+			fieldHash := calcHash(fieldName, ctx.caseSensitive())
 			_, known := knownHash[fieldHash]
 			if known {
 				return &generalStructDecoder{typ, fields, false}
@@ -83,7 +94,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
 		var fieldDecoder2 *structFieldDecoder
 		var fieldDecoder3 *structFieldDecoder
 		for fieldName, fieldDecoder := range fields {
-			fieldHash := calcHash(fieldName)
+			fieldHash := calcHash(fieldName, ctx.caseSensitive())
 			_, known := knownHash[fieldHash]
 			if known {
 				return &generalStructDecoder{typ, fields, false}
@@ -114,7 +125,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
 		var fieldDecoder3 *structFieldDecoder
 		var fieldDecoder4 *structFieldDecoder
 		for fieldName, fieldDecoder := range fields {
-			fieldHash := calcHash(fieldName)
+			fieldHash := calcHash(fieldName, ctx.caseSensitive())
 			_, known := knownHash[fieldHash]
 			if known {
 				return &generalStructDecoder{typ, fields, false}
@@ -151,7 +162,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
 		var fieldDecoder4 *structFieldDecoder
 		var fieldDecoder5 *structFieldDecoder
 		for fieldName, fieldDecoder := range fields {
-			fieldHash := calcHash(fieldName)
+			fieldHash := calcHash(fieldName, ctx.caseSensitive())
 			_, known := knownHash[fieldHash]
 			if known {
 				return &generalStructDecoder{typ, fields, false}
@@ -194,7 +205,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
 		var fieldDecoder5 *structFieldDecoder
 		var fieldDecoder6 *structFieldDecoder
 		for fieldName, fieldDecoder := range fields {
-			fieldHash := calcHash(fieldName)
+			fieldHash := calcHash(fieldName, ctx.caseSensitive())
 			_, known := knownHash[fieldHash]
 			if known {
 				return &generalStructDecoder{typ, fields, false}
@@ -243,7 +254,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
 		var fieldDecoder6 *structFieldDecoder
 		var fieldDecoder7 *structFieldDecoder
 		for fieldName, fieldDecoder := range fields {
-			fieldHash := calcHash(fieldName)
+			fieldHash := calcHash(fieldName, ctx.caseSensitive())
 			_, known := knownHash[fieldHash]
 			if known {
 				return &generalStructDecoder{typ, fields, false}
@@ -298,7 +309,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
 		var fieldDecoder7 *structFieldDecoder
 		var fieldDecoder8 *structFieldDecoder
 		for fieldName, fieldDecoder := range fields {
-			fieldHash := calcHash(fieldName)
+			fieldHash := calcHash(fieldName, ctx.caseSensitive())
 			_, known := knownHash[fieldHash]
 			if known {
 				return &generalStructDecoder{typ, fields, false}
@@ -359,7 +370,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
 		var fieldDecoder8 *structFieldDecoder
 		var fieldDecoder9 *structFieldDecoder
 		for fieldName, fieldDecoder := range fields {
-			fieldHash := calcHash(fieldName)
+			fieldHash := calcHash(fieldName, ctx.caseSensitive())
 			_, known := knownHash[fieldHash]
 			if known {
 				return &generalStructDecoder{typ, fields, false}
@@ -426,7 +437,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
 		var fieldDecoder9 *structFieldDecoder
 		var fieldDecoder10 *structFieldDecoder
 		for fieldName, fieldDecoder := range fields {
-			fieldHash := calcHash(fieldName)
+			fieldHash := calcHash(fieldName, ctx.caseSensitive())
 			_, known := knownHash[fieldHash]
 			if known {
 				return &generalStructDecoder{typ, fields, false}
@@ -489,13 +500,16 @@ func (decoder *generalStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator)
 	if !iter.readObjectStart() {
 		return
 	}
-	decoder.decodeOneField(ptr, iter)
-	for iter.nextToken() == ',' {
+	var c byte
+	for c = ','; c == ','; c = iter.nextToken() {
 		decoder.decodeOneField(ptr, iter)
 	}
 	if iter.Error != nil && iter.Error != io.EOF {
 		iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
 	}
+	if c != '}' {
+		iter.ReportError("struct Decode", `expect }, but found `+string([]byte{c}))
+	}
 }
 
 func (decoder *generalStructDecoder) decodeOneField(ptr unsafe.Pointer, iter *Iterator) {
@@ -505,13 +519,13 @@ func (decoder *generalStructDecoder) decodeOneField(ptr unsafe.Pointer, iter *It
 		fieldBytes := iter.ReadStringAsSlice()
 		field = *(*string)(unsafe.Pointer(&fieldBytes))
 		fieldDecoder = decoder.fields[field]
-		if fieldDecoder == nil {
+		if fieldDecoder == nil && !iter.cfg.caseSensitive {
 			fieldDecoder = decoder.fields[strings.ToLower(field)]
 		}
 	} else {
 		field = iter.ReadString()
 		fieldDecoder = decoder.fields[field]
-		if fieldDecoder == nil {
+		if fieldDecoder == nil && !iter.cfg.caseSensitive {
 			fieldDecoder = decoder.fields[strings.ToLower(field)]
 		}
 	}

skip_tests/struct_test.go

@@ -13,7 +13,7 @@ func init() {
 			`{"hello":{}}`,               // valid
 			`{"hello":{}}}`,              // invalid
 			`{"hello":  {  "hello": 1}}`, // valid
-			`{abc}`, // invalid
+			`{abc}`,                      // invalid
 		},
 	})
 }

type_tests/struct_tags_test.go

@@ -145,6 +145,9 @@ func init() {
 		(*struct {
 			Field bool `json:",omitempty,string"`
 		})(nil),
+		(*struct {
+			Field bool `json:"中文"`
+		})(nil),
 	)
 }
 

value_tests/error_test.go

@@ -0,0 +1,36 @@
+package test
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"reflect"
+	"testing"
+)
+
+func Test_errorInput(t *testing.T) {
+	for _, testCase := range unmarshalCases {
+		if testCase.obj != nil {
+			continue
+		}
+		valType := reflect.TypeOf(testCase.ptr).Elem()
+		t.Run(valType.String(), func(t *testing.T) {
+			for _, data := range []string{
+				`x`,
+				`n`,
+				`nul`,
+				`{x}`,
+				`{"x"}`,
+				`{"x": "y"x}`,
+				`{"x": "y"`,
+				`{"x": "y", "a"}`,
+				`[`,
+				`[{"x": "y"}`,
+			} {
+				ptrVal := reflect.New(valType)
+				ptr := ptrVal.Interface()
+				err := jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal([]byte(data), ptr)
+				require.Error(t, err, "on input %q", data)
+			}
+		})
+	}
+}

value_tests/invalid_test.go

@@ -224,3 +224,13 @@ func Test_EmptyInput(t *testing.T) {
 		t.Errorf("Expected error")
 	}
 }
+
+type Foo struct {
+	A jsoniter.Any
+}
+
+func Test_nil_any(t *testing.T) {
+	should := require.New(t)
+	data, _ := jsoniter.Marshal(&Foo{})
+	should.Equal(`{"A":null}`, string(data))
+}

value_tests/map_test.go

@@ -2,7 +2,9 @@ package test
 
 import (
 	"encoding/json"
+	"fmt"
 	"math/big"
+	"time"
 )
 
 func init() {
@@ -27,6 +29,8 @@ func init() {
 		nilMap,
 		&nilMap,
 		map[string]*json.RawMessage{"hello": pRawMessage(json.RawMessage("[]"))},
+		map[Date]bool{{}: true},
+		map[Date2]bool{{}: true},
 	)
 	unmarshalCases = append(unmarshalCases, unmarshalCase{
 		ptr:   (*map[string]string)(nil),
@@ -37,6 +41,20 @@ func init() {
 	}, unmarshalCase{
 		ptr:   (*map[string]*json.RawMessage)(nil),
 		input: "{\"test\":[{\"key\":\"value\"}]}",
+	}, unmarshalCase{
+		ptr: (*map[Date]bool)(nil),
+		input: `{
+        "2018-12-12": true,
+        "2018-12-13": true,
+        "2018-12-14": true
+    	}`,
+	}, unmarshalCase{
+		ptr: (*map[Date2]bool)(nil),
+		input: `{
+        "2018-12-12": true,
+        "2018-12-13": true,
+        "2018-12-14": true
+    	}`,
 	})
 }
 
@@ -49,3 +67,51 @@ type MyString string
 func (ms MyString) Hello() string {
 	return string(ms)
 }
+
+type Date struct {
+	time.Time
+}
+
+func (d *Date) UnmarshalJSON(b []byte) error {
+	dateStr := string(b) // something like `"2017-08-20"`
+
+	if dateStr == "null" {
+		return nil
+	}
+
+	t, err := time.Parse(`"2006-01-02"`, dateStr)
+	if err != nil {
+		return fmt.Errorf("cant parse date: %#v", err)
+	}
+
+	d.Time = t
+	return nil
+}
+
+func (d *Date) MarshalJSON() ([]byte, error) {
+	return []byte(d.Time.Format("2006-01-02")), nil
+}
+
+type Date2 struct {
+	time.Time
+}
+
+func (d Date2) UnmarshalJSON(b []byte) error {
+	dateStr := string(b) // something like `"2017-08-20"`
+
+	if dateStr == "null" {
+		return nil
+	}
+
+	t, err := time.Parse(`"2006-01-02"`, dateStr)
+	if err != nil {
+		return fmt.Errorf("cant parse date: %#v", err)
+	}
+
+	d.Time = t
+	return nil
+}
+
+func (d Date2) MarshalJSON() ([]byte, error) {
+	return []byte(d.Time.Format("2006-01-02")), nil
+}

value_tests/raw_message_test.go

@@ -1,13 +1,24 @@
 package test
 
-import "encoding/json"
+import (
+	"encoding/json"
+)
 
 func init() {
 	marshalCases = append(marshalCases,
 		json.RawMessage("{}"),
+		struct {
+			Env   string          `json:"env"`
+			Extra json.RawMessage `json:"extra,omitempty"`
+		}{
+			Env: "jfdk",
+		},
 	)
 	unmarshalCases = append(unmarshalCases, unmarshalCase{
 		ptr:   (*json.RawMessage)(nil),
 		input: `[1,2,3]`,
+	}, unmarshalCase{
+		ptr:   (*json.RawMessage)(nil),
+		input: `1.122e+250`,
 	})
 }

value_tests/slice_test.go

@@ -20,5 +20,8 @@ func init() {
 	}, unmarshalCase{
 		ptr:   (*[]byte)(nil),
 		input: `"aGVsbG8="`,
+	}, unmarshalCase{
+		ptr:   (*[]byte)(nil),
+		input: `"c3ViamVjdHM\/X2Q9MQ=="`,
 	})
 }

value_tests/struct_test.go

@@ -63,6 +63,43 @@ func init() {
 			d *time.Timer
 		})(nil),
 		input: `{"a": 444, "b":"bad", "C":256, "d":{"not":"a timer"}}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			A string
+			B string
+			C string
+			D string
+			E string
+			F string
+			G string
+			H string
+			I string
+			J string
+			K string
+		})(nil),
+		input: `{"a":"1","b":"2","c":"3","d":"4","e":"5","f":"6","g":"7","h":"8","i":"9","j":"10","k":"11"}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			T float64 `json:"T"`
+		})(nil),
+		input: `{"t":10.0}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			T float64 `json:"T"`
+		})(nil),
+		input: `{"T":10.0}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			T float64 `json:"t"`
+		})(nil),
+		input: `{"T":10.0}`,
+	}, unmarshalCase{
+		ptr: (*struct {
+			KeyString string       `json:"key_string"`
+			Type      string       `json:"type"`
+			Asks      [][2]float64 `json:"asks"`
+		})(nil),
+		input: `{"key_string": "KEYSTRING","type": "TYPE","asks": [[1e+66,1]]}`,
 	})
 	marshalCases = append(marshalCases,
 		struct {