Merge branch 'master' of https://github.com/francoispqt/gojay

README.md

@@ -397,7 +397,7 @@ func main() {
 
 Unsafe API has the same functions than the regular API, it only has `Unmarshal API` for now. It is unsafe because it makes assumptions on the quality of the given JSON. 
 
-If you are not sure if you're JSON is valid, don't use the Unsafe API. 
+If you are not sure if your JSON is valid, don't use the Unsafe API. 
 
 Also, the `Unsafe` API does not copy the buffer when using Unmarshal API, which, in case of string decoding, can lead to data corruption if a byte buffer is reused. Using the `Decode` API makes `Unsafe` API safer as the io.Reader relies on `copy` builtin method and `Decoder` will have its own internal buffer :) 
 

decode.go

@@ -13,7 +13,7 @@ import (
 // If a JSON value is not appropriate for a given target type, or if a JSON number
 // overflows the target type, UnmarshalArray skips that field and completes the unmarshaling as best it can.
 func UnmarshalArray(data []byte, v UnmarshalerArray) error {
-	dec := BorrowDecoder(nil)
+	dec := borrowDecoder(nil, 0)
 	defer dec.Release()
 	dec.data = make([]byte, len(data))
 	copy(dec.data, data)
@@ -35,7 +35,7 @@ func UnmarshalArray(data []byte, v UnmarshalerArray) error {
 // If a JSON value is not appropriate for a given target type, or if a JSON number
 // overflows the target type, UnmarshalObject skips that field and completes the unmarshaling as best it can.
 func UnmarshalObject(data []byte, v UnmarshalerObject) error {
-	dec := BorrowDecoder(nil)
+	dec := borrowDecoder(nil, 0)
 	defer dec.Release()
 	dec.data = make([]byte, len(data))
 	copy(dec.data, data)
@@ -73,53 +73,53 @@ func Unmarshal(data []byte, v interface{}) error {
 	var dec *Decoder
 	switch vt := v.(type) {
 	case *string:
-		dec = BorrowDecoder(nil)
+		dec = borrowDecoder(nil, 0)
 		dec.length = len(data)
 		dec.data = data
 		err = dec.decodeString(vt)
 	case *int:
-		dec = BorrowDecoder(nil)
+		dec = borrowDecoder(nil, 0)
 		dec.length = len(data)
 		dec.data = data
 		err = dec.decodeInt(vt)
 	case *int32:
-		dec = BorrowDecoder(nil)
+		dec = borrowDecoder(nil, 0)
 		dec.length = len(data)
 		dec.data = data
 		err = dec.decodeInt32(vt)
 	case *uint32:
-		dec = BorrowDecoder(nil)
+		dec = borrowDecoder(nil, 0)
 		dec.length = len(data)
 		dec.data = data
 		err = dec.decodeUint32(vt)
 	case *int64:
-		dec = BorrowDecoder(nil)
+		dec = borrowDecoder(nil, 0)
 		dec.length = len(data)
 		dec.data = data
 		err = dec.decodeInt64(vt)
 	case *uint64:
-		dec = BorrowDecoder(nil)
+		dec = borrowDecoder(nil, 0)
 		dec.length = len(data)
 		dec.data = data
 		err = dec.decodeUint64(vt)
 	case *float64:
-		dec = BorrowDecoder(nil)
+		dec = borrowDecoder(nil, 0)
 		dec.length = len(data)
 		dec.data = data
 		err = dec.decodeFloat64(vt)
 	case *bool:
-		dec = BorrowDecoder(nil)
+		dec = borrowDecoder(nil, 0)
 		dec.length = len(data)
 		dec.data = data
 		err = dec.decodeBool(vt)
 	case UnmarshalerObject:
-		dec = BorrowDecoder(nil)
+		dec = borrowDecoder(nil, 0)
 		dec.length = len(data)
 		dec.data = make([]byte, len(data))
 		copy(dec.data, data)
 		_, err = dec.decodeObject(vt)
 	case UnmarshalerArray:
-		dec = BorrowDecoder(nil)
+		dec = borrowDecoder(nil, 0)
 		dec.length = len(data)
 		dec.data = make([]byte, len(data))
 		copy(dec.data, data)

decode_array.go

@@ -71,7 +71,7 @@ func (dec *Decoder) skipArray() (int, error) {
 	var arraysOpen = 1
 	var arraysClosed = 0
 	// var stringOpen byte = 0
-	for j := dec.cursor; j < dec.length; j++ {
+	for j := dec.cursor; j < dec.length || dec.read(); j++ {
 		switch dec.data[j] {
 		case ']':
 			arraysClosed++
@@ -94,7 +94,7 @@ func (dec *Decoder) skipArray() (int, error) {
 				// loop backward and count how many anti slash found
 				// to see if string is effectively escaped
 				ct := 1
-				for i := j; i > 0; i-- {
+				for i := j - 2; i > 0; i-- {
 					if dec.data[i] != '\\' {
 						break
 					}

decode_array_test.go

@@ -189,3 +189,38 @@ func TestDecoderSliceDecoderAPIError(t *testing.T) {
 	assert.NotNil(t, err, "Err must not be nil as JSON is invalid")
 	assert.IsType(t, InvalidJSONError(""), err, "err message must be 'Invalid JSON'")
 }
+
+func TestSkipArray(t *testing.T) {
+	testCases := []struct {
+		json         string
+		expectations func(*testing.T, int, error)
+	}{
+		{
+			json: `"testbasic"]`,
+			expectations: func(t *testing.T, i int, err error) {
+				assert.Equal(t, len(`"testbasic"]`), i)
+				assert.Nil(t, err)
+			},
+		},
+		{
+			json: `"test \\\\\" escape"]`,
+			expectations: func(t *testing.T, i int, err error) {
+				assert.Equal(t, len(`"test \\\\\" escape"]`), i)
+				assert.Nil(t, err)
+			},
+		},
+		{
+			json: `"test \\\\\\"]`,
+			expectations: func(t *testing.T, i int, err error) {
+				assert.Equal(t, len(`"test \\\\\\"]`), i)
+				assert.Nil(t, err)
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		dec := NewDecoder(strings.NewReader(test.json))
+		i, err := dec.skipArray()
+		test.expectations(t, i, err)
+	}
+}

decode_number.go

@@ -581,7 +581,7 @@ func (dec *Decoder) atoi32(start, end int) int32 {
 		for i := start + 1; i < end; i++ {
 			intv := int32(digits[dec.data[i]])
 			if val > maxInt32toMultiply {
-				dec.err = InvalidTypeError("Overflows int321")
+				dec.err = InvalidTypeError("Overflows int32")
 				return 0
 			}
 			val = (val << 3) + (val << 1)

decode_number_test.go

@@ -15,12 +15,19 @@ func TestDecoderIntBasic(t *testing.T) {
 	assert.Equal(t, 124, v, "v must be equal to 124")
 }
 func TestDecoderIntNegative(t *testing.T) {
-	json := []byte(`-124`)
+	json := []byte(` -124 `)
 	var v int
 	err := Unmarshal(json, &v)
 	assert.Nil(t, err, "Err must be nil")
 	assert.Equal(t, -124, v, "v must be equal to -124")
 }
+func TestDecoderIntNegativeError(t *testing.T) {
+	json := []byte(` -12x4 `)
+	var v int
+	err := Unmarshal(json, &v)
+	assert.NotNil(t, err, "Err must be nil")
+	assert.IsType(t, InvalidJSONError(""), err, "err must be of type InvalidJSONError")
+}
 func TestDecoderIntNull(t *testing.T) {
 	json := []byte(`null`)
 	var v int
@@ -56,6 +63,20 @@ func TestDecoderIntOverfow(t *testing.T) {
 	assert.NotNil(t, err, "Err must not be nil as int is overflowing")
 	assert.Equal(t, 0, v, "v must be equal to 0")
 }
+func TestDecoderIntOverfow2(t *testing.T) {
+	json := []byte(`92233720368547758089 `)
+	var v int
+	err := Unmarshal(json, &v)
+	assert.NotNil(t, err, "Err must not be nil as int is overflowing")
+	assert.Equal(t, 0, v, "v must be equal to 0")
+}
+func TestDecoderIntOverfow3(t *testing.T) {
+	json := []byte(`92233720368547758089 `)
+	var v int
+	err := Unmarshal(json, &v)
+	assert.NotNil(t, err, "Err must not be nil as int is overflowing")
+	assert.Equal(t, 0, v, "v must be equal to 0")
+}
 func TestDecoderIntPoolError(t *testing.T) {
 	result := int(1)
 	dec := NewDecoder(nil)
@@ -68,13 +89,6 @@ func TestDecoderIntPoolError(t *testing.T) {
 	_ = dec.DecodeInt(&result)
 	assert.True(t, false, "should not be called as decoder should have panicked")
 }
-func TestDecoderIntOverfow2(t *testing.T) {
-	json := []byte(`92233720368547758089`)
-	var v int
-	err := Unmarshal(json, &v)
-	assert.NotNil(t, err, "Err must not be nil as int is overflowing")
-	assert.Equal(t, 0, v, "v must be equal to 0")
-}
 func TestDecoderInttDecoderAPI(t *testing.T) {
 	var v int
 	dec := NewDecoder(strings.NewReader(`33`))
@@ -92,12 +106,19 @@ func TestDecoderInt32Basic(t *testing.T) {
 	assert.Equal(t, int32(124), v, "v must be equal to 124")
 }
 func TestDecoderInt32Negative(t *testing.T) {
-	json := []byte(`-124`)
+	json := []byte(`-124 `)
 	var v int32
 	err := Unmarshal(json, &v)
 	assert.Nil(t, err, "Err must be nil")
 	assert.Equal(t, int32(-124), v, "v must be equal to -124")
 }
+func TestDecoderInt32NegativeError(t *testing.T) {
+	json := []byte(`-12x4 `)
+	var v int32
+	err := Unmarshal(json, &v)
+	assert.NotNil(t, err, "Err must be nil")
+	assert.IsType(t, InvalidJSONError(""), err, "err must be of type InvalidJSONError")
+}
 func TestDecoderInt32Null(t *testing.T) {
 	json := []byte(`null`)
 	var v int32
@@ -127,7 +148,7 @@ func TestDecoderInt32Big(t *testing.T) {
 	assert.Equal(t, int32(2147483647), v, "int32 must be equal to 2147483647")
 }
 func TestDecoderInt32Overflow(t *testing.T) {
-	json := []byte(`2147483648`)
+	json := []byte(` 2147483648`)
 	var v int32
 	err := Unmarshal(json, &v)
 	assert.NotNil(t, err, "err must not be nil as int32 overflows")
@@ -162,7 +183,7 @@ func TestDecoderInt32tDecoderAPI(t *testing.T) {
 }
 
 func TestDecoderUint32Basic(t *testing.T) {
-	json := []byte(`124`)
+	json := []byte(`124 `)
 	var v uint32
 	err := Unmarshal(json, &v)
 	assert.Nil(t, err, "Err must be nil")
@@ -190,7 +211,7 @@ func TestDecoderUint32InvalidJSON(t *testing.T) {
 	assert.IsType(t, InvalidJSONError(""), err, "err must be of type InvalidJSONError")
 }
 func TestDecoderUint32Big(t *testing.T) {
-	json := []byte(`4294967295`)
+	json := []byte(`4294967295 `)
 	var v uint32
 	err := Unmarshal(json, &v)
 	assert.Nil(t, err, "err must not be nil as uint32 does not overflow")
@@ -233,7 +254,7 @@ func TestDecoderUint32tDecoderAPI(t *testing.T) {
 }
 
 func TestDecoderInt64Basic(t *testing.T) {
-	json := []byte(`124`)
+	json := []byte(`124 `)
 	var v int64
 	err := Unmarshal(json, &v)
 	assert.Nil(t, err, "Err must be nil")
@@ -309,7 +330,7 @@ func TestDecoderInt64tDecoderAPI(t *testing.T) {
 	assert.Equal(t, int64(33), v, "v must be equal to 33")
 }
 func TestDecoderUint64Basic(t *testing.T) {
-	json := []byte(`124`)
+	json := []byte(` 124 `)
 	var v uint64
 	err := Unmarshal(json, &v)
 	assert.Nil(t, err, "Err must be nil")
@@ -378,15 +399,29 @@ func TestDecoderUint64tDecoderAPI(t *testing.T) {
 	assert.Equal(t, uint64(33), v, "v must be equal to 33")
 }
 func TestDecoderFloatBasic(t *testing.T) {
-	json := []byte(`100.11`)
+	json := []byte(`100.11 `)
 	var v float64
 	err := Unmarshal(json, &v)
 	assert.Nil(t, err, "Err must be nil")
 	assert.Equal(t, 100.11, v, "v must be equal to 100.11")
 }
+func TestDecoderFloatBasic2(t *testing.T) {
+	json := []byte(` 100.11 `)
+	var v float64
+	err := Unmarshal(json, &v)
+	assert.Nil(t, err, "Err must be nil")
+	assert.Equal(t, 100.11, v, "v must be equal to 100.11")
+}
+func TestDecoderFloatBasic3(t *testing.T) {
+	json := []byte(` 100 `)
+	var v float64
+	err := Unmarshal(json, &v)
+	assert.Nil(t, err, "Err must be nil")
+	assert.Equal(t, float64(100), v, "v must be equal to 100.11")
+}
 
 func TestDecoderFloatBig(t *testing.T) {
-	json := []byte(`89899843.3493493`)
+	json := []byte(`89899843.3493493 `)
 	var v float64
 	err := Unmarshal(json, &v)
 	assert.Nil(t, err, "Err must be nil")

decode_object.go

@@ -18,9 +18,6 @@ func (dec *Decoder) DecodeObject(j UnmarshalerObject) error {
 	return err
 }
 func (dec *Decoder) decodeObject(j UnmarshalerObject) (int, error) {
-	if dec.isPooled == 1 {
-		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
-	}
 	keys := j.NKeys()
 	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
 		switch dec.data[dec.cursor] {

decode_object_test.go

@@ -154,8 +154,13 @@ func TestDecodeObjectNull(t *testing.T) {
 var jsonComplex = []byte(`{
 	"test": "{\"test\":\"1\",\"test1\":2}",
 	"test2\\n": "\\\\\\\\\\\n",
-	"testArrSkip": ["testString with escaped \" quotes"],
+	"testArrSkip": ["testString with escaped \\\" quotes"],
 	"testSkipString": "skip \\ string with \\n escaped char \" ",
+	"testSkipObject": {
+		"testSkipSubObj": {
+			"test": "test"
+		}
+	},
 	"testSkipNumber": 123.23,
 	"testBool": true,
 	"testSub": {
@@ -210,7 +215,7 @@ func TestDecodeObjComplex(t *testing.T) {
 	result := jsonObjectComplex{}
 	err := UnmarshalObject(jsonComplex, &result)
 	assert.NotNil(t, err, "err should not be as invalid type as been encountered nil")
-	assert.Equal(t, `Cannot unmarshal to struct, wrong char '"' found at pos 460`, err.Error(), "err should not be as invalid type as been encountered nil")
+	assert.Equal(t, `Cannot unmarshal to struct, wrong char '"' found at pos 531`, err.Error(), "err should not be as invalid type as been encountered nil")
 	assert.Equal(t, `{"test":"1","test1":2}`, result.Test, "result.Test is not expected value")
 	assert.Equal(t, `\\\\\\n`, result.Test2, "result.Test2 is not expected value")
 	assert.Equal(t, 1, result.Test3, "result.test3 is not expected value")

decode_stream_test.go

@@ -369,6 +369,19 @@ func TestStreamDecodingDeadline(t *testing.T) {
 	assert.Equal(t, now.String(), dec.deadline.String(), "dec.now and now should be equal")
 }
 
+func TestStreamDecodingDeadlineNotSet(t *testing.T) {
+	dec := Stream.NewDecoder(&StreamReader{})
+	_, isSet := dec.Deadline()
+	assert.Equal(t, false, isSet, "isSet should be false as deadline is not set")
+}
+
+// this test is only relevant for coverage
+func TestStreamDecodingValue(t *testing.T) {
+	dec := Stream.NewDecoder(&StreamReader{})
+	v := dec.Value("")
+	assert.Nil(t, v, "v should be nil")
+}
+
 func TestStreamDecodingErrNotSet(t *testing.T) {
 	dec := Stream.NewDecoder(&StreamReader{})
 	assert.Nil(t, dec.Err(), "dec.Err should be nim")

encode.go

@@ -1,5 +1,10 @@
 package gojay
 
+import (
+	"fmt"
+	"reflect"
+)
+
 // MarshalObject returns the JSON encoding of v.
 //
 // It takes a struct implementing Marshaler to a JSON slice of byte
@@ -162,6 +167,8 @@ func Marshal(v interface{}) ([]byte, error) {
 		enc := BorrowEncoder()
 		defer enc.Release()
 		return enc.encodeFloat(float64(vt))
+	default:
+		err = InvalidMarshalError(fmt.Sprintf(invalidMarshalErrorMsg, reflect.TypeOf(vt).String()))
 	}
 	return b, err
 }