easyjson/tests/errors_test.go

package tests

import (
	"math"
	"testing"

	"github.com/mailru/easyjson/jlexer"
)

func TestMultipleErrorsInt(t *testing.T) {
	for i, test := range []struct {
		Data    []byte
		Offsets []int
	}{
		{
			Data:    []byte(`[1, 2, 3, "4", "5"]`),
			Offsets: []int{10, 15},
		},
		{
			Data:    []byte(`[1, {"2":"3"}, 3, "4"]`),
			Offsets: []int{4, 18},
		},
		{
			Data:    []byte(`[1, "2", "3", "4", "5", "6"]`),
			Offsets: []int{4, 9, 14, 19, 24},
		},
		{
			Data:    []byte(`[1, 2, 3, 4, "5"]`),
			Offsets: []int{13},
		},
		{
			Data:    []byte(`[{"1": "2"}]`),
			Offsets: []int{1},
		},
	} {
		l := jlexer.Lexer{
			Data:              test.Data,
			UseMultipleErrors: true,
		}

		var v ErrorIntSlice

		v.UnmarshalEasyJSON(&l)

		errors := l.GetNonFatalErrors()

		if len(errors) != len(test.Offsets) {
			t.Errorf("[%d] TestMultipleErrorsInt(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
			return
		}

		for ii, e := range errors {
			if e.Offset != test.Offsets[ii] {
				t.Errorf("[%d] TestMultipleErrorsInt(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
			}
		}
	}
}

func TestMultipleErrorsBool(t *testing.T) {
	for i, test := range []struct {
		Data    []byte
		Offsets []int
	}{
		{
			Data: []byte(`[true, false, true, false]`),
		},
		{
			Data:    []byte(`["test", "value", "lol", "1"]`),
			Offsets: []int{1, 9, 18, 25},
		},
		{
			Data:    []byte(`[true, 42, {"a":"b", "c":"d"}, false]`),
			Offsets: []int{7, 11},
		},
	} {
		l := jlexer.Lexer{
			Data:              test.Data,
			UseMultipleErrors: true,
		}

		var v ErrorBoolSlice
		v.UnmarshalEasyJSON(&l)

		errors := l.GetNonFatalErrors()

		if len(errors) != len(test.Offsets) {
			t.Errorf("[%d] TestMultipleErrorsBool(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
			return
		}
		for ii, e := range errors {
			if e.Offset != test.Offsets[ii] {
				t.Errorf("[%d] TestMultipleErrorsBool(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
			}
		}
	}
}

func TestMultipleErrorsUint(t *testing.T) {
	for i, test := range []struct {
		Data    []byte
		Offsets []int
	}{
		{
			Data: []byte(`[42, 42, 42]`),
		},
		{
			Data:    []byte(`[17, "42", 32]`),
			Offsets: []int{5},
		},
		{
			Data:    []byte(`["zz", "zz"]`),
			Offsets: []int{1, 7},
		},
		{
			Data:    []byte(`[{}, 42]`),
			Offsets: []int{1},
		},
	} {
		l := jlexer.Lexer{
			Data:              test.Data,
			UseMultipleErrors: true,
		}

		var v ErrorUintSlice
		v.UnmarshalEasyJSON(&l)

		errors := l.GetNonFatalErrors()

		if len(errors) != len(test.Offsets) {
			t.Errorf("[%d] TestMultipleErrorsUint(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
			return
		}
		for ii, e := range errors {
			if e.Offset != test.Offsets[ii] {
				t.Errorf("[%d] TestMultipleErrorsUint(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
			}
		}
	}
}

func TestMultipleErrorsStruct(t *testing.T) {
	for i, test := range []struct {
		Data    []byte
		Offsets []int
	}{
		{
			Data: []byte(`{"string": "test", "slice":[42, 42, 42], "int_slice":[1, 2, 3]}`),
		},
		{
			Data:    []byte(`{"string": {"test": "test"}, "slice":[42, 42, 42], "int_slice":["1", 2, 3]}`),
			Offsets: []int{11, 64},
		},
		{
			Data:    []byte(`{"slice": [42, 42], "string": {"test": "test"}, "int_slice":["1", "2", 3]}`),
			Offsets: []int{30, 61, 66},
		},
		{
			Data:    []byte(`{"string": "test", "slice": {}}`),
			Offsets: []int{28},
		},
		{
			Data:    []byte(`{"slice":5, "string" : "test"}`),
			Offsets: []int{9},
		},
		{
			Data:    []byte(`{"slice" : "test", "string" : "test"}`),
			Offsets: []int{11},
		},
		{
			Data:    []byte(`{"slice": "", "string" : {}, "int":{}}`),
			Offsets: []int{10, 25, 35},
		},
	} {
		l := jlexer.Lexer{
			Data:              test.Data,
			UseMultipleErrors: true,
		}
		var v ErrorStruct
		v.UnmarshalEasyJSON(&l)

		errors := l.GetNonFatalErrors()

		if len(errors) != len(test.Offsets) {
			t.Errorf("[%d] TestMultipleErrorsStruct(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
			return
		}
		for ii, e := range errors {
			if e.Offset != test.Offsets[ii] {
				t.Errorf("[%d] TestMultipleErrorsStruct(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
			}
		}
	}
}

func TestMultipleErrorsNestedStruct(t *testing.T) {
	for i, test := range []struct {
		Data    []byte
		Offsets []int
	}{
		{
			Data: []byte(`{"error_struct":{}}`),
		},
		{
			Data:    []byte(`{"error_struct":5}`),
			Offsets: []int{16},
		},
		{
			Data:    []byte(`{"error_struct":[]}`),
			Offsets: []int{16},
		},
		{
			Data:    []byte(`{"error_struct":{"int":{}}}`),
			Offsets: []int{23},
		},
		{
			Data:    []byte(`{"error_struct":{"int_slice":{}}, "int":4}`),
			Offsets: []int{29},
		},
		{
			Data:    []byte(`{"error_struct":{"int_slice":["1", 2, "3"]}, "int":[]}`),
			Offsets: []int{30, 38, 51},
		},
	} {
		l := jlexer.Lexer{
			Data:              test.Data,
			UseMultipleErrors: true,
		}
		var v ErrorNestedStruct
		v.UnmarshalEasyJSON(&l)

		errors := l.GetNonFatalErrors()

		if len(errors) != len(test.Offsets) {
			t.Errorf("[%d] TestMultipleErrorsNestedStruct(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
			return
		}
		for ii, e := range errors {
			if e.Offset != test.Offsets[ii] {
				t.Errorf("[%d] TestMultipleErrorsNestedStruct(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
			}
		}
	}
}

func TestMultipleErrorsIntMap(t *testing.T) {
	for i, test := range []struct {
		Data    []byte
		Offsets []int
	}{
		{
			Data:    []byte(`{"a":"NumErr"}`),
			Offsets: []int{1},
		},
		{
			Data:    []byte(`{"":"ErrSyntax"}`),
			Offsets: []int{1},
		},
		{
			Data:    []byte(`{"a":"NumErr","33147483647":"ErrRange","-1":"ErrRange"}`),
			Offsets: []int{1, 14, 39},
		},
	} {
		l := jlexer.Lexer{
			Data:              test.Data,
			UseMultipleErrors: true,
		}

		var v ErrorIntMap

		v.UnmarshalEasyJSON(&l)

		errors := l.GetNonFatalErrors()

		if len(errors) != len(test.Offsets) {
			t.Errorf("[%d] TestMultipleErrorsInt(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
			return
		}

		for ii, e := range errors {
			if e.Offset != test.Offsets[ii] {
				t.Errorf("[%d] TestMultipleErrorsInt(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
			}
		}
	}
}

func TestUnsupportedFloatValues(t *testing.T) {
	for i, test := range []struct {
		Value       ErrorFloatTypes
		ExpectedErr string
	}{
		{
			Value:       ErrorFloatTypes{Float64: math.NaN()},
			ExpectedErr: "json: unsupported value: NaN",
		},
		{
			Value:       ErrorFloatTypes{Float64: math.Inf(1)},
			ExpectedErr: "json: unsupported value: +Inf",
		},
		{
			Value:       ErrorFloatTypes{Float64: math.Inf(-1)},
			ExpectedErr: "json: unsupported value: -Inf",
		},
		{
			Value:       ErrorFloatTypes{Float32: float32(math.NaN())},
			ExpectedErr: "json: unsupported value: NaN",
		},
		{
			Value:       ErrorFloatTypes{Float32: float32(math.Inf(1))},
			ExpectedErr: "json: unsupported value: +Inf",
		},
		{
			Value:       ErrorFloatTypes{Float32: float32(math.Inf(-1))},
			ExpectedErr: "json: unsupported value: -Inf",
		},
	} {
		_, err := test.Value.MarshalJSON()
		if err == nil || err.Error() != test.ExpectedErr {
			t.Errorf("[%d] TestUnsupportedFloatValues(): error: want %s, got %v", i, test.ExpectedErr, err)
		}
	}
}