recover_test.tmpl raw
1 //go:build amd64
2 // +build amd64
3
4 // Code generated by Makefile, DO NOT EDIT.
5
6 /**
7 * Copyright 2023 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 `bytes`
26 `os`
27 `runtime`
28 `runtime/debug`
29 `runtime/pprof`
30 `strings`
31 `testing`
32 `time`
33 `unsafe`
34
35 `github.com/bytedance/sonic/internal/native/types`
36 `github.com/bytedance/sonic/internal/rt`
37 )
38
39 var (
40 debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == ""
41 )
42
43
44 func TestMain(m *testing.M) {
45 Use()
46 go func () {
47 if !debugAsyncGC {
48 return
49 }
50 println("Begin GC looping...")
51 for {
52 runtime.GC()
53 debug.FreeOSMemory()
54 }
55 println("stop GC looping!")
56 }()
57 time.Sleep(time.Millisecond*100)
58 m.Run()
59 }
60
61 func TestRecover_f64toa(t *testing.T) {
62 defer func() {
63 if r := recover(); r!= nil {
64 t.Log("recover: ", r)
65 } else {
66 t.Fatal("no panic")
67 }
68 }()
69 _ = f64toa(nil, 123)
70 }
71
72 func TestRecover_f32toa(t *testing.T) {
73 defer func() {
74 if r := recover(); r!= nil {
75 t.Log("recover: ", r)
76 } else {
77 t.Fatal("no panic")
78 }
79 }()
80 _ = f32toa(nil, 123)
81 }
82
83 func TestRecover_i64toa(t *testing.T) {
84 defer func() {
85 if r := recover(); r!= nil {
86 t.Log("recover: ", r)
87 } else {
88 t.Fatal("no panic")
89 }
90 }()
91 _ = i64toa(nil, 123)
92 }
93
94 func TestRecover_u64toa(t *testing.T) {
95 defer func() {
96 if r := recover(); r!= nil {
97 t.Log("recover: ", r)
98 } else {
99 t.Fatal("no panic")
100 }
101 }()
102 _ = u64toa(nil, 123)
103 }
104
105 func TestRecover_lspace(t *testing.T) {
106 defer func() {
107 if r := recover(); r!= nil {
108 t.Log("recover: ", r)
109 } else {
110 t.Fatal("no panic")
111 }
112 }()
113 _ = lspace(nil, 2, 0)
114 }
115
116 func TestRecover_lspace2(t *testing.T) {
117 // generate random space with json
118 cases := []string{
119 strings.Repeat(" ", 1) + "123",
120 strings.Repeat(" ", 1) + "123",
121 "123",
122 }
123 pprof.StartCPUProfile(bytes.NewBuffer(nil))
124 defer pprof.StopCPUProfile()
125 for i := 0; i < 10000000; i++{
126 for _, t := range cases {
127 sp := (*byte)((*rt.GoString)(unsafe.Pointer(&t)).Ptr)
128 _ = lspace(sp, len(t), 0)
129 }
130 }
131 }
132
133 func TestRecover_quote(t *testing.T) {
134 var dn = 10
135 var dp = make([]byte, dn)
136 var sp = []byte("123")
137 t.Run("sp", func(t *testing.T) {
138 defer func() {
139 if r := recover(); r!= nil {
140 t.Log("recover: ", r)
141 } else {
142 t.Fatal("no panic")
143 }
144 }()
145 _ = quote(nil, 3, unsafe.Pointer(&dp[0]), &dn, 0)
146 })
147 t.Run("dp", func(t *testing.T) {
148 defer func() {
149 if r := recover(); r!= nil {
150 t.Log("recover: ", r)
151 } else {
152 t.Fatal("no panic")
153 }
154 }()
155 _ = quote(unsafe.Pointer(&sp[0]), 3, nil, &dn, 0)
156 })
157 t.Run("dn", func(t *testing.T) {
158 defer func() {
159 if r := recover(); r!= nil {
160 t.Log("recover: ", r)
161 } else {
162 t.Fatal("no panic")
163 }
164 }()
165 _ = quote(unsafe.Pointer(&sp[0]), 3, unsafe.Pointer(&dp[0]), nil, 0)
166 })
167 }
168
169 func TestRecover_html_escape(t *testing.T) {
170 var dn = 10
171 var dp = make([]byte, dn)
172 var sp = []byte("123")
173 t.Run("sp", func(t *testing.T) {
174 defer func() {
175 if r := recover(); r!= nil {
176 t.Log("recover: ", r)
177 } else {
178 t.Fatal("no panic")
179 }
180 }()
181 _ = html_escape(nil, 3, unsafe.Pointer(&dp[0]), &dn)
182 })
183 t.Run("dp", func(t *testing.T) {
184 defer func() {
185 if r := recover(); r!= nil {
186 t.Log("recover: ", r)
187 } else {
188 t.Fatal("no panic")
189 }
190 }()
191 _ = html_escape(unsafe.Pointer(&sp[0]), 3, nil, &dn)
192 })
193 t.Run("dn", func(t *testing.T) {
194 defer func() {
195 if r := recover(); r!= nil {
196 t.Log("recover: ", r)
197 } else {
198 t.Fatal("no panic")
199 }
200 }()
201 _ = html_escape(unsafe.Pointer(&sp[0]), 3, unsafe.Pointer(&dp[0]), nil)
202 })
203 }
204
205 func TestRecover_unquote(t *testing.T) {
206 var ep = 0
207 var dp = make([]byte, 10)
208 var sp = []byte("12\\x\"3\"4")
209 t.Run("sp", func(t *testing.T) {
210 defer func() {
211 if r := recover(); r!= nil {
212 t.Log("recover: ", r)
213 } else {
214 t.Fatal("no panic")
215 }
216 }()
217 _ = unquote(nil, len(sp), unsafe.Pointer(&dp[0]), &ep, 0)
218 })
219 t.Run("dp", func(t *testing.T) {
220 defer func() {
221 if r := recover(); r!= nil {
222 t.Log("recover: ", r)
223 } else {
224 t.Fatal("no panic")
225 }
226 }()
227 _ = unquote(unsafe.Pointer(&sp[0]), len(sp), nil, &ep, 0)
228 })
229 t.Run("ep", func(t *testing.T) {
230 defer func() {
231 if r := recover(); r!= nil {
232 t.Log("recover: ", r)
233 } else {
234 t.Fatal("no panic")
235 }
236 }()
237 _ = unquote(unsafe.Pointer(&sp[0]), len(sp), unsafe.Pointer(&dp[0]), nil, 0)
238 })
239 }
240
241 func TestRecover_value(t *testing.T) {
242 var v = new(types.JsonState)
243 var sp = []byte("123")
244 t.Run("sp", func(t *testing.T) {
245 defer func() {
246 if r := recover(); r!= nil {
247 t.Log("recover: ", r)
248 } else {
249 t.Fatal("no panic")
250 }
251 }()
252 _ = value(nil, 3, 0, v, 0)
253 })
254 t.Run("v", func(t *testing.T) {
255 defer func() {
256 if r := recover(); r!= nil {
257 t.Log("recover: ", r)
258 } else {
259 t.Fatal("no panic")
260 }
261 }()
262 _ = value(unsafe.Pointer(&sp[0]), 3, 0, nil, 0)
263 })
264 }
265
266 func TestRecover_vstring(t *testing.T) {
267 var v = new(types.JsonState)
268 var sp = "123"
269 var p = 0
270 t.Run("sp", func(t *testing.T) {
271 defer func() {
272 if r := recover(); r!= nil {
273 t.Log("recover: ", r)
274 } else {
275 t.Fatal("no panic")
276 }
277 }()
278 vstring(nil, &p, v, 0)
279 })
280 t.Run("p", func(t *testing.T) {
281 defer func() {
282 if r := recover(); r!= nil {
283 t.Log("recover: ", r)
284 } else {
285 t.Fatal("no panic")
286 }
287 }()
288 vstring(&sp, nil, v, 0)
289 })
290 t.Run("v", func(t *testing.T) {
291 defer func() {
292 if r := recover(); r!= nil {
293 t.Log("recover: ", r)
294 } else {
295 t.Fatal("no panic")
296 }
297 }()
298 vstring(&sp, &p, nil, 0)
299 })
300 }
301
302 func TestRecover_vnumber(t *testing.T) {
303 var v = new(types.JsonState)
304 var sp = "123"
305 var p = 0
306 t.Run("sp", func(t *testing.T) {
307 defer func() {
308 if r := recover(); r!= nil {
309 t.Log("recover: ", r)
310 } else {
311 t.Fatal("no panic")
312 }
313 }()
314 vnumber(nil, &p, v)
315 })
316 t.Run("p", func(t *testing.T) {
317 defer func() {
318 if r := recover(); r!= nil {
319 t.Log("recover: ", r)
320 } else {
321 t.Fatal("no panic")
322 }
323 }()
324 vnumber(&sp, nil, v)
325 })
326 t.Run("v", func(t *testing.T) {
327 defer func() {
328 if r := recover(); r!= nil {
329 t.Log("recover: ", r)
330 } else {
331 t.Fatal("no panic")
332 }
333 }()
334 vnumber(&sp, &p, nil)
335 })
336 }
337
338 func TestRecover_vsigned(t *testing.T) {
339 var v = new(types.JsonState)
340 var sp = "123"
341 var p = 0
342 t.Run("sp", func(t *testing.T) {
343 defer func() {
344 if r := recover(); r!= nil {
345 t.Log("recover: ", r)
346 } else {
347 t.Fatal("no panic")
348 }
349 }()
350 vsigned(nil, &p, v)
351 })
352 t.Run("p", func(t *testing.T) {
353 defer func() {
354 if r := recover(); r!= nil {
355 t.Log("recover: ", r)
356 } else {
357 t.Fatal("no panic")
358 }
359 }()
360 vsigned(&sp, nil, v)
361 })
362 t.Run("v", func(t *testing.T) {
363 defer func() {
364 if r := recover(); r!= nil {
365 t.Log("recover: ", r)
366 } else {
367 t.Fatal("no panic")
368 }
369 }()
370 vsigned(&sp, &p, nil)
371 })
372 }
373
374 func TestRecover_vunsigned(t *testing.T) {
375 var v = new(types.JsonState)
376 var sp = "123"
377 var p = 0
378 t.Run("sp", func(t *testing.T) {
379 defer func() {
380 if r := recover(); r!= nil {
381 t.Log("recover: ", r)
382 } else {
383 t.Fatal("no panic")
384 }
385 }()
386 vunsigned(nil, &p, v)
387 })
388 t.Run("p", func(t *testing.T) {
389 defer func() {
390 if r := recover(); r!= nil {
391 t.Log("recover: ", r)
392 } else {
393 t.Fatal("no panic")
394 }
395 }()
396 vunsigned(&sp, nil, v)
397 })
398 t.Run("v", func(t *testing.T) {
399 defer func() {
400 if r := recover(); r!= nil {
401 t.Log("recover: ", r)
402 } else {
403 t.Fatal("no panic")
404 }
405 }()
406 vunsigned(&sp, &p, nil)
407 })
408 }
409
410 func TestRecover_skip_one(t *testing.T) {
411 var v = types.NewStateMachine()
412 var sp = "123"
413 var p = 0
414 t.Run("sp", func(t *testing.T) {
415 defer func() {
416 if r := recover(); r!= nil {
417 t.Log("recover: ", r)
418 } else {
419 t.Fatal("no panic")
420 }
421 }()
422 _ = skip_one(nil, &p, v, 0)
423 })
424 t.Run("p", func(t *testing.T) {
425 defer func() {
426 if r := recover(); r!= nil {
427 t.Log("recover: ", r)
428 } else {
429 t.Fatal("no panic")
430 }
431 }()
432 _ = skip_one(&sp, nil, v, 0)
433 })
434 t.Run("v", func(t *testing.T) {
435 defer func() {
436 if r := recover(); r!= nil {
437 t.Log("recover: ", r)
438 } else {
439 t.Fatal("no panic")
440 }
441 }()
442 _ = skip_one(&sp, &p, nil, 0)
443 })
444 }
445
446 func TestRecover_skip_one_fast(t *testing.T) {
447 var sp = "123"
448 var p = 0
449 t.Run("sp", func(t *testing.T) {
450 defer func() {
451 if r := recover(); r!= nil {
452 t.Log("recover: ", r)
453 } else {
454 t.Fatal("no panic")
455 }
456 }()
457 _ = skip_one_fast(nil, &p)
458 })
459 t.Run("p", func(t *testing.T) {
460 defer func() {
461 if r := recover(); r!= nil {
462 t.Log("recover: ", r)
463 } else {
464 t.Fatal("no panic")
465 }
466 }()
467 _ = skip_one_fast(&sp, nil)
468 })
469 }
470
471 func TestRecover_skip_array(t *testing.T) {
472 var v = types.NewStateMachine()
473 var sp = "123"
474 var p = 0
475 t.Run("sp", func(t *testing.T) {
476 defer func() {
477 if r := recover(); r!= nil {
478 t.Log("recover: ", r)
479 } else {
480 t.Fatal("no panic")
481 }
482 }()
483 _ = skip_array(nil, &p, v, 0)
484 })
485 t.Run("p", func(t *testing.T) {
486 defer func() {
487 if r := recover(); r!= nil {
488 t.Log("recover: ", r)
489 } else {
490 t.Fatal("no panic")
491 }
492 }()
493 _ = skip_array(&sp, nil, v, 0)
494 })
495 t.Run("v", func(t *testing.T) {
496 defer func() {
497 if r := recover(); r!= nil {
498 t.Log("recover: ", r)
499 } else {
500 t.Fatal("no panic")
501 }
502 }()
503 _ = skip_array(&sp, &p, nil, 0)
504 })
505 }
506
507 func TestRecover_skip_object(t *testing.T) {
508 var v = types.NewStateMachine()
509 var sp = "123"
510 var p = 0
511 t.Run("sp", func(t *testing.T) {
512 defer func() {
513 if r := recover(); r!= nil {
514 t.Log("recover: ", r)
515 } else {
516 t.Fatal("no panic")
517 }
518 }()
519 _ = skip_object(nil, &p, v, 0)
520 })
521 t.Run("p", func(t *testing.T) {
522 defer func() {
523 if r := recover(); r!= nil {
524 t.Log("recover: ", r)
525 } else {
526 t.Fatal("no panic")
527 }
528 }()
529 _ = skip_object(&sp, nil, v, 0)
530 })
531 t.Run("v", func(t *testing.T) {
532 defer func() {
533 if r := recover(); r!= nil {
534 t.Log("recover: ", r)
535 } else {
536 t.Fatal("no panic")
537 }
538 }()
539 _ = skip_object(&sp, &p, nil, 0)
540 })
541 }
542
543 func TestRecover_skip_number(t *testing.T) {
544 var sp = "123"
545 var p = 0
546 t.Run("sp", func(t *testing.T) {
547 defer func() {
548 if r := recover(); r!= nil {
549 t.Log("recover: ", r)
550 } else {
551 t.Fatal("no panic")
552 }
553 }()
554 _ = skip_number(nil, &p)
555 })
556 t.Run("p", func(t *testing.T) {
557 defer func() {
558 if r := recover(); r!= nil {
559 t.Log("recover: ", r)
560 } else {
561 t.Fatal("no panic")
562 }
563 }()
564 _ = skip_number(&sp, nil)
565 })
566 }
567
568 func TestRecover_get_by_path(t *testing.T) {
569 var v = []interface{}{}
570 var sp = "123"
571 var p = 0
572 var m = types.NewStateMachine()
573 t.Run("sp", func(t *testing.T) {
574 defer func() {
575 if r := recover(); r!= nil {
576 t.Log("recover: ", r)
577 } else {
578 t.Fatal("no panic")
579 }
580 }()
581 _ = get_by_path(nil, &p, &v, m)
582 })
583 t.Run("p", func(t *testing.T) {
584 defer func() {
585 if r := recover(); r!= nil {
586 t.Log("recover: ", r)
587 } else {
588 t.Fatal("no panic")
589 }
590 }()
591 _ = get_by_path(&sp, nil, &v, m)
592 })
593 t.Run("path", func(t *testing.T) {
594 defer func() {
595 if r := recover(); r!= nil {
596 t.Log("recover: ", r)
597 } else {
598 t.Fatal("no panic")
599 }
600 }()
601 _ = get_by_path(&sp, &p, nil, m)
602 })
603 }
604
605 func TestRecover_validate_one(t *testing.T) {
606 var v = types.NewStateMachine()
607 var sp = "123"
608 var p = 0
609 t.Run("sp", func(t *testing.T) {
610 defer func() {
611 if r := recover(); r!= nil {
612 t.Log("recover: ", r)
613 } else {
614 t.Fatal("no panic")
615 }
616 }()
617 _ = validate_one(nil, &p, v, 0)
618 })
619 t.Run("p", func(t *testing.T) {
620 defer func() {
621 if r := recover(); r!= nil {
622 t.Log("recover: ", r)
623 } else {
624 t.Fatal("no panic")
625 }
626 }()
627 _ = validate_one(&sp, nil, v, 0)
628 })
629 t.Run("v", func(t *testing.T) {
630 defer func() {
631 if r := recover(); r!= nil {
632 t.Log("recover: ", r)
633 } else {
634 t.Fatal("no panic")
635 }
636 }()
637 _ = validate_one(&sp, &p, nil, 0)
638 })
639 }
640
641 func TestRecover_validate_utf8(t *testing.T) {
642 var v = types.NewStateMachine()
643 var sp = string([]byte{0xff, 0xff, 0xff})
644 var p = 0
645 t.Run("sp", func(t *testing.T) {
646 defer func() {
647 if r := recover(); r!= nil {
648 t.Log("recover: ", r)
649 } else {
650 t.Fatal("no panic")
651 }
652 }()
653 _ = validate_utf8(nil, &p, v)
654 })
655 t.Run("p", func(t *testing.T) {
656 defer func() {
657 if r := recover(); r!= nil {
658 t.Log("recover: ", r)
659 } else {
660 t.Fatal("no panic")
661 }
662 }()
663 _ = validate_utf8(&sp, nil, v)
664 })
665 t.Run("v", func(t *testing.T) {
666 defer func() {
667 if r := recover(); r!= nil {
668 t.Log("recover: ", r)
669 } else {
670 t.Fatal("no panic")
671 }
672 }()
673 _ = validate_utf8(&sp, &p, nil)
674 })
675 }
676
677 func TestRecover_validate_utf8_fast(t *testing.T) {
678 defer func() {
679 if r := recover(); r!= nil {
680 t.Log("recover: ", r)
681 } else {
682 t.Fatal("no panic")
683 }
684 }()
685 _ = validate_utf8_fast(nil)
686 }
687
688 func TestRecover_parse_with_padding(t *testing.T) {
689 defer func() {
690 if r := recover(); r!= nil {
691 t.Log("recover: ", r)
692 } else {
693 t.Fatal("no panic")
694 }
695 }()
696 _ = parse_with_padding(nil)
697 }
698
699 func TestRecover_lookup_small_key(t *testing.T) {
700 t.Run("key", func(t *testing.T) {
701 defer func() {
702 if r := recover(); r!= nil {
703 t.Log("recover: ", r)
704 } else {
705 t.Fatal("no panic")
706 }
707 }()
708 b := bytes.Repeat([]byte("a"), 100)
709 _ = lookup_small_key(nil, &b, 10)
710 })
711 t.Run("table", func(t *testing.T) {
712 defer func() {
713 if r := recover(); r!= nil {
714 t.Log("recover: ", r)
715 } else {
716 t.Fatal("no panic")
717 }
718 }()
719 key := "a"
720 _ = lookup_small_key(&key, nil, 10)
721 })
722 }
723