podman

1
// Code generated by Makefile, DO NOT EDIT.
2

3
/*
4
 * Copyright 2021 ByteDance Inc.
5
 *
6
 * Licensed under the Apache License, Version 2.0 (the "License");
7
 * you may not use this file except in compliance with the License.
8
 * You may obtain a copy of the License at
9
 *
10
 *     http://www.apache.org/licenses/LICENSE-2.0
11
 *
12
 * Unless required by applicable law or agreed to in writing, software
13
 * distributed under the License is distributed on an "AS IS" BASIS,
14
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15
 * See the License for the specific language governing permissions and
16
 * limitations under the License.
17
 */
18

19
package {{PACKAGE}}
20

21
import (
22
    `encoding/hex`
23
    `fmt`
24
    `math`
25
    `strings`
26
    `testing`
27
    `unsafe`
28

29
    `github.com/bytedance/sonic/internal/native/types`
30
    `github.com/bytedance/sonic/internal/rt`
31
    `github.com/davecgh/go-spew/spew`
32
    `github.com/stretchr/testify/assert`
33
    `github.com/stretchr/testify/require`
34
)
35

36
func TestNative_Value(t *testing.T) {
37
    var v types.JsonState
38
    s := `   -12345`
39
    p := (*rt.GoString)(unsafe.Pointer(&s))
40
    x := value(p.Ptr, p.Len, 0, &v, 0)
41
    assert.Equal(t, 9, x)
42
    assert.Equal(t, types.V_INTEGER, v.Vt)
43
    assert.Equal(t, int64(-12345), v.Iv)
44
    assert.Equal(t, 3, v.Ep)
45
}
46

47
func TestNative_Value_OutOfBound(t *testing.T) {
48
    var v types.JsonState
49
    mem := []byte{'"', '"'}
50
    s := rt.Mem2Str(mem[:1])
51
    p := (*rt.GoString)(unsafe.Pointer(&s))
52
    x := value(p.Ptr, p.Len, 0, &v, 0)
53
    assert.Equal(t, 1, x)
54
    assert.Equal(t, -int(types.ERR_EOF), int(v.Vt))
55
}
56

57
func TestNative_Quote(t *testing.T) {
58
    s := "hello\b\f\n\r\t\\\"\u666fworld"
59
    d := make([]byte, 256)
60
    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
61
    sp := (*rt.GoString)(unsafe.Pointer(&s))
62
    rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
63
    if rv < 0 {
64
        require.NoError(t, types.ParsingError(-rv))
65
    }
66
    assert.Equal(t, len(s), rv)
67
    assert.Equal(t, 35, len(d))
68
    assert.Equal(t, `hello\u0008\u000c\n\r\t\\\"景world`, string(d))
69
}
70

71
func TestNative_QuoteNoMem(t *testing.T) {
72
    s := "hello\b\f\n\r\t\\\"\u666fworld"
73
    d := make([]byte, 10)
74
    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
75
    sp := (*rt.GoString)(unsafe.Pointer(&s))
76
    rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
77
    assert.Equal(t, -6, rv)
78
    assert.Equal(t, 5, len(d))
79
    assert.Equal(t, `hello`, string(d))
80
}
81

82
func TestNative_DoubleQuote(t *testing.T) {
83
    s := "hello\b\f\n\r\t\\\"\u666fworld"
84
    d := make([]byte, 256)
85
    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
86
    sp := (*rt.GoString)(unsafe.Pointer(&s))
87
    rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, types.F_DOUBLE_UNQUOTE)
88
    if rv < 0 {
89
        require.NoError(t, types.ParsingError(-rv))
90
    }
91
    assert.Equal(t, len(s), rv)
92
    assert.Equal(t, 44, len(d))
93
    assert.Equal(t, `hello\\u0008\\u000c\\n\\r\\t\\\\\\\"景world`, string(d))
94
}
95

96
func TestNative_Unquote(t *testing.T) {
97
    s := `hello\b\f\n\r\t\\\"\u2333world`
98
    d := make([]byte, 0, len(s))
99
    ep := -1
100
    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
101
    sp := (*rt.GoString)(unsafe.Pointer(&s))
102
    rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
103
    if rv < 0 {
104
        require.NoError(t, types.ParsingError(-rv))
105
    }
106
    dp.Len = rv
107
    assert.Equal(t, -1, ep)
108
    assert.Equal(t, "hello\b\f\n\r\t\\\"\u2333world", string(d))
109
}
110

111
func TestNative_UnquoteError(t *testing.T) {
112
    s := `asdf\`
113
    d := make([]byte, 0, len(s))
114
    ep := -1
115
    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
116
    sp := (*rt.GoString)(unsafe.Pointer(&s))
117
    rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
118
    assert.Equal(t, -int(types.ERR_EOF), rv)
119
    assert.Equal(t, 5, ep)
120
    s = `asdf\gqwer`
121
    d = make([]byte, 0, len(s))
122
    ep = -1
123
    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
124
    sp = (*rt.GoString)(unsafe.Pointer(&s))
125
    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
126
    assert.Equal(t, -int(types.ERR_INVALID_ESCAPE), rv)
127
    assert.Equal(t, 5, ep)
128
    s = `asdf\u1gggqwer`
129
    d = make([]byte, 0, len(s))
130
    ep = -1
131
    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
132
    sp = (*rt.GoString)(unsafe.Pointer(&s))
133
    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
134
    assert.Equal(t, -int(types.ERR_INVALID_CHAR), rv)
135
    assert.Equal(t, 7, ep)
136
    s = `asdf\ud800qwer`
137
    d = make([]byte, 0, len(s))
138
    ep = -1
139
    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
140
    sp = (*rt.GoString)(unsafe.Pointer(&s))
141
    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
142
    assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
143
    assert.Equal(t, 6, ep)
144
    s = `asdf\\ud800qwer`
145
    d = make([]byte, 0, len(s))
146
    ep = -1
147
    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
148
    sp = (*rt.GoString)(unsafe.Pointer(&s))
149
    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
150
    assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
151
    assert.Equal(t, 7, ep)
152
    s = `asdf\ud800\ud800qwer`
153
    d = make([]byte, 0, len(s))
154
    ep = -1
155
    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
156
    sp = (*rt.GoString)(unsafe.Pointer(&s))
157
    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
158
    assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
159
    assert.Equal(t, 12, ep)
160
    s = `asdf\\ud800\\ud800qwer`
161
    d = make([]byte, 0, len(s))
162
    ep = -1
163
    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
164
    sp = (*rt.GoString)(unsafe.Pointer(&s))
165
    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
166
    assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
167
    assert.Equal(t, 14, ep)
168
}
169

170
func TestNative_DoubleUnquote(t *testing.T) {
171
    s := `hello\\b\\f\\n\\r\\t\\\\\\\"\\u2333world`
172
    d := make([]byte, 0, len(s))
173
    ep := -1
174
    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
175
    sp := (*rt.GoString)(unsafe.Pointer(&s))
176
    rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
177
    if rv < 0 {
178
        require.NoError(t, types.ParsingError(-rv))
179
    }
180
    dp.Len = rv
181
    assert.Equal(t, -1, ep)
182
    assert.Equal(t, "hello\b\f\n\r\t\\\"\u2333world", string(d))
183
}
184

185
func TestNative_UnquoteUnicodeReplacement(t *testing.T) {
186
    s := `hello\ud800world`
187
    d := make([]byte, 0, len(s))
188
    ep := -1
189
    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
190
    sp := (*rt.GoString)(unsafe.Pointer(&s))
191
    rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
192
    if rv < 0 {
193
        require.NoError(t, types.ParsingError(-rv))
194
    }
195
    dp.Len = rv
196
    assert.Equal(t, -1, ep)
197
    assert.Equal(t, "hello\ufffdworld", string(d))
198
    s = `hello\ud800\ud800world`
199
    d = make([]byte, 0, len(s))
200
    ep = -1
201
    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
202
    sp = (*rt.GoString)(unsafe.Pointer(&s))
203
    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
204
    if rv < 0 {
205
        require.NoError(t, types.ParsingError(-rv))
206
    }
207
    dp.Len = rv
208
    assert.Equal(t, -1, ep)
209
    assert.Equal(t, "hello\ufffd\ufffdworld", string(d))
210
}
211

212
func TestNative_HTMLEscape(t *testing.T) {
213
    s := "hello\u2029\u2028<&>world"
214
    d := make([]byte, 256)
215
    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
216
    sp := (*rt.GoString)(unsafe.Pointer(&s))
217
    rv := html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
218
    if rv < 0 {
219
        require.NoError(t, types.ParsingError(-rv))
220
    }
221
    assert.Equal(t, len(s), rv)
222
    assert.Equal(t, 40, len(d))
223
    assert.Equal(t, `hello\u2029\u2028\u003c\u0026\u003eworld`, string(d))
224
}
225

226
func TestNative_HTMLEscapeNoMem(t *testing.T) {
227
    s := "hello\u2029\u2028<&>world"
228
    d := make([]byte, 10)
229
    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
230
    sp := (*rt.GoString)(unsafe.Pointer(&s))
231
    rv := html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
232
    assert.Equal(t, -6, rv)
233
    assert.Equal(t, 5, len(d))
234
    assert.Equal(t, `hello`, string(d))
235
}
236

237
func TestNative_Vstring(t *testing.T) {
238
    var v types.JsonState
239
    i := 0
240
    s := `test"test\n2"`
241
    vstring(&s, &i, &v, 0)
242
    assert.Equal(t, 5, i)
243
    assert.Equal(t, -1, v.Ep)
244
    assert.Equal(t, int64(0), v.Iv)
245
    vstring(&s, &i, &v, 0)
246
    assert.Equal(t, 13, i)
247
    assert.Equal(t, 9, v.Ep)
248
    assert.Equal(t, int64(5), v.Iv)
249
}
250

251
func TestNative_Vstring_ValidUnescapedChars(t *testing.T) {
252
    var v types.JsonState
253
    valid := uint64(types.F_VALIDATE_STRING)
254
    i := 0
255
    s := "test\x1f\""
256
    vstring(&s, &i, &v, valid)
257
    assert.Equal(t, -int(types.ERR_INVALID_CHAR), int(v.Vt))
258
}
259

260
func TestNative_VstringEscapeEOF(t *testing.T) {
261
    var v types.JsonState
262
    i := 0
263
    s := `xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"x`
264
    vstring(&s, &i, &v, 0)
265
    assert.Equal(t, 95, i)
266
    assert.Equal(t, 63, v.Ep)
267
    assert.Equal(t, int64(0), v.Iv)
268
}
269

270
func TestNative_VstringHangUpOnRandomData(t *testing.T) {
271
    v, e := hex.DecodeString(
272
        "228dc61efd54ef80a908fb6026b7f2d5f92a257ba8b347c995f259eb8685376a" +
273
        "8c4500262d9c308b3f3ec2577689cf345d9f86f9b5d18d3e463bec5c22df2d2e" +
274
        "4506010eba1dae7278",
275
    )
276
    assert.Nil(t, e)
277
    p := 1
278
    s := rt.Mem2Str(v)
279
    var js types.JsonState
280
    vstring(&s, &p, &js, 0)
281
    fmt.Printf("js: %s\n", spew.Sdump(js))
282
}
283

284
func TestNative_Vnumber(t *testing.T) {
285
    var v types.JsonState
286
    i := 0
287
    s := "1234"
288
    vnumber(&s, &i, &v)
289
    assert.Equal(t, 4, i)
290
    assert.Equal(t, 0, v.Ep)
291
    assert.Equal(t, int64(1234), v.Iv)
292
    assert.Equal(t, types.V_INTEGER, v.Vt)
293
    i = 0
294
    s = "1.234"
295
    vnumber(&s, &i, &v)
296
    assert.Equal(t, 5, i)
297
    assert.Equal(t, 0, v.Ep)
298
    assert.Equal(t, 1.234, v.Dv)
299
    assert.Equal(t, types.V_DOUBLE, v.Vt)
300
    i = 0
301
    s = "1.234e5"
302
    vnumber(&s, &i, &v)
303
    assert.Equal(t, 7, i)
304
    assert.Equal(t, 0, v.Ep)
305
    assert.Equal(t, 1.234e5, v.Dv)
306
    assert.Equal(t, types.V_DOUBLE, v.Vt)
307
    i = 0
308
    s = "0.0125"
309
    vnumber(&s, &i, &v)
310
    assert.Equal(t, 6, i)
311
    assert.Equal(t, 0, v.Ep)
312
    assert.Equal(t, 0.0125, v.Dv)
313
    assert.Equal(t, types.V_DOUBLE, v.Vt)
314
    i = 0
315
    s = "100000000000000000000"
316
    vnumber(&s, &i, &v)
317
    assert.Equal(t, 21, i)
318
    assert.Equal(t, 0, v.Ep)
319
    assert.Equal(t, 100000000000000000000.0, v.Dv)
320
    assert.Equal(t, types.V_DOUBLE, v.Vt)
321
    i = 0
322
    s = "999999999999999900000"
323
    vnumber(&s, &i, &v)
324
    assert.Equal(t, 21, i)
325
    assert.Equal(t, 0, v.Ep)
326
    assert.Equal(t, 999999999999999900000.0, v.Dv)
327
    assert.Equal(t, types.V_DOUBLE, v.Vt)
328
    i = 0
329
    s = "-1.234"
330
    vnumber(&s, &i, &v)
331
    assert.Equal(t, 6, i)
332
    assert.Equal(t, 0, v.Ep)
333
    assert.Equal(t, -1.234, v.Dv)
334
    assert.Equal(t, types.V_DOUBLE, v.Vt)
335
}
336

337
func TestNative_Vsigned(t *testing.T) {
338
    var v types.JsonState
339
    i := 0
340
    s := "1234"
341
    vsigned(&s, &i, &v)
342
    assert.Equal(t, 4, i)
343
    assert.Equal(t, 0, v.Ep)
344
    assert.Equal(t, int64(1234), v.Iv)
345
    assert.Equal(t, types.V_INTEGER, v.Vt)
346
    i = 0
347
    s = "-1234"
348
    vsigned(&s, &i, &v)
349
    assert.Equal(t, 5, i)
350
    assert.Equal(t, 0, v.Ep)
351
    assert.Equal(t, int64(-1234), v.Iv)
352
    assert.Equal(t, types.V_INTEGER, v.Vt)
353
    i = 0
354
    s = "9223372036854775807"
355
    vsigned(&s, &i, &v)
356
    assert.Equal(t, 19, i)
357
    assert.Equal(t, 0, v.Ep)
358
    assert.Equal(t, int64(math.MaxInt64), v.Iv)
359
    assert.Equal(t, types.V_INTEGER, v.Vt)
360
    i = 0
361
    s = "-9223372036854775808"
362
    vsigned(&s, &i, &v)
363
    assert.Equal(t, 20, i)
364
    assert.Equal(t, 0, v.Ep)
365
    assert.Equal(t, int64(math.MinInt64), v.Iv)
366
    assert.Equal(t, types.V_INTEGER, v.Vt)
367
    i = 0
368
    s = "9223372036854775808"
369
    vsigned(&s, &i, &v)
370
    assert.Equal(t, 18, i)
371
    assert.Equal(t, 0, v.Ep)
372
    assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
373
    i = 0
374
    s = "-9223372036854775809"
375
    vsigned(&s, &i, &v)
376
    assert.Equal(t, 19, i)
377
    assert.Equal(t, 0, v.Ep)
378
    assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
379
    i = 0
380
    s = "1.234"
381
    vsigned(&s, &i, &v)
382
    assert.Equal(t, 1, i)
383
    assert.Equal(t, 0, v.Ep)
384
    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
385
    i = 0
386
    s = "0.0125"
387
    vsigned(&s, &i, &v)
388
    assert.Equal(t, 1, i)
389
    assert.Equal(t, 0, v.Ep)
390
    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
391
    i = 0
392
    s = "-1234e5"
393
    vsigned(&s, &i, &v)
394
    assert.Equal(t, 5, i)
395
    assert.Equal(t, 0, v.Ep)
396
    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
397
    i = 0
398
    s = "-1234e-5"
399
    vsigned(&s, &i, &v)
400
    assert.Equal(t, 5, i)
401
    assert.Equal(t, 0, v.Ep)
402
    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
403
}
404

405
func TestNative_Vunsigned(t *testing.T) {
406
    var v types.JsonState
407
    i := 0
408
    s := "1234"
409
    vunsigned(&s, &i, &v)
410
    assert.Equal(t, 4, i)
411
    assert.Equal(t, 0, v.Ep)
412
    assert.Equal(t, int64(1234), v.Iv)
413
    assert.Equal(t, types.V_INTEGER, v.Vt)
414
    i = 0
415
    s = "18446744073709551615"
416
    vunsigned(&s, &i, &v)
417
    assert.Equal(t, 20, i)
418
    assert.Equal(t, 0, v.Ep)
419
    assert.Equal(t, ^int64(0), v.Iv)
420
    assert.Equal(t, types.V_INTEGER, v.Vt)
421
    i = 0
422
    s = "18446744073709551616"
423
    vunsigned(&s, &i, &v)
424
    assert.Equal(t, 19, i)
425
    assert.Equal(t, 0, v.Ep)
426
    assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
427
    i = 0
428
    s = "-1234"
429
    vunsigned(&s, &i, &v)
430
    assert.Equal(t, 0, i)
431
    assert.Equal(t, 0, v.Ep)
432
    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
433
    i = 0
434
    s = "1.234"
435
    vunsigned(&s, &i, &v)
436
    assert.Equal(t, 1, i)
437
    assert.Equal(t, 0, v.Ep)
438
    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
439
    i = 0
440
    s = "0.0125"
441
    vunsigned(&s, &i, &v)
442
    assert.Equal(t, 1, i)
443
    assert.Equal(t, 0, v.Ep)
444
    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
445
    i = 0
446
    s = "1234e5"
447
    vunsigned(&s, &i, &v)
448
    assert.Equal(t, 4, i)
449
    assert.Equal(t, 0, v.Ep)
450
    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
451
    i = 0
452
    s = "-1234e5"
453
    vunsigned(&s, &i, &v)
454
    assert.Equal(t, 0, i)
455
    assert.Equal(t, 0, v.Ep)
456
    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
457
    i = 0
458
    s = "-1.234e5"
459
    vunsigned(&s, &i, &v)
460
    assert.Equal(t, 0, i)
461
    assert.Equal(t, 0, v.Ep)
462
    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
463
    i = 0
464
    s = "-1.234e-5"
465
    vunsigned(&s, &i, &v)
466
    assert.Equal(t, 0, i)
467
    assert.Equal(t, 0, v.Ep)
468
    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
469
}
470

471
func TestNative_SkipOne(t *testing.T) {
472
    p := 0
473
    s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
474
    q := skip_one(&s, &p, &types.StateMachine{}, uint64(0))
475
    assert.Equal(t, 42, p)
476
    assert.Equal(t, 1, q)
477
    p = 0
478
    s = `1 2.5 -3 "asdf\nqwer" true false null {} []`
479
    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
480
    assert.Equal(t, 1, p)
481
    assert.Equal(t, 0, q)
482
    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
483
    assert.Equal(t, 5, p)
484
    assert.Equal(t, 2, q)
485
    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
486
    assert.Equal(t, 8, p)
487
    assert.Equal(t, 6, q)
488
    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
489
    assert.Equal(t, 21, p)
490
    assert.Equal(t, 9, q)
491
    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
492
    assert.Equal(t, 26, p)
493
    assert.Equal(t, 22, q)
494
    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
495
    assert.Equal(t, 32, p)
496
    assert.Equal(t, 27, q)
497
    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
498
    assert.Equal(t, 37, p)
499
    assert.Equal(t, 33, q)
500
    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
501
    assert.Equal(t, 40, p)
502
    assert.Equal(t, 38, q)
503
    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
504
    assert.Equal(t, 43, p)
505
    assert.Equal(t, 41, q)
506
}
507

508
func TestNative_SkipOne_Error(t *testing.T) {
509
    for _, s := range([]string{
510
        "-", "+", "0.", "0. ", "+1", "0.0e ", "9e+", "0e-",
511
        "tru", "fals", "nul", "trux", "fals ", 
512
        `"asdf`, `"\\\"`,
513
    }) {
514
        p := 0
515
        q := skip_one(&s, &p, &types.StateMachine{}, uint64(0))
516
        assert.True(t, q < 0)
517
    }
518
}
519

520
func TestNative_SkipArray(t *testing.T) {
521
    p := 0
522
    s := `null, true, false, 1, 2.0, -3, {"asdf": "wqer"}],`
523
    skip_array(&s, &p, &types.StateMachine{}, uint64(0))
524
    assert.Equal(t, p, 48)
525
}
526

527
func TestNative_SkipObject(t *testing.T) {
528
    p := 0
529
    s := `"asdf": "wqer"},`
530
    skip_object(&s, &p, &types.StateMachine{}, uint64(0))
531
    assert.Equal(t, p, 15)
532
}
533

534
func TestNative_SkipNumber(t *testing.T) {
535
    p := 0
536
    s := `-1.23e+12`
537
    q := skip_number(&s, &p)
538
    assert.Equal(t, 9, p)
539
    assert.Equal(t, 0, q)
540
}
541

542
func TestNative_SkipNumberInJson(t *testing.T) {
543
    p := 0x13
544
    s := "{\"h\":\"1.00000\",\"i\":true,\"pass3\":1}"
545
    q := skip_number(&s, &p)
546
    assert.Equal(t, 0x13, p)
547
    assert.Equal(t, -2, q)
548
}
549

550
func TestNative_SkipOneFast(t *testing.T) {
551
    p := 0
552
    s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
553
    q := skip_one_fast(&s, &p)
554
    assert.Equal(t, 42, p)
555
    assert.Equal(t, 1, q)
556
    p = 0
557
    s = `1, 2.5, -3, "asdf\nqwer", true, false, null, {}, [],`
558
    q = skip_one_fast(&s, &p)
559
    assert.Equal(t, 1, p)
560
    assert.Equal(t, 0, q)
561
    p += 1
562
    q = skip_one_fast(&s, &p)
563
    assert.Equal(t, 6, p)
564
    assert.Equal(t, 3, q)
565
    p += 1
566
    q = skip_one_fast(&s, &p)
567
    assert.Equal(t, 10, p)
568
    assert.Equal(t, 8, q)
569
    p += 1
570
    q = skip_one_fast(&s, &p)
571
    assert.Equal(t, 24, p)
572
    assert.Equal(t, 12, q)
573
    p += 1
574
    q = skip_one_fast(&s, &p)
575
    assert.Equal(t, 30, p)
576
    assert.Equal(t, 26, q)
577
    p += 1
578
    q = skip_one_fast(&s, &p)
579
    assert.Equal(t, 37, p)
580
    assert.Equal(t, 32, q)
581
    p += 1
582
    q = skip_one_fast(&s, &p)
583
    assert.Equal(t, 43, p)
584
    assert.Equal(t, 39, q)
585
    p += 1
586
    q = skip_one_fast(&s, &p)
587
    assert.Equal(t, 47, p)
588
    assert.Equal(t, 45, q)
589
    p += 1
590
    q = skip_one_fast(&s, &p)
591
    assert.Equal(t, 51, p)
592
    assert.Equal(t, 49, q)
593
}
594

595
func TestNative_SkipOneFast_Error(t *testing.T) {
596
    for _, s := range([]string{
597
        "{{", "[{",  "{{}",
598
        `"asdf`, `"\\\"`,
599
    }) {
600
        p := 0
601
        q := skip_one_fast(&s, &p)
602
        assert.True(t, q < 0)
603
    }
604
}
605

606
func TestNative_GetByPath(t *testing.T) {
607
    s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
608
    p := 0
609
    path := []interface{}{"asdf", 4}
610
    ret := get_by_path(&s, &p, &path, types.NewStateMachine())
611
    assert.Equal(t, strings.Index(s, "2.0"), ret)
612
}
613

614
func BenchmarkNative_SkipOneFast(b *testing.B) {
615
    b.ResetTimer()
616
    for i:=0; i<b.N; i++ {
617
        s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
618
        p := 0
619
        _ = skip_one_fast(&s, &p)
620
    }
621
}
622

623
func BenchmarkNative_GetByPath(b *testing.B) {
624
    b.ResetTimer()
625
    for i:=0; i<b.N; i++ {
626
        s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
627
        p := 0
628
        path := []interface{}{"asdf", 3}
629
        sm := types.NewStateMachine()
630
        _ = get_by_path(&s, &p, &path, sm)
631
        types.FreeStateMachine(sm)
632
    }
633
}