1 package tests
2
3 import (
4 "testing"
5
6 "github.com/mailru/easyjson/jlexer"
7 )
8
9 func TestMultipleErrorsInt(t *testing.T) {
10 for i, test := range []struct {
11 Data []byte
12 Offsets []int
13 }{
14 {
15 Data: []byte(`[1, 2, 3, "4", "5"]`),
16 Offsets: []int{10, 15},
17 },
18 {
19 Data: []byte(`[1, {"2":"3"}, 3, "4"]`),
20 Offsets: []int{4, 18},
21 },
22 {
23 Data: []byte(`[1, "2", "3", "4", "5", "6"]`),
24 Offsets: []int{4, 9, 14, 19, 24},
25 },
26 {
27 Data: []byte(`[1, 2, 3, 4, "5"]`),
28 Offsets: []int{13},
29 },
30 {
31 Data: []byte(`[{"1": "2"}]`),
32 Offsets: []int{1},
33 },
34 } {
35 l := jlexer.Lexer{
36 Data: test.Data,
37 UseMultipleErrors: true,
38 }
39
40 var v ErrorIntSlice
41
42 v.UnmarshalEasyJSON(&l)
43
44 errors := l.GetNonFatalErrors()
45
46 if len(errors) != len(test.Offsets) {
47 t.Errorf("[%d] TestMultipleErrorsInt(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
48 return
49 }
50
51 for ii, e := range errors {
52 if e.Offset != test.Offsets[ii] {
53 t.Errorf("[%d] TestMultipleErrorsInt(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
54 }
55 }
56 }
57 }
58
59 func TestMultipleErrorsBool(t *testing.T) {
60 for i, test := range []struct {
61 Data []byte
62 Offsets []int
63 }{
64 {
65 Data: []byte(`[true, false, true, false]`),
66 },
67 {
68 Data: []byte(`["test", "value", "lol", "1"]`),
69 Offsets: []int{1, 9, 18, 25},
70 },
71 {
72 Data: []byte(`[true, 42, {"a":"b", "c":"d"}, false]`),
73 Offsets: []int{7, 11},
74 },
75 } {
76 l := jlexer.Lexer{
77 Data: test.Data,
78 UseMultipleErrors: true,
79 }
80
81 var v ErrorBoolSlice
82 v.UnmarshalEasyJSON(&l)
83
84 errors := l.GetNonFatalErrors()
85
86 if len(errors) != len(test.Offsets) {
87 t.Errorf("[%d] TestMultipleErrorsBool(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
88 return
89 }
90 for ii, e := range errors {
91 if e.Offset != test.Offsets[ii] {
92 t.Errorf("[%d] TestMultipleErrorsBool(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
93 }
94 }
95 }
96 }
97
98 func TestMultipleErrorsUint(t *testing.T) {
99 for i, test := range []struct {
100 Data []byte
101 Offsets []int
102 }{
103 {
104 Data: []byte(`[42, 42, 42]`),
105 },
106 {
107 Data: []byte(`[17, "42", 32]`),
108 Offsets: []int{5},
109 },
110 {
111 Data: []byte(`["zz", "zz"]`),
112 Offsets: []int{1, 7},
113 },
114 {
115 Data: []byte(`[{}, 42]`),
116 Offsets: []int{1},
117 },
118 } {
119 l := jlexer.Lexer{
120 Data: test.Data,
121 UseMultipleErrors: true,
122 }
123
124 var v ErrorUintSlice
125 v.UnmarshalEasyJSON(&l)
126
127 errors := l.GetNonFatalErrors()
128
129 if len(errors) != len(test.Offsets) {
130 t.Errorf("[%d] TestMultipleErrorsUint(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
131 return
132 }
133 for ii, e := range errors {
134 if e.Offset != test.Offsets[ii] {
135 t.Errorf("[%d] TestMultipleErrorsUint(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
136 }
137 }
138 }
139 }
140
141 func TestMultipleErrorsStruct(t *testing.T) {
142 for i, test := range []struct {
143 Data []byte
144 Offsets []int
145 }{
146 {
147 Data: []byte(`{"string": "test", "slice":[42, 42, 42], "int_slice":[1, 2, 3]}`),
148 },
149 {
150 Data: []byte(`{"string": {"test": "test"}, "slice":[42, 42, 42], "int_slice":["1", 2, 3]}`),
151 Offsets: []int{11, 64},
152 },
153 {
154 Data: []byte(`{"slice": [42, 42], "string": {"test": "test"}, "int_slice":["1", "2", 3]}`),
155 Offsets: []int{30, 61, 66},
156 },
157 {
158 Data: []byte(`{"string": "test", "slice": {}}`),
159 Offsets: []int{28},
160 },
161 {
162 Data: []byte(`{"slice":5, "string" : "test"}`),
163 Offsets: []int{9},
164 },
165 {
166 Data: []byte(`{"slice" : "test", "string" : "test"}`),
167 Offsets: []int{11},
168 },
169 {
170 Data: []byte(`{"slice": "", "string" : {}, "int":{}}`),
171 Offsets: []int{10, 25, 35},
172 },
173 } {
174 l := jlexer.Lexer{
175 Data: test.Data,
176 UseMultipleErrors: true,
177 }
178 var v ErrorStruct
179 v.UnmarshalEasyJSON(&l)
180
181 errors := l.GetNonFatalErrors()
182
183 if len(errors) != len(test.Offsets) {
184 t.Errorf("[%d] TestMultipleErrorsStruct(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
185 return
186 }
187 for ii, e := range errors {
188 if e.Offset != test.Offsets[ii] {
189 t.Errorf("[%d] TestMultipleErrorsStruct(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
190 }
191 }
192 }
193 }
194
195 func TestMultipleErrorsNestedStruct(t *testing.T) {
196 for i, test := range []struct {
197 Data []byte
198 Offsets []int
199 }{
200 {
201 Data: []byte(`{"error_struct":{}}`),
202 },
203 {
204 Data: []byte(`{"error_struct":5}`),
205 Offsets: []int{16},
206 },
207 {
208 Data: []byte(`{"error_struct":[]}`),
209 Offsets: []int{16},
210 },
211 {
212 Data: []byte(`{"error_struct":{"int":{}}}`),
213 Offsets: []int{23},
214 },
215 {
216 Data: []byte(`{"error_struct":{"int_slice":{}}, "int":4}`),
217 Offsets: []int{29},
218 },
219 {
220 Data: []byte(`{"error_struct":{"int_slice":["1", 2, "3"]}, "int":[]}`),
221 Offsets: []int{30, 38, 51},
222 },
223 } {
224 l := jlexer.Lexer{
225 Data: test.Data,
226 UseMultipleErrors: true,
227 }
228 var v ErrorNestedStruct
229 v.UnmarshalEasyJSON(&l)
230
231 errors := l.GetNonFatalErrors()
232
233 if len(errors) != len(test.Offsets) {
234 t.Errorf("[%d] TestMultipleErrorsNestedStruct(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
235 return
236 }
237 for ii, e := range errors {
238 if e.Offset != test.Offsets[ii] {
239 t.Errorf("[%d] TestMultipleErrorsNestedStruct(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
240 }
241 }
242 }
243 }
244
245 func TestMultipleErrorsIntMap(t *testing.T) {
246 for i, test := range []struct {
247 Data []byte
248 Offsets []int
249 }{
250 {
251 Data: []byte(`{"a":"NumErr"}`),
252 Offsets: []int{1},
253 },
254 {
255 Data: []byte(`{"":"ErrSyntax"}`),
256 Offsets: []int{1},
257 },
258 {
259 Data: []byte(`{"a":"NumErr","33147483647":"ErrRange","-1":"ErrRange"}`),
260 Offsets: []int{1, 14, 39},
261 },
262 } {
263 l := jlexer.Lexer{
264 Data: test.Data,
265 UseMultipleErrors: true,
266 }
267
268 var v ErrorIntMap
269
270 v.UnmarshalEasyJSON(&l)
271
272 errors := l.GetNonFatalErrors()
273
274 if len(errors) != len(test.Offsets) {
275 t.Errorf("[%d] TestMultipleErrorsInt(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
276 return
277 }
278
279 for ii, e := range errors {
280 if e.Offset != test.Offsets[ii] {
281 t.Errorf("[%d] TestMultipleErrorsInt(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
282 }
283 }
284 }
285 }
286
View as plain text