native_test.tmpl raw
1 // +build amd64
2
3
4 // Code generated by Makefile, DO NOT EDIT.
5
6 /*
7 * Copyright 2021 ByteDance Inc.
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 */
21
22 package {{PACKAGE}}
23
24 import (
25 `encoding/hex`
26 `fmt`
27 `math`
28 `strings`
29 `testing`
30 `unsafe`
31
32 `github.com/bytedance/sonic/internal/native/types`
33 `github.com/bytedance/sonic/internal/rt`
34 `github.com/davecgh/go-spew/spew`
35 `github.com/stretchr/testify/assert`
36 `github.com/stretchr/testify/require`
37 )
38
39 func TestNative_Value(t *testing.T) {
40 var v types.JsonState
41 s := ` -12345`
42 p := (*rt.GoString)(unsafe.Pointer(&s))
43 x := value(p.Ptr, p.Len, 0, &v, 0)
44 assert.Equal(t, 9, x)
45 assert.Equal(t, types.V_INTEGER, v.Vt)
46 assert.Equal(t, int64(-12345), v.Iv)
47 assert.Equal(t, 3, v.Ep)
48 }
49
50 func TestNative_Value_OutOfBound(t *testing.T) {
51 var v types.JsonState
52 mem := []byte{'"', '"'}
53 s := rt.Mem2Str(mem[:1])
54 p := (*rt.GoString)(unsafe.Pointer(&s))
55 x := value(p.Ptr, p.Len, 0, &v, 0)
56 assert.Equal(t, 1, x)
57 assert.Equal(t, -int(types.ERR_EOF), int(v.Vt))
58 }
59
60 func TestNative_Quote(t *testing.T) {
61 s := "hello\b\f\n\r\t\\\"\u666fworld"
62 d := make([]byte, 256)
63 dp := (*rt.GoSlice)(unsafe.Pointer(&d))
64 sp := (*rt.GoString)(unsafe.Pointer(&s))
65 rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
66 if rv < 0 {
67 require.NoError(t, types.ParsingError(-rv))
68 }
69 assert.Equal(t, len(s), rv)
70 assert.Equal(t, 35, len(d))
71 assert.Equal(t, `hello\u0008\u000c\n\r\t\\\"景world`, string(d))
72 }
73
74 func TestNative_QuoteNoMem(t *testing.T) {
75 s := "hello\b\f\n\r\t\\\"\u666fworld"
76 d := make([]byte, 10)
77 dp := (*rt.GoSlice)(unsafe.Pointer(&d))
78 sp := (*rt.GoString)(unsafe.Pointer(&s))
79 rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
80 assert.Equal(t, -6, rv)
81 assert.Equal(t, 5, len(d))
82 assert.Equal(t, `hello`, string(d))
83 }
84
85 func TestNative_DoubleQuote(t *testing.T) {
86 s := "hello\b\f\n\r\t\\\"\u666fworld"
87 d := make([]byte, 256)
88 dp := (*rt.GoSlice)(unsafe.Pointer(&d))
89 sp := (*rt.GoString)(unsafe.Pointer(&s))
90 rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, types.F_DOUBLE_UNQUOTE)
91 if rv < 0 {
92 require.NoError(t, types.ParsingError(-rv))
93 }
94 assert.Equal(t, len(s), rv)
95 assert.Equal(t, 44, len(d))
96 assert.Equal(t, `hello\\u0008\\u000c\\n\\r\\t\\\\\\\"景world`, string(d))
97 }
98
99 func TestNative_Unquote(t *testing.T) {
100 s := `hello\b\f\n\r\t\\\"\u2333world`
101 d := make([]byte, 0, len(s))
102 ep := -1
103 dp := (*rt.GoSlice)(unsafe.Pointer(&d))
104 sp := (*rt.GoString)(unsafe.Pointer(&s))
105 rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
106 if rv < 0 {
107 require.NoError(t, types.ParsingError(-rv))
108 }
109 dp.Len = rv
110 assert.Equal(t, -1, ep)
111 assert.Equal(t, "hello\b\f\n\r\t\\\"\u2333world", string(d))
112 }
113
114 func TestNative_UnquoteError(t *testing.T) {
115 s := `asdf\`
116 d := make([]byte, 0, len(s))
117 ep := -1
118 dp := (*rt.GoSlice)(unsafe.Pointer(&d))
119 sp := (*rt.GoString)(unsafe.Pointer(&s))
120 rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
121 assert.Equal(t, -int(types.ERR_EOF), rv)
122 assert.Equal(t, 5, ep)
123 s = `asdf\gqwer`
124 d = make([]byte, 0, len(s))
125 ep = -1
126 dp = (*rt.GoSlice)(unsafe.Pointer(&d))
127 sp = (*rt.GoString)(unsafe.Pointer(&s))
128 rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
129 assert.Equal(t, -int(types.ERR_INVALID_ESCAPE), rv)
130 assert.Equal(t, 5, ep)
131 s = `asdf\u1gggqwer`
132 d = make([]byte, 0, len(s))
133 ep = -1
134 dp = (*rt.GoSlice)(unsafe.Pointer(&d))
135 sp = (*rt.GoString)(unsafe.Pointer(&s))
136 rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
137 assert.Equal(t, -int(types.ERR_INVALID_CHAR), rv)
138 assert.Equal(t, 7, ep)
139 s = `asdf\ud800qwer`
140 d = make([]byte, 0, len(s))
141 ep = -1
142 dp = (*rt.GoSlice)(unsafe.Pointer(&d))
143 sp = (*rt.GoString)(unsafe.Pointer(&s))
144 rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
145 assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
146 assert.Equal(t, 6, ep)
147 s = `asdf\\ud800qwer`
148 d = make([]byte, 0, len(s))
149 ep = -1
150 dp = (*rt.GoSlice)(unsafe.Pointer(&d))
151 sp = (*rt.GoString)(unsafe.Pointer(&s))
152 rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
153 assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
154 assert.Equal(t, 7, ep)
155 s = `asdf\ud800\ud800qwer`
156 d = make([]byte, 0, len(s))
157 ep = -1
158 dp = (*rt.GoSlice)(unsafe.Pointer(&d))
159 sp = (*rt.GoString)(unsafe.Pointer(&s))
160 rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
161 assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
162 assert.Equal(t, 12, ep)
163 s = `asdf\\ud800\\ud800qwer`
164 d = make([]byte, 0, len(s))
165 ep = -1
166 dp = (*rt.GoSlice)(unsafe.Pointer(&d))
167 sp = (*rt.GoString)(unsafe.Pointer(&s))
168 rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
169 assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
170 assert.Equal(t, 14, ep)
171 }
172
173 func TestNative_DoubleUnquote(t *testing.T) {
174 s := `hello\\b\\f\\n\\r\\t\\\\\\\"\\u2333world`
175 d := make([]byte, 0, len(s))
176 ep := -1
177 dp := (*rt.GoSlice)(unsafe.Pointer(&d))
178 sp := (*rt.GoString)(unsafe.Pointer(&s))
179 rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
180 if rv < 0 {
181 require.NoError(t, types.ParsingError(-rv))
182 }
183 dp.Len = rv
184 assert.Equal(t, -1, ep)
185 assert.Equal(t, "hello\b\f\n\r\t\\\"\u2333world", string(d))
186 }
187
188 func TestNative_UnquoteUnicodeReplacement(t *testing.T) {
189 s := `hello\ud800world`
190 d := make([]byte, 0, len(s))
191 ep := -1
192 dp := (*rt.GoSlice)(unsafe.Pointer(&d))
193 sp := (*rt.GoString)(unsafe.Pointer(&s))
194 rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
195 if rv < 0 {
196 require.NoError(t, types.ParsingError(-rv))
197 }
198 dp.Len = rv
199 assert.Equal(t, -1, ep)
200 assert.Equal(t, "hello\ufffdworld", string(d))
201 s = `hello\ud800\ud800world`
202 d = make([]byte, 0, len(s))
203 ep = -1
204 dp = (*rt.GoSlice)(unsafe.Pointer(&d))
205 sp = (*rt.GoString)(unsafe.Pointer(&s))
206 rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
207 if rv < 0 {
208 require.NoError(t, types.ParsingError(-rv))
209 }
210 dp.Len = rv
211 assert.Equal(t, -1, ep)
212 assert.Equal(t, "hello\ufffd\ufffdworld", string(d))
213 }
214
215 func TestNative_HTMLEscape(t *testing.T) {
216 s := "hello\u2029\u2028<&>world"
217 d := make([]byte, 256)
218 dp := (*rt.GoSlice)(unsafe.Pointer(&d))
219 sp := (*rt.GoString)(unsafe.Pointer(&s))
220 rv := html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
221 if rv < 0 {
222 require.NoError(t, types.ParsingError(-rv))
223 }
224 assert.Equal(t, len(s), rv)
225 assert.Equal(t, 40, len(d))
226 assert.Equal(t, `hello\u2029\u2028\u003c\u0026\u003eworld`, string(d))
227 }
228
229 func TestNative_HTMLEscapeNoMem(t *testing.T) {
230 s := "hello\u2029\u2028<&>world"
231 d := make([]byte, 10)
232 dp := (*rt.GoSlice)(unsafe.Pointer(&d))
233 sp := (*rt.GoString)(unsafe.Pointer(&s))
234 rv := html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
235 assert.Equal(t, -6, rv)
236 assert.Equal(t, 5, len(d))
237 assert.Equal(t, `hello`, string(d))
238 }
239
240 func TestNative_Vstring(t *testing.T) {
241 var v types.JsonState
242 i := 0
243 s := `test"test\n2"`
244 vstring(&s, &i, &v, 0)
245 assert.Equal(t, 5, i)
246 assert.Equal(t, -1, v.Ep)
247 assert.Equal(t, int64(0), v.Iv)
248 vstring(&s, &i, &v, 0)
249 assert.Equal(t, 13, i)
250 assert.Equal(t, 9, v.Ep)
251 assert.Equal(t, int64(5), v.Iv)
252 }
253
254 func TestNative_Vstring_ValidUnescapedChars(t *testing.T) {
255 var v types.JsonState
256 valid := uint64(types.F_VALIDATE_STRING)
257 i := 0
258 s := "test\x1f\""
259 vstring(&s, &i, &v, valid)
260 assert.Equal(t, -int(types.ERR_INVALID_CHAR), int(v.Vt))
261 }
262
263 func TestNative_VstringEscapeEOF(t *testing.T) {
264 var v types.JsonState
265 i := 0
266 s := `xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"x`
267 vstring(&s, &i, &v, 0)
268 assert.Equal(t, 95, i)
269 assert.Equal(t, 63, v.Ep)
270 assert.Equal(t, int64(0), v.Iv)
271 }
272
273 func TestNative_VstringHangUpOnRandomData(t *testing.T) {
274 v, e := hex.DecodeString(
275 "228dc61efd54ef80a908fb6026b7f2d5f92a257ba8b347c995f259eb8685376a" +
276 "8c4500262d9c308b3f3ec2577689cf345d9f86f9b5d18d3e463bec5c22df2d2e" +
277 "4506010eba1dae7278",
278 )
279 assert.Nil(t, e)
280 p := 1
281 s := rt.Mem2Str(v)
282 var js types.JsonState
283 vstring(&s, &p, &js, 0)
284 fmt.Printf("js: %s\n", spew.Sdump(js))
285 }
286
287 func TestNative_Vnumber(t *testing.T) {
288 var v types.JsonState
289 i := 0
290 s := "1234"
291 vnumber(&s, &i, &v)
292 assert.Equal(t, 4, i)
293 assert.Equal(t, 0, v.Ep)
294 assert.Equal(t, int64(1234), v.Iv)
295 assert.Equal(t, types.V_INTEGER, v.Vt)
296 i = 0
297 s = "1.234"
298 vnumber(&s, &i, &v)
299 assert.Equal(t, 5, i)
300 assert.Equal(t, 0, v.Ep)
301 assert.Equal(t, 1.234, v.Dv)
302 assert.Equal(t, types.V_DOUBLE, v.Vt)
303 i = 0
304 s = "1.234e5"
305 vnumber(&s, &i, &v)
306 assert.Equal(t, 7, i)
307 assert.Equal(t, 0, v.Ep)
308 assert.Equal(t, 1.234e5, v.Dv)
309 assert.Equal(t, types.V_DOUBLE, v.Vt)
310 i = 0
311 s = "0.0125"
312 vnumber(&s, &i, &v)
313 assert.Equal(t, 6, i)
314 assert.Equal(t, 0, v.Ep)
315 assert.Equal(t, 0.0125, v.Dv)
316 assert.Equal(t, types.V_DOUBLE, v.Vt)
317 i = 0
318 s = "100000000000000000000"
319 vnumber(&s, &i, &v)
320 assert.Equal(t, 21, i)
321 assert.Equal(t, 0, v.Ep)
322 assert.Equal(t, 100000000000000000000.0, v.Dv)
323 assert.Equal(t, types.V_DOUBLE, v.Vt)
324 i = 0
325 s = "999999999999999900000"
326 vnumber(&s, &i, &v)
327 assert.Equal(t, 21, i)
328 assert.Equal(t, 0, v.Ep)
329 assert.Equal(t, 999999999999999900000.0, v.Dv)
330 assert.Equal(t, types.V_DOUBLE, v.Vt)
331 i = 0
332 s = "-1.234"
333 vnumber(&s, &i, &v)
334 assert.Equal(t, 6, i)
335 assert.Equal(t, 0, v.Ep)
336 assert.Equal(t, -1.234, v.Dv)
337 assert.Equal(t, types.V_DOUBLE, v.Vt)
338 }
339
340 func TestNative_Vsigned(t *testing.T) {
341 var v types.JsonState
342 i := 0
343 s := "1234"
344 vsigned(&s, &i, &v)
345 assert.Equal(t, 4, i)
346 assert.Equal(t, 0, v.Ep)
347 assert.Equal(t, int64(1234), v.Iv)
348 assert.Equal(t, types.V_INTEGER, v.Vt)
349 i = 0
350 s = "-1234"
351 vsigned(&s, &i, &v)
352 assert.Equal(t, 5, i)
353 assert.Equal(t, 0, v.Ep)
354 assert.Equal(t, int64(-1234), v.Iv)
355 assert.Equal(t, types.V_INTEGER, v.Vt)
356 i = 0
357 s = "9223372036854775807"
358 vsigned(&s, &i, &v)
359 assert.Equal(t, 19, i)
360 assert.Equal(t, 0, v.Ep)
361 assert.Equal(t, int64(math.MaxInt64), v.Iv)
362 assert.Equal(t, types.V_INTEGER, v.Vt)
363 i = 0
364 s = "-9223372036854775808"
365 vsigned(&s, &i, &v)
366 assert.Equal(t, 20, i)
367 assert.Equal(t, 0, v.Ep)
368 assert.Equal(t, int64(math.MinInt64), v.Iv)
369 assert.Equal(t, types.V_INTEGER, v.Vt)
370 i = 0
371 s = "9223372036854775808"
372 vsigned(&s, &i, &v)
373 assert.Equal(t, 18, i)
374 assert.Equal(t, 0, v.Ep)
375 assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
376 i = 0
377 s = "-9223372036854775809"
378 vsigned(&s, &i, &v)
379 assert.Equal(t, 19, i)
380 assert.Equal(t, 0, v.Ep)
381 assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
382 i = 0
383 s = "1.234"
384 vsigned(&s, &i, &v)
385 assert.Equal(t, 1, i)
386 assert.Equal(t, 0, v.Ep)
387 assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
388 i = 0
389 s = "0.0125"
390 vsigned(&s, &i, &v)
391 assert.Equal(t, 1, i)
392 assert.Equal(t, 0, v.Ep)
393 assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
394 i = 0
395 s = "-1234e5"
396 vsigned(&s, &i, &v)
397 assert.Equal(t, 5, i)
398 assert.Equal(t, 0, v.Ep)
399 assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
400 i = 0
401 s = "-1234e-5"
402 vsigned(&s, &i, &v)
403 assert.Equal(t, 5, i)
404 assert.Equal(t, 0, v.Ep)
405 assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
406 }
407
408 func TestNative_Vunsigned(t *testing.T) {
409 var v types.JsonState
410 i := 0
411 s := "1234"
412 vunsigned(&s, &i, &v)
413 assert.Equal(t, 4, i)
414 assert.Equal(t, 0, v.Ep)
415 assert.Equal(t, int64(1234), v.Iv)
416 assert.Equal(t, types.V_INTEGER, v.Vt)
417 i = 0
418 s = "18446744073709551615"
419 vunsigned(&s, &i, &v)
420 assert.Equal(t, 20, i)
421 assert.Equal(t, 0, v.Ep)
422 assert.Equal(t, ^int64(0), v.Iv)
423 assert.Equal(t, types.V_INTEGER, v.Vt)
424 i = 0
425 s = "18446744073709551616"
426 vunsigned(&s, &i, &v)
427 assert.Equal(t, 19, i)
428 assert.Equal(t, 0, v.Ep)
429 assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
430 i = 0
431 s = "-1234"
432 vunsigned(&s, &i, &v)
433 assert.Equal(t, 0, i)
434 assert.Equal(t, 0, v.Ep)
435 assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
436 i = 0
437 s = "1.234"
438 vunsigned(&s, &i, &v)
439 assert.Equal(t, 1, i)
440 assert.Equal(t, 0, v.Ep)
441 assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
442 i = 0
443 s = "0.0125"
444 vunsigned(&s, &i, &v)
445 assert.Equal(t, 1, i)
446 assert.Equal(t, 0, v.Ep)
447 assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
448 i = 0
449 s = "1234e5"
450 vunsigned(&s, &i, &v)
451 assert.Equal(t, 4, i)
452 assert.Equal(t, 0, v.Ep)
453 assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
454 i = 0
455 s = "-1234e5"
456 vunsigned(&s, &i, &v)
457 assert.Equal(t, 0, i)
458 assert.Equal(t, 0, v.Ep)
459 assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
460 i = 0
461 s = "-1.234e5"
462 vunsigned(&s, &i, &v)
463 assert.Equal(t, 0, i)
464 assert.Equal(t, 0, v.Ep)
465 assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
466 i = 0
467 s = "-1.234e-5"
468 vunsigned(&s, &i, &v)
469 assert.Equal(t, 0, i)
470 assert.Equal(t, 0, v.Ep)
471 assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
472 }
473
474 func TestNative_SkipOne(t *testing.T) {
475 p := 0
476 s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
477 q := skip_one(&s, &p, &types.StateMachine{}, uint64(0))
478 assert.Equal(t, 42, p)
479 assert.Equal(t, 1, q)
480 p = 0
481 s = `1 2.5 -3 "asdf\nqwer" true false null {} []`
482 q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
483 assert.Equal(t, 1, p)
484 assert.Equal(t, 0, q)
485 q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
486 assert.Equal(t, 5, p)
487 assert.Equal(t, 2, q)
488 q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
489 assert.Equal(t, 8, p)
490 assert.Equal(t, 6, q)
491 q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
492 assert.Equal(t, 21, p)
493 assert.Equal(t, 9, q)
494 q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
495 assert.Equal(t, 26, p)
496 assert.Equal(t, 22, q)
497 q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
498 assert.Equal(t, 32, p)
499 assert.Equal(t, 27, q)
500 q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
501 assert.Equal(t, 37, p)
502 assert.Equal(t, 33, q)
503 q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
504 assert.Equal(t, 40, p)
505 assert.Equal(t, 38, q)
506 q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
507 assert.Equal(t, 43, p)
508 assert.Equal(t, 41, q)
509 }
510
511 func TestNative_SkipOne_Error(t *testing.T) {
512 for _, s := range([]string{
513 "-", "+", "0.", "0. ", "+1", "0.0e ", "9e+", "0e-",
514 "tru", "fals", "nul", "trux", "fals ",
515 `"asdf`, `"\\\"`,
516 }) {
517 p := 0
518 q := skip_one(&s, &p, &types.StateMachine{}, uint64(0))
519 assert.True(t, q < 0)
520 }
521 }
522
523 func TestNative_SkipArray(t *testing.T) {
524 p := 0
525 s := `null, true, false, 1, 2.0, -3, {"asdf": "wqer"}],`
526 skip_array(&s, &p, &types.StateMachine{}, uint64(0))
527 assert.Equal(t, p, 48)
528 }
529
530 func TestNative_SkipObject(t *testing.T) {
531 p := 0
532 s := `"asdf": "wqer"},`
533 skip_object(&s, &p, &types.StateMachine{}, uint64(0))
534 assert.Equal(t, p, 15)
535 }
536
537 func TestNative_SkipNumber(t *testing.T) {
538 p := 0
539 s := `-1.23e+12`
540 q := skip_number(&s, &p)
541 assert.Equal(t, 9, p)
542 assert.Equal(t, 0, q)
543 }
544
545 func TestNative_SkipNumberInJson(t *testing.T) {
546 p := 0x13
547 s := "{\"h\":\"1.00000\",\"i\":true,\"pass3\":1}"
548 q := skip_number(&s, &p)
549 assert.Equal(t, 0x13, p)
550 assert.Equal(t, -2, q)
551 }
552
553 func TestNative_SkipOneFast(t *testing.T) {
554 p := 0
555 s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
556 q := skip_one_fast(&s, &p)
557 assert.Equal(t, 42, p)
558 assert.Equal(t, 1, q)
559 p = 0
560 s = `1, 2.5, -3, "asdf\nqwer", true, false, null, {}, [],`
561 q = skip_one_fast(&s, &p)
562 assert.Equal(t, 1, p)
563 assert.Equal(t, 0, q)
564 p += 1
565 q = skip_one_fast(&s, &p)
566 assert.Equal(t, 6, p)
567 assert.Equal(t, 3, q)
568 p += 1
569 q = skip_one_fast(&s, &p)
570 assert.Equal(t, 10, p)
571 assert.Equal(t, 8, q)
572 p += 1
573 q = skip_one_fast(&s, &p)
574 assert.Equal(t, 24, p)
575 assert.Equal(t, 12, q)
576 p += 1
577 q = skip_one_fast(&s, &p)
578 assert.Equal(t, 30, p)
579 assert.Equal(t, 26, q)
580 p += 1
581 q = skip_one_fast(&s, &p)
582 assert.Equal(t, 37, p)
583 assert.Equal(t, 32, q)
584 p += 1
585 q = skip_one_fast(&s, &p)
586 assert.Equal(t, 43, p)
587 assert.Equal(t, 39, q)
588 p += 1
589 q = skip_one_fast(&s, &p)
590 assert.Equal(t, 47, p)
591 assert.Equal(t, 45, q)
592 p += 1
593 q = skip_one_fast(&s, &p)
594 assert.Equal(t, 51, p)
595 assert.Equal(t, 49, q)
596 }
597
598 func TestNative_SkipOneFast_Error(t *testing.T) {
599 for _, s := range([]string{
600 "{{", "[{", "{{}",
601 `"asdf`, `"\\\"`,
602 }) {
603 p := 0
604 q := skip_one_fast(&s, &p)
605 assert.True(t, q < 0)
606 }
607 }
608
609 func TestNative_GetByPath(t *testing.T) {
610 s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
611 p := 0
612 path := []interface{}{"asdf", 4}
613 ret := get_by_path(&s, &p, &path, types.NewStateMachine())
614 assert.Equal(t, strings.Index(s, "2.0"), ret)
615 }
616
617 func BenchmarkNative_SkipOneFast(b *testing.B) {
618 b.ResetTimer()
619 for i:=0; i<b.N; i++ {
620 s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
621 p := 0
622 _ = skip_one_fast(&s, &p)
623 }
624 }
625
626 func BenchmarkNative_GetByPath(b *testing.B) {
627 b.ResetTimer()
628 for i:=0; i<b.N; i++ {
629 s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
630 p := 0
631 path := []interface{}{"asdf", 3}
632 sm := types.NewStateMachine()
633 _ = get_by_path(&s, &p, &path, sm)
634 types.FreeStateMachine(sm)
635 }
636 }
637