decode_number_int_test.go (78109B)
1 package gojay 2 3 import ( 4 "fmt" 5 "reflect" 6 "strings" 7 "testing" 8 9 "github.com/stretchr/testify/assert" 10 ) 11 12 func TestDecoderInt(t *testing.T) { 13 testCases := []struct { 14 name string 15 json string 16 expectedResult int 17 err bool 18 errType interface{} 19 }{ 20 { 21 name: "basic-positive", 22 json: "100", 23 expectedResult: 100, 24 }, 25 { 26 name: "basic-positive2", 27 json: "1039405", 28 expectedResult: 1039405, 29 }, 30 { 31 name: "basic-negative", 32 json: "-2", 33 expectedResult: -2, 34 }, 35 { 36 name: "basic-null", 37 json: "null", 38 expectedResult: 0, 39 }, 40 { 41 name: "basic-negative-err", 42 json: "-", 43 expectedResult: 0, 44 err: true, 45 errType: InvalidJSONError(""), 46 }, 47 { 48 name: "basic-negative-err", 49 json: "-q", 50 expectedResult: 0, 51 err: true, 52 errType: InvalidJSONError(""), 53 }, 54 { 55 name: "basic-null-err", 56 json: "nxll", 57 expectedResult: 0, 58 err: true, 59 errType: InvalidJSONError(""), 60 }, 61 { 62 name: "basic-skip-data-err", 63 json: "trua", 64 expectedResult: 0, 65 err: true, 66 errType: InvalidJSONError(""), 67 }, 68 { 69 name: "basic-big", 70 json: "9223372036854775807", 71 expectedResult: 9223372036854775807, 72 }, 73 { 74 name: "basic-big-overflow", 75 json: "9223372036854775808", 76 expectedResult: 0, 77 err: true, 78 errType: InvalidUnmarshalError(""), 79 }, 80 { 81 name: "basic-big-overflow2", 82 json: "92233720368547758089", 83 expectedResult: 0, 84 err: true, 85 errType: InvalidUnmarshalError(""), 86 }, 87 { 88 name: "basic-big-overflow3", 89 json: "92233720368547758089 ", 90 expectedResult: 0, 91 err: true, 92 errType: InvalidUnmarshalError(""), 93 }, 94 { 95 name: "basic-negative2", 96 json: "-2349557", 97 expectedResult: -2349557, 98 }, 99 { 100 name: "exponent-err-too-big", 101 json: "0e10000000000000000000", 102 expectedResult: 0, 103 err: true, 104 }, 105 { 106 name: "basic-float", 107 json: "2.4595", 108 expectedResult: 2, 109 }, 110 { 111 name: "basic-float2", 112 json: "-7.8876", 113 expectedResult: -7, 114 }, 115 { 116 name: "basic-float2", 117 json: "-7.8876 ", 118 expectedResult: -7, 119 }, 120 { 121 name: "basic-float2", 122 json: "-7.8876a", 123 expectedResult: 0, 124 err: true, 125 }, 126 { 127 name: "basic-exponent-positive-positive-exp", 128 json: "1e2", 129 expectedResult: 100, 130 }, 131 { 132 name: "basic-exponent-positive-positive-exp2", 133 json: "5e+06", 134 expectedResult: 5000000, 135 }, 136 { 137 name: "basic-exponent-positive-positive-exp2", 138 json: "5.01e+10", 139 expectedResult: 50100000000, 140 }, 141 { 142 name: "basic-exponent-positive-positive-exp3", 143 json: "3e+3", 144 expectedResult: 3000, 145 }, 146 { 147 name: "basic-exponent-positive-positive-exp4", 148 json: "8e+005", 149 expectedResult: 800000, 150 }, 151 { 152 name: "basic-exponent-positive-negative-exp", 153 json: "1e-2", 154 expectedResult: 0, 155 }, 156 { 157 name: "basic-exponent-positive-negative-exp2", 158 json: "5e-6", 159 expectedResult: 0, 160 }, 161 { 162 name: "basic-exponent-positive-negative-exp3", 163 json: "3e-3", 164 expectedResult: 0, 165 }, 166 { 167 name: "basic-exponent-positive-negative-exp4", 168 json: "8e-005", 169 expectedResult: 0, 170 }, 171 { 172 name: "basic-exponent-negative-positive-exp", 173 json: "-1e2", 174 expectedResult: -100, 175 }, 176 { 177 name: "basic-exponent-negative-positive-exp2", 178 json: "-5e+06", 179 expectedResult: -5000000, 180 }, 181 { 182 name: "basic-exponent-negative-positive-exp3", 183 json: "-3e03", 184 expectedResult: -3000, 185 }, 186 { 187 name: "basic-exponent-negative-positive-exp4", 188 json: "-8e+005", 189 expectedResult: -800000, 190 }, 191 { 192 name: "error1", 193 json: "132zz4", 194 expectedResult: 0, 195 err: true, 196 }, 197 { 198 name: "negative-error2", 199 json: " -1213xdde2323 ", 200 expectedResult: 0, 201 err: true, 202 errType: InvalidJSONError(""), 203 }, 204 { 205 name: "error3", 206 json: "-8e+00$aa5", 207 expectedResult: 0, 208 err: true, 209 errType: InvalidJSONError(""), 210 }, 211 { 212 name: "error4", 213 json: "0.E----", 214 expectedResult: 0, 215 err: true, 216 errType: InvalidJSONError(""), 217 }, 218 { 219 name: "exponent-err-", 220 json: "0.1e", 221 expectedResult: 0, 222 err: true, 223 }, 224 { 225 name: "error5", 226 json: "0E40", 227 expectedResult: 0, 228 err: true, 229 errType: InvalidJSONError(""), 230 }, 231 { 232 name: "error6", 233 json: "0.e-9", 234 expectedResult: 0, 235 err: true, 236 errType: InvalidJSONError(""), 237 }, 238 239 { 240 name: "error7", 241 json: "-5.e-2", 242 expectedResult: 0, 243 err: true, 244 errType: InvalidJSONError(""), 245 }, 246 { 247 name: "invalid-type", 248 json: `"string"`, 249 expectedResult: 0, 250 err: true, 251 errType: InvalidUnmarshalError(""), 252 }, 253 } 254 for _, testCase := range testCases { 255 t.Run(testCase.name, func(t *testing.T) { 256 json := []byte(testCase.json) 257 var v int 258 err := Unmarshal(json, &v) 259 if testCase.err { 260 assert.NotNil(t, err, "Err must not be nil") 261 if testCase.errType != nil && err != nil { 262 assert.IsType( 263 t, 264 testCase.errType, 265 err, 266 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 267 ) 268 } 269 } else { 270 assert.Nil(t, err, "Err must be nil") 271 } 272 assert.Equal(t, testCase.expectedResult, v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 273 }) 274 } 275 t.Run("pool-error", func(t *testing.T) { 276 result := int(1) 277 dec := NewDecoder(nil) 278 dec.Release() 279 defer func() { 280 err := recover() 281 assert.NotNil(t, err, "err shouldnt be nil") 282 assert.IsType(t, InvalidUsagePooledDecoderError(""), err, "err should be of type InvalidUsagePooledDecoderError") 283 }() 284 _ = dec.DecodeInt(&result) 285 assert.True(t, false, "should not be called as decoder should have panicked") 286 }) 287 t.Run("decoder-api", func(t *testing.T) { 288 var v int 289 dec := NewDecoder(strings.NewReader(`33`)) 290 defer dec.Release() 291 err := dec.DecodeInt(&v) 292 assert.Nil(t, err, "Err must be nil") 293 assert.Equal(t, int(33), v, "v must be equal to 33") 294 }) 295 t.Run("decoder-api2", func(t *testing.T) { 296 var v int 297 dec := NewDecoder(strings.NewReader(`33`)) 298 defer dec.Release() 299 err := dec.Decode(&v) 300 assert.Nil(t, err, "Err must be nil") 301 assert.Equal(t, int(33), v, "v must be equal to 33") 302 }) 303 t.Run("decoder-api-invalid-json", func(t *testing.T) { 304 var v int 305 dec := NewDecoder(strings.NewReader(``)) 306 defer dec.Release() 307 err := dec.DecodeInt(&v) 308 assert.NotNil(t, err, "Err must not be nil") 309 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 310 }) 311 } 312 func TestDecoderIntNull(t *testing.T) { 313 testCases := []struct { 314 name string 315 json string 316 expectedResult int 317 err bool 318 errType interface{} 319 resultIsNil bool 320 }{ 321 { 322 name: "basic-positive", 323 json: "100", 324 expectedResult: 100, 325 }, 326 { 327 name: "basic-positive2", 328 json: "1039405", 329 expectedResult: 1039405, 330 }, 331 { 332 name: "basic-negative", 333 json: "-2", 334 expectedResult: -2, 335 }, 336 { 337 name: "basic-null", 338 json: "null", 339 expectedResult: 0, 340 resultIsNil: true, 341 }, 342 { 343 name: "basic-negative-err", 344 json: "-", 345 expectedResult: 0, 346 err: true, 347 errType: InvalidJSONError(""), 348 }, 349 { 350 name: "basic-negative-err", 351 json: "-q", 352 expectedResult: 0, 353 err: true, 354 errType: InvalidJSONError(""), 355 }, 356 { 357 name: "basic-null-err", 358 json: "nxll", 359 expectedResult: 0, 360 err: true, 361 errType: InvalidJSONError(""), 362 }, 363 { 364 name: "basic-skip-data-err", 365 json: "trua", 366 expectedResult: 0, 367 err: true, 368 errType: InvalidJSONError(""), 369 }, 370 { 371 name: "basic-big", 372 json: "9223372036854775807", 373 expectedResult: 9223372036854775807, 374 }, 375 { 376 name: "basic-big-overflow", 377 json: "9223372036854775808", 378 expectedResult: 0, 379 err: true, 380 errType: InvalidUnmarshalError(""), 381 }, 382 { 383 name: "basic-big-overflow2", 384 json: "92233720368547758089", 385 expectedResult: 0, 386 err: true, 387 errType: InvalidUnmarshalError(""), 388 }, 389 { 390 name: "basic-big-overflow3", 391 json: "92233720368547758089 ", 392 expectedResult: 0, 393 err: true, 394 errType: InvalidUnmarshalError(""), 395 }, 396 { 397 name: "basic-negative2", 398 json: "-2349557", 399 expectedResult: -2349557, 400 }, 401 { 402 name: "exponent-err-too-big", 403 json: "0e10000000000000000000", 404 expectedResult: 0, 405 err: true, 406 }, 407 { 408 name: "basic-float", 409 json: "2.4595", 410 expectedResult: 2, 411 }, 412 { 413 name: "basic-float2", 414 json: "-7.8876", 415 expectedResult: -7, 416 }, 417 { 418 name: "basic-float2", 419 json: "-7.8876 ", 420 expectedResult: -7, 421 }, 422 { 423 name: "basic-float2", 424 json: "-7.8876a", 425 expectedResult: 0, 426 err: true, 427 }, 428 { 429 name: "basic-exponent-positive-positive-exp", 430 json: "1e2", 431 expectedResult: 100, 432 }, 433 { 434 name: "basic-exponent-positive-positive-exp2", 435 json: "5e+06", 436 expectedResult: 5000000, 437 }, 438 { 439 name: "basic-exponent-positive-positive-exp2", 440 json: "5.01e+10", 441 expectedResult: 50100000000, 442 }, 443 { 444 name: "basic-exponent-positive-positive-exp3", 445 json: "3e+3", 446 expectedResult: 3000, 447 }, 448 { 449 name: "basic-exponent-positive-positive-exp4", 450 json: "8e+005", 451 expectedResult: 800000, 452 }, 453 { 454 name: "basic-exponent-positive-negative-exp", 455 json: "1e-2", 456 expectedResult: 0, 457 }, 458 { 459 name: "basic-exponent-positive-negative-exp2", 460 json: "5e-6", 461 expectedResult: 0, 462 }, 463 { 464 name: "basic-exponent-positive-negative-exp3", 465 json: "3e-3", 466 expectedResult: 0, 467 }, 468 { 469 name: "basic-exponent-positive-negative-exp4", 470 json: "8e-005", 471 expectedResult: 0, 472 }, 473 { 474 name: "basic-exponent-negative-positive-exp", 475 json: "-1e2", 476 expectedResult: -100, 477 }, 478 { 479 name: "basic-exponent-negative-positive-exp2", 480 json: "-5e+06", 481 expectedResult: -5000000, 482 }, 483 { 484 name: "basic-exponent-negative-positive-exp3", 485 json: "-3e03", 486 expectedResult: -3000, 487 }, 488 { 489 name: "basic-exponent-negative-positive-exp4", 490 json: "-8e+005", 491 expectedResult: -800000, 492 }, 493 { 494 name: "error1", 495 json: "132zz4", 496 expectedResult: 0, 497 err: true, 498 }, 499 { 500 name: "negative-error2", 501 json: " -1213xdde2323 ", 502 expectedResult: 0, 503 err: true, 504 errType: InvalidJSONError(""), 505 }, 506 { 507 name: "error3", 508 json: "-8e+00$aa5", 509 expectedResult: 0, 510 err: true, 511 errType: InvalidJSONError(""), 512 }, 513 { 514 name: "error4", 515 json: "0.E----", 516 expectedResult: 0, 517 err: true, 518 errType: InvalidJSONError(""), 519 }, 520 { 521 name: "exponent-err-", 522 json: "0.1e", 523 expectedResult: 0, 524 err: true, 525 }, 526 { 527 name: "error5", 528 json: "0E40", 529 expectedResult: 0, 530 err: true, 531 errType: InvalidJSONError(""), 532 }, 533 { 534 name: "error6", 535 json: "0.e-9", 536 expectedResult: 0, 537 err: true, 538 errType: InvalidJSONError(""), 539 }, 540 541 { 542 name: "error7", 543 json: "-5.e-2", 544 expectedResult: 0, 545 err: true, 546 errType: InvalidJSONError(""), 547 }, 548 { 549 name: "invalid-type", 550 json: `"string"`, 551 expectedResult: 0, 552 err: true, 553 errType: InvalidUnmarshalError(""), 554 }, 555 } 556 for _, testCase := range testCases { 557 t.Run(testCase.name, func(t *testing.T) { 558 json := []byte(testCase.json) 559 var v = (*int)(nil) 560 err := Unmarshal(json, &v) 561 if testCase.err { 562 assert.NotNil(t, err, "Err must not be nil") 563 if testCase.errType != nil && err != nil { 564 assert.IsType( 565 t, 566 testCase.errType, 567 err, 568 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 569 ) 570 } 571 return 572 } 573 assert.Nil(t, err, "Err must be nil") 574 if testCase.resultIsNil { 575 assert.Nil(t, v) 576 } else { 577 assert.Equal(t, testCase.expectedResult, *v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 578 } 579 }) 580 } 581 t.Run("decoder-api-invalid-json", func(t *testing.T) { 582 var v = new(int) 583 err := Unmarshal([]byte(``), &v) 584 assert.NotNil(t, err, "Err must not be nil") 585 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 586 }) 587 t.Run("decoder-api-invalid-json2", func(t *testing.T) { 588 var v = new(int) 589 var dec = NewDecoder(strings.NewReader(``)) 590 err := dec.IntNull(&v) 591 assert.NotNil(t, err, "Err must not be nil") 592 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 593 }) 594 } 595 596 func TestDecoderInt64(t *testing.T) { 597 testCases := []struct { 598 name string 599 json string 600 expectedResult int64 601 err bool 602 errType interface{} 603 }{ 604 { 605 name: "basic-positive", 606 json: "100", 607 expectedResult: 100, 608 }, 609 { 610 name: "basic-positive2", 611 json: " 1039405", 612 expectedResult: 1039405, 613 }, 614 { 615 name: "basic-negative", 616 json: "-2", 617 expectedResult: -2, 618 }, 619 { 620 name: "basic-null", 621 json: "null", 622 expectedResult: 0, 623 }, 624 { 625 name: "basic-null-err", 626 json: "nxll", 627 expectedResult: 0, 628 err: true, 629 errType: InvalidJSONError(""), 630 }, 631 { 632 name: "basic-negative-err", 633 json: "-", 634 expectedResult: 0, 635 err: true, 636 errType: InvalidJSONError(""), 637 }, 638 { 639 name: "basic-negative-err", 640 json: "-q", 641 expectedResult: 0, 642 err: true, 643 errType: InvalidJSONError(""), 644 }, 645 { 646 name: "basic-skip-data-err", 647 json: "trua", 648 expectedResult: 0, 649 err: true, 650 errType: InvalidJSONError(""), 651 }, 652 { 653 name: "basic-big", 654 json: "9223372036854775807", 655 expectedResult: 9223372036854775807, 656 }, 657 { 658 name: "basic-big-overflow", 659 json: " 9223372036854775808", 660 expectedResult: 0, 661 err: true, 662 }, 663 { 664 name: "basic-big-overflow", 665 json: " 9223372036854775827", 666 expectedResult: 0, 667 err: true, 668 }, 669 { 670 name: "basic-big-overflow2", 671 json: "92233720368547758089", 672 expectedResult: 0, 673 err: true, 674 }, 675 { 676 name: "basic-big-overflow3", 677 json: "92233720368547758089 ", 678 expectedResult: 0, 679 err: true, 680 }, 681 { 682 name: "basic-negative2", 683 json: "-2349557", 684 expectedResult: -2349557, 685 }, 686 { 687 name: "basic-float", 688 json: "2.4595", 689 expectedResult: 2, 690 }, 691 { 692 name: "basic-float2", 693 json: "-7.8876", 694 expectedResult: -7, 695 }, 696 { 697 name: "basic-float2", 698 json: "-7.8876a", 699 expectedResult: 0, 700 err: true, 701 }, 702 { 703 name: "basic-exponent-positive-positive-exp", 704 json: "1e2", 705 expectedResult: 100, 706 }, 707 { 708 name: "basic-exponent-positive-positive-exp2", 709 json: "5e+06 ", 710 expectedResult: 5000000, 711 }, 712 { 713 name: "basic-exponent-positive-positive-exp3", 714 json: "3e+3", 715 expectedResult: 3000, 716 }, 717 { 718 name: "basic-exponent-positive-positive-exp4", 719 json: "8e+005", 720 expectedResult: 800000, 721 }, 722 { 723 name: "basic-exponent-positive-negative-exp", 724 json: "1e-2 ", 725 expectedResult: 0, 726 }, 727 { 728 name: "basic-exponent-positive-negative-exp2", 729 json: "5e-6", 730 expectedResult: 0, 731 }, 732 { 733 name: "basic-exponent-positive-negative-exp3", 734 json: "3e-3", 735 expectedResult: 0, 736 }, 737 { 738 name: "before-exp-err-too-big", 739 json: "10.11231242345325435464364643e1", 740 expectedResult: 0, 741 err: true, 742 }, 743 { 744 name: "error3", 745 json: "0E40", 746 expectedResult: 0, 747 err: true, 748 errType: InvalidJSONError(""), 749 }, 750 { 751 name: "basic-exponent-positive-negative-exp4", 752 json: "8e-005", 753 expectedResult: 0, 754 }, 755 { 756 name: "basic-exponent-negative-positive-exp", 757 json: "-1e2", 758 expectedResult: -100, 759 }, 760 { 761 name: "basic-exponent-negative-positive-exp2", 762 json: "-5e+06", 763 expectedResult: -5000000, 764 }, 765 { 766 name: "basic-exponent-negative-positive-exp2", 767 json: "-5.4e+06", 768 expectedResult: -5400000, 769 }, 770 { 771 name: "basic-exponent-negative-positive-exp3", 772 json: "-3e03", 773 expectedResult: -3000, 774 }, 775 { 776 name: "basic-exponent-negative-positive-exp4", 777 json: "-8e+005", 778 expectedResult: -800000, 779 }, 780 { 781 name: "exponent-err-too-big", 782 json: "0e10000000000000000000", 783 expectedResult: 0, 784 err: true, 785 }, 786 { 787 name: "exponent-err-too-big", 788 json: "0e1000000000000000000000000 ", 789 expectedResult: 0, 790 err: true, 791 }, 792 { 793 name: "exponent-err-too-big", 794 json: "0.1e1000000000", 795 expectedResult: 0, 796 err: true, 797 }, 798 { 799 name: "exponent-err-too-big", 800 json: "0.1932242242424244244e1000000000000000000000000", 801 expectedResult: 0, 802 err: true, 803 }, 804 { 805 name: "basic-exponent-negative-positive-exp4", 806 json: "8ea+00a5", 807 expectedResult: 0, 808 err: true, 809 errType: InvalidJSONError(""), 810 }, 811 { 812 name: "basic-exponent-err", 813 json: "3e", 814 expectedResult: 0, 815 err: true, 816 }, 817 { 818 name: "error1", 819 json: "132zz4", 820 expectedResult: 0, 821 err: true, 822 }, 823 { 824 name: "error4", 825 json: "0.E----", 826 expectedResult: 0, 827 err: true, 828 errType: InvalidJSONError(""), 829 }, 830 { 831 name: "error5", 832 json: "0E40", 833 expectedResult: 0, 834 err: true, 835 errType: InvalidJSONError(""), 836 }, 837 { 838 name: "exponent-err-", 839 json: "0.1e", 840 expectedResult: 0, 841 err: true, 842 }, 843 { 844 name: "error6", 845 json: "0.e-9", 846 expectedResult: 0, 847 err: true, 848 errType: InvalidJSONError(""), 849 }, 850 { 851 name: "error7", 852 json: "-5.e-2", 853 expectedResult: 0, 854 err: true, 855 errType: InvalidJSONError(""), 856 }, 857 { 858 name: "invalid-type", 859 json: `"string"`, 860 expectedResult: 0, 861 err: true, 862 errType: InvalidUnmarshalError(""), 863 }, 864 } 865 for _, testCase := range testCases { 866 t.Run(testCase.name, func(t *testing.T) { 867 json := []byte(testCase.json) 868 var v int64 869 err := Unmarshal(json, &v) 870 if testCase.err { 871 assert.NotNil(t, err, "Err must not be nil") 872 if testCase.errType != nil { 873 assert.IsType( 874 t, 875 testCase.errType, 876 err, 877 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 878 ) 879 } 880 } else { 881 assert.Nil(t, err, "Err must be nil") 882 } 883 assert.Equal(t, testCase.expectedResult, v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 884 }) 885 } 886 t.Run("pool-error", func(t *testing.T) { 887 result := int64(1) 888 dec := NewDecoder(nil) 889 dec.Release() 890 defer func() { 891 err := recover() 892 assert.NotNil(t, err, "err shouldnt be nil") 893 assert.IsType(t, InvalidUsagePooledDecoderError(""), err, "err should be of type InvalidUsagePooledDecoderError") 894 }() 895 _ = dec.DecodeInt64(&result) 896 assert.True(t, false, "should not be called as decoder should have panicked") 897 }) 898 t.Run("decoder-api", func(t *testing.T) { 899 var v int64 900 dec := NewDecoder(strings.NewReader(`33`)) 901 defer dec.Release() 902 err := dec.DecodeInt64(&v) 903 assert.Nil(t, err, "Err must be nil") 904 assert.Equal(t, int64(33), v, "v must be equal to 33") 905 }) 906 t.Run("decoder-api2", func(t *testing.T) { 907 var v int64 908 dec := NewDecoder(strings.NewReader(`33`)) 909 defer dec.Release() 910 err := dec.Decode(&v) 911 assert.Nil(t, err, "Err must be nil") 912 assert.Equal(t, int64(33), v, "v must be equal to 33") 913 }) 914 t.Run("decoder-api-invalid-json", func(t *testing.T) { 915 var v int64 916 dec := NewDecoder(strings.NewReader(``)) 917 defer dec.Release() 918 err := dec.DecodeInt64(&v) 919 assert.NotNil(t, err, "Err must not be nil") 920 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 921 }) 922 } 923 func TestDecoderInt64Null(t *testing.T) { 924 testCases := []struct { 925 name string 926 json string 927 expectedResult int64 928 err bool 929 errType interface{} 930 resultIsNil bool 931 }{ 932 { 933 name: "basic-positive", 934 json: "100", 935 expectedResult: 100, 936 }, 937 { 938 name: "basic-positive2", 939 json: " 1039405", 940 expectedResult: 1039405, 941 }, 942 { 943 name: "basic-negative", 944 json: "-2", 945 expectedResult: -2, 946 }, 947 { 948 name: "basic-null", 949 json: "null", 950 expectedResult: 0, 951 resultIsNil: true, 952 }, 953 { 954 name: "basic-null-err", 955 json: "nxll", 956 expectedResult: 0, 957 err: true, 958 errType: InvalidJSONError(""), 959 }, 960 { 961 name: "basic-negative-err", 962 json: "-", 963 expectedResult: 0, 964 err: true, 965 errType: InvalidJSONError(""), 966 }, 967 { 968 name: "basic-negative-err", 969 json: "-q", 970 expectedResult: 0, 971 err: true, 972 errType: InvalidJSONError(""), 973 }, 974 { 975 name: "basic-skip-data-err", 976 json: "trua", 977 expectedResult: 0, 978 err: true, 979 errType: InvalidJSONError(""), 980 }, 981 { 982 name: "basic-big", 983 json: "9223372036854775807", 984 expectedResult: 9223372036854775807, 985 }, 986 { 987 name: "basic-big-overflow", 988 json: " 9223372036854775808", 989 expectedResult: 0, 990 err: true, 991 }, 992 { 993 name: "basic-big-overflow", 994 json: " 9223372036854775827", 995 expectedResult: 0, 996 err: true, 997 }, 998 { 999 name: "basic-big-overflow2", 1000 json: "92233720368547758089", 1001 expectedResult: 0, 1002 err: true, 1003 }, 1004 { 1005 name: "basic-big-overflow3", 1006 json: "92233720368547758089 ", 1007 expectedResult: 0, 1008 err: true, 1009 }, 1010 { 1011 name: "basic-negative2", 1012 json: "-2349557", 1013 expectedResult: -2349557, 1014 }, 1015 { 1016 name: "basic-float", 1017 json: "2.4595", 1018 expectedResult: 2, 1019 }, 1020 { 1021 name: "basic-float2", 1022 json: "-7.8876", 1023 expectedResult: -7, 1024 }, 1025 { 1026 name: "basic-float2", 1027 json: "-7.8876a", 1028 expectedResult: 0, 1029 err: true, 1030 }, 1031 { 1032 name: "basic-exponent-positive-positive-exp", 1033 json: "1e2", 1034 expectedResult: 100, 1035 }, 1036 { 1037 name: "basic-exponent-positive-positive-exp2", 1038 json: "5e+06 ", 1039 expectedResult: 5000000, 1040 }, 1041 { 1042 name: "basic-exponent-positive-positive-exp3", 1043 json: "3e+3", 1044 expectedResult: 3000, 1045 }, 1046 { 1047 name: "basic-exponent-positive-positive-exp4", 1048 json: "8e+005", 1049 expectedResult: 800000, 1050 }, 1051 { 1052 name: "basic-exponent-positive-negative-exp", 1053 json: "1e-2 ", 1054 expectedResult: 0, 1055 }, 1056 { 1057 name: "basic-exponent-positive-negative-exp2", 1058 json: "5e-6", 1059 expectedResult: 0, 1060 }, 1061 { 1062 name: "basic-exponent-positive-negative-exp3", 1063 json: "3e-3", 1064 expectedResult: 0, 1065 }, 1066 { 1067 name: "error3", 1068 json: "0E40", 1069 expectedResult: 0, 1070 err: true, 1071 errType: InvalidJSONError(""), 1072 }, 1073 { 1074 name: "basic-exponent-positive-negative-exp4", 1075 json: "8e-005", 1076 expectedResult: 0, 1077 }, 1078 { 1079 name: "basic-exponent-negative-positive-exp", 1080 json: "-1e2", 1081 expectedResult: -100, 1082 }, 1083 { 1084 name: "basic-exponent-negative-positive-exp2", 1085 json: "-5e+06", 1086 expectedResult: -5000000, 1087 }, 1088 { 1089 name: "basic-exponent-negative-positive-exp2", 1090 json: "-5.4e+06", 1091 expectedResult: -5400000, 1092 }, 1093 { 1094 name: "basic-exponent-negative-positive-exp3", 1095 json: "-3e03", 1096 expectedResult: -3000, 1097 }, 1098 { 1099 name: "basic-exponent-negative-positive-exp4", 1100 json: "-8e+005", 1101 expectedResult: -800000, 1102 }, 1103 { 1104 name: "exponent-err-too-big", 1105 json: "0e10000000000000000000", 1106 expectedResult: 0, 1107 err: true, 1108 }, 1109 { 1110 name: "exponent-err-too-big", 1111 json: "0e1000000000000000000000000 ", 1112 expectedResult: 0, 1113 err: true, 1114 }, 1115 { 1116 name: "exponent-err-too-big", 1117 json: "0.1e1000000000", 1118 expectedResult: 0, 1119 err: true, 1120 }, 1121 { 1122 name: "exponent-err-too-big", 1123 json: "0.1932242242424244244e1000000000000000000000000", 1124 expectedResult: 0, 1125 err: true, 1126 }, 1127 { 1128 name: "basic-exponent-negative-positive-exp4", 1129 json: "8ea+00a5", 1130 expectedResult: 0, 1131 err: true, 1132 errType: InvalidJSONError(""), 1133 }, 1134 { 1135 name: "basic-exponent-err", 1136 json: "3e", 1137 expectedResult: 0, 1138 err: true, 1139 }, 1140 { 1141 name: "error1", 1142 json: "132zz4", 1143 expectedResult: 0, 1144 err: true, 1145 }, 1146 { 1147 name: "error4", 1148 json: "0.E----", 1149 expectedResult: 0, 1150 err: true, 1151 errType: InvalidJSONError(""), 1152 }, 1153 { 1154 name: "error5", 1155 json: "0E40", 1156 expectedResult: 0, 1157 err: true, 1158 errType: InvalidJSONError(""), 1159 }, 1160 { 1161 name: "exponent-err-", 1162 json: "0.1e", 1163 expectedResult: 0, 1164 err: true, 1165 }, 1166 { 1167 name: "error6", 1168 json: "0.e-9", 1169 expectedResult: 0, 1170 err: true, 1171 errType: InvalidJSONError(""), 1172 }, 1173 { 1174 name: "error7", 1175 json: "-5.e-2", 1176 expectedResult: 0, 1177 err: true, 1178 errType: InvalidJSONError(""), 1179 }, 1180 { 1181 name: "invalid-type", 1182 json: `"string"`, 1183 expectedResult: 0, 1184 err: true, 1185 errType: InvalidUnmarshalError(""), 1186 }, 1187 } 1188 for _, testCase := range testCases { 1189 t.Run(testCase.name, func(t *testing.T) { 1190 json := []byte(testCase.json) 1191 var v = (*int64)(nil) 1192 err := Unmarshal(json, &v) 1193 if testCase.err { 1194 assert.NotNil(t, err, "Err must not be nil") 1195 if testCase.errType != nil { 1196 assert.IsType( 1197 t, 1198 testCase.errType, 1199 err, 1200 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 1201 ) 1202 } 1203 return 1204 } 1205 assert.Nil(t, err, "Err must be nil") 1206 if testCase.resultIsNil { 1207 assert.Nil(t, v) 1208 } else { 1209 assert.Equal(t, testCase.expectedResult, *v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 1210 } 1211 }) 1212 } 1213 t.Run("decoder-api-invalid-json", func(t *testing.T) { 1214 var v = new(int64) 1215 err := Unmarshal([]byte(``), &v) 1216 assert.NotNil(t, err, "Err must not be nil") 1217 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 1218 }) 1219 t.Run("decoder-api-invalid-json2", func(t *testing.T) { 1220 var v = new(int64) 1221 var dec = NewDecoder(strings.NewReader(``)) 1222 err := dec.Int64Null(&v) 1223 assert.NotNil(t, err, "Err must not be nil") 1224 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 1225 }) 1226 } 1227 1228 func TestDecoderInt32(t *testing.T) { 1229 testCases := []struct { 1230 name string 1231 json string 1232 expectedResult int32 1233 err bool 1234 errType interface{} 1235 }{ 1236 { 1237 name: "basic-positive", 1238 json: "100", 1239 expectedResult: 100, 1240 }, 1241 { 1242 name: "basic-positive2", 1243 json: " 1039405", 1244 expectedResult: 1039405, 1245 }, 1246 { 1247 name: "basic-negative", 1248 json: "-2", 1249 expectedResult: -2, 1250 }, 1251 { 1252 name: "basic-null", 1253 json: "null", 1254 expectedResult: 0, 1255 }, 1256 { 1257 name: "basic-null-err", 1258 json: "nxll", 1259 expectedResult: 0, 1260 err: true, 1261 errType: InvalidJSONError(""), 1262 }, 1263 { 1264 name: "basic-negative-err", 1265 json: "-", 1266 expectedResult: 0, 1267 err: true, 1268 errType: InvalidJSONError(""), 1269 }, 1270 { 1271 name: "basic-negative-err", 1272 json: "-q", 1273 expectedResult: 0, 1274 err: true, 1275 errType: InvalidJSONError(""), 1276 }, 1277 { 1278 name: "basic-skip-data-err", 1279 json: "trua", 1280 expectedResult: 0, 1281 err: true, 1282 errType: InvalidJSONError(""), 1283 }, 1284 { 1285 name: "basic-negative2", 1286 json: "-2349557", 1287 expectedResult: -2349557, 1288 }, 1289 { 1290 name: "basic-big", 1291 json: " 2147483647", 1292 expectedResult: 2147483647, 1293 }, 1294 { 1295 name: "basic-big-overflow", 1296 json: " 2147483648", 1297 expectedResult: 0, 1298 err: true, 1299 }, 1300 { 1301 name: "basic-big-overflow", 1302 json: " 2147483657", 1303 expectedResult: 0, 1304 err: true, 1305 }, 1306 { 1307 name: "basic-big-overflow2", 1308 json: "21474836483", 1309 expectedResult: 0, 1310 err: true, 1311 }, 1312 { 1313 name: "basic-float", 1314 json: "2.4595", 1315 expectedResult: 2, 1316 }, 1317 { 1318 name: "basic-float2", 1319 json: "-7.8876", 1320 expectedResult: -7, 1321 }, 1322 { 1323 name: "basic-float2", 1324 json: "-7.8876a", 1325 expectedResult: 0, 1326 err: true, 1327 }, 1328 { 1329 name: "basic-exponent-positive-positive-exp", 1330 json: "1.2E2", 1331 expectedResult: 120, 1332 }, 1333 { 1334 name: "exponent-err-too-big", 1335 json: "0e10000000000000000000", 1336 expectedResult: 0, 1337 err: true, 1338 }, 1339 { 1340 name: "exponent-err-too-big", 1341 json: "0.1932242242424244244e1000000000000000000000000", 1342 expectedResult: 0, 1343 err: true, 1344 }, 1345 { 1346 name: "basic-exponent-positive-positive-exp1", 1347 json: "3.5e+005 ", 1348 expectedResult: 350000, 1349 }, 1350 { 1351 name: "basic-exponent-positive-positive-exp1", 1352 json: "3.5e+005", 1353 expectedResult: 350000, 1354 }, 1355 { 1356 name: "basic-exponent-positive-positive-exp2", 1357 json: "5e+06", 1358 expectedResult: 5000000, 1359 }, 1360 { 1361 name: "basic-exponent-positive-positive-exp3", 1362 json: "3e+3", 1363 expectedResult: 3000, 1364 }, 1365 { 1366 name: "basic-exponent-positive-positive-exp4", 1367 json: "8e+005 ", 1368 expectedResult: 800000, 1369 }, 1370 { 1371 name: "basic-exponent-positive-negative-exp", 1372 json: "1e-2 ", 1373 expectedResult: 0, 1374 }, 1375 { 1376 name: "basic-exponent-positive-negative-exp2", 1377 json: "5E-6", 1378 expectedResult: 0, 1379 }, 1380 { 1381 name: "basic-exponent-positive-negative-exp3", 1382 json: "3e-3", 1383 expectedResult: 0, 1384 }, 1385 { 1386 name: "basic-exponent-positive-negative-exp4", 1387 json: "8e-005", 1388 expectedResult: 0, 1389 }, 1390 { 1391 name: "basic-exponent-negative-positive-exp", 1392 json: "-1e2", 1393 expectedResult: -100, 1394 }, 1395 { 1396 name: "basic-exponent-negative-positive-exp2", 1397 json: "-5e+06", 1398 expectedResult: -5000000, 1399 }, 1400 { 1401 name: "basic-exponent-negative-positive-exp3", 1402 json: "-3e03", 1403 expectedResult: -3000, 1404 }, 1405 { 1406 name: "basic-exponent-negative-positive-exp4", 1407 json: "-8e+005", 1408 expectedResult: -800000, 1409 }, 1410 { 1411 name: "before-exp-err-too-big", 1412 json: "10.11231242345325435464364643e1", 1413 expectedResult: 0, 1414 err: true, 1415 }, 1416 { 1417 name: "exponent-err-", 1418 json: "0.1e", 1419 expectedResult: 0, 1420 err: true, 1421 }, 1422 { 1423 name: "exponent-err-too-big", 1424 json: "0.1e10000000000000000000", 1425 expectedResult: 0, 1426 err: true, 1427 }, 1428 { 1429 name: "exponent-err-too-big", 1430 json: "0.1e1000000000", 1431 expectedResult: 0, 1432 err: true, 1433 }, 1434 { 1435 name: "exponent-err-too-big", 1436 json: "0.1e1000000000 ", 1437 expectedResult: 0, 1438 err: true, 1439 }, 1440 { 1441 name: "exponent-err-too-big", 1442 json: "0e100000000000", 1443 expectedResult: 0, 1444 err: true, 1445 }, 1446 { 1447 name: "exponent-err-too-big", 1448 json: "0e100000000000 ", 1449 expectedResult: 0, 1450 err: true, 1451 }, 1452 { 1453 name: "basic-exponent-err", 1454 json: "3e", 1455 expectedResult: 0, 1456 err: true, 1457 }, 1458 { 1459 name: "error3", 1460 json: "0E40", 1461 expectedResult: 0, 1462 err: true, 1463 errType: InvalidJSONError(""), 1464 }, 1465 { 1466 name: "error4", 1467 json: "0.E----", 1468 expectedResult: 0, 1469 err: true, 1470 errType: InvalidJSONError(""), 1471 }, 1472 { 1473 name: "error5", 1474 json: "0E40", 1475 expectedResult: 0, 1476 err: true, 1477 errType: InvalidJSONError(""), 1478 }, 1479 { 1480 name: "error6", 1481 json: "0.e-9", 1482 expectedResult: 0, 1483 err: true, 1484 errType: InvalidJSONError(""), 1485 }, 1486 { 1487 name: "error7", 1488 json: "-5.e-2", 1489 expectedResult: 0, 1490 err: true, 1491 errType: InvalidJSONError(""), 1492 }, 1493 { 1494 name: "basic-float", 1495 json: "8.32 ", 1496 expectedResult: 8, 1497 }, 1498 { 1499 name: "error", 1500 json: "83zez4", 1501 expectedResult: 0, 1502 err: true, 1503 errType: InvalidJSONError(""), 1504 }, 1505 { 1506 name: "error", 1507 json: "8ea00$aa5", 1508 expectedResult: 0, 1509 err: true, 1510 errType: InvalidJSONError(""), 1511 }, 1512 { 1513 name: "error2", 1514 json: "-8e+00$aa5", 1515 expectedResult: 0, 1516 err: true, 1517 }, 1518 { 1519 name: "invalid-type", 1520 json: `"string"`, 1521 expectedResult: 0, 1522 err: true, 1523 errType: InvalidUnmarshalError(""), 1524 }, 1525 } 1526 for _, testCase := range testCases { 1527 t.Run(testCase.name, func(t *testing.T) { 1528 json := []byte(testCase.json) 1529 var v int32 1530 err := Unmarshal(json, &v) 1531 if testCase.err { 1532 assert.NotNil(t, err, "Err must not be nil") 1533 if testCase.errType != nil { 1534 assert.IsType( 1535 t, 1536 testCase.errType, 1537 err, 1538 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 1539 ) 1540 } 1541 } else { 1542 assert.Nil(t, err, "Err must be nil") 1543 } 1544 assert.Equal(t, testCase.expectedResult, v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 1545 }) 1546 } 1547 t.Run("pool-error", func(t *testing.T) { 1548 result := int32(1) 1549 dec := NewDecoder(nil) 1550 dec.Release() 1551 defer func() { 1552 err := recover() 1553 assert.NotNil(t, err, "err shouldnt be nil") 1554 assert.IsType(t, InvalidUsagePooledDecoderError(""), err, "err should be of type InvalidUsagePooledDecoderError") 1555 }() 1556 _ = dec.DecodeInt32(&result) 1557 assert.True(t, false, "should not be called as decoder should have panicked") 1558 1559 }) 1560 t.Run("decoder-api", func(t *testing.T) { 1561 var v int32 1562 dec := NewDecoder(strings.NewReader(`33`)) 1563 defer dec.Release() 1564 err := dec.DecodeInt32(&v) 1565 assert.Nil(t, err, "Err must be nil") 1566 assert.Equal(t, int32(33), v, "v must be equal to 33") 1567 }) 1568 t.Run("decoder-api2", func(t *testing.T) { 1569 var v int32 1570 dec := NewDecoder(strings.NewReader(`33`)) 1571 defer dec.Release() 1572 err := dec.Decode(&v) 1573 assert.Nil(t, err, "Err must be nil") 1574 assert.Equal(t, int32(33), v, "v must be equal to 33") 1575 }) 1576 t.Run("decoder-api-invalid-json", func(t *testing.T) { 1577 var v int32 1578 dec := NewDecoder(strings.NewReader(``)) 1579 defer dec.Release() 1580 err := dec.DecodeInt32(&v) 1581 assert.NotNil(t, err, "Err must not be nil") 1582 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 1583 }) 1584 } 1585 func TestDecoderInt32Null(t *testing.T) { 1586 testCases := []struct { 1587 name string 1588 json string 1589 expectedResult int32 1590 err bool 1591 errType interface{} 1592 resultIsNil bool 1593 }{ 1594 { 1595 name: "basic-positive", 1596 json: "100", 1597 expectedResult: 100, 1598 }, 1599 { 1600 name: "basic-positive2", 1601 json: " 1039405", 1602 expectedResult: 1039405, 1603 }, 1604 { 1605 name: "basic-negative", 1606 json: "-2", 1607 expectedResult: -2, 1608 }, 1609 { 1610 name: "basic-null", 1611 json: "null", 1612 expectedResult: 0, 1613 resultIsNil: true, 1614 }, 1615 { 1616 name: "basic-null-err", 1617 json: "nxll", 1618 expectedResult: 0, 1619 err: true, 1620 errType: InvalidJSONError(""), 1621 }, 1622 { 1623 name: "basic-negative-err", 1624 json: "-", 1625 expectedResult: 0, 1626 err: true, 1627 errType: InvalidJSONError(""), 1628 }, 1629 { 1630 name: "basic-negative-err", 1631 json: "-q", 1632 expectedResult: 0, 1633 err: true, 1634 errType: InvalidJSONError(""), 1635 }, 1636 { 1637 name: "basic-skip-data-err", 1638 json: "trua", 1639 expectedResult: 0, 1640 err: true, 1641 errType: InvalidJSONError(""), 1642 }, 1643 { 1644 name: "basic-negative2", 1645 json: "-2349557", 1646 expectedResult: -2349557, 1647 }, 1648 { 1649 name: "basic-big", 1650 json: " 2147483647", 1651 expectedResult: 2147483647, 1652 }, 1653 { 1654 name: "basic-big-overflow", 1655 json: " 2147483648", 1656 expectedResult: 0, 1657 err: true, 1658 }, 1659 { 1660 name: "basic-big-overflow", 1661 json: " 2147483657", 1662 expectedResult: 0, 1663 err: true, 1664 }, 1665 { 1666 name: "basic-big-overflow2", 1667 json: "21474836483", 1668 expectedResult: 0, 1669 err: true, 1670 }, 1671 { 1672 name: "basic-float", 1673 json: "2.4595", 1674 expectedResult: 2, 1675 }, 1676 { 1677 name: "basic-float2", 1678 json: "-7.8876", 1679 expectedResult: -7, 1680 }, 1681 { 1682 name: "basic-float2", 1683 json: "-7.8876a", 1684 expectedResult: 0, 1685 err: true, 1686 }, 1687 { 1688 name: "basic-exponent-positive-positive-exp", 1689 json: "1.2E2", 1690 expectedResult: 120, 1691 }, 1692 { 1693 name: "exponent-err-too-big", 1694 json: "0e10000000000000000000", 1695 expectedResult: 0, 1696 err: true, 1697 }, 1698 { 1699 name: "exponent-err-too-big", 1700 json: "0.1932242242424244244e1000000000000000000000000", 1701 expectedResult: 0, 1702 err: true, 1703 }, 1704 { 1705 name: "basic-exponent-positive-positive-exp1", 1706 json: "3.5e+005 ", 1707 expectedResult: 350000, 1708 }, 1709 { 1710 name: "basic-exponent-positive-positive-exp1", 1711 json: "3.5e+005", 1712 expectedResult: 350000, 1713 }, 1714 { 1715 name: "basic-exponent-positive-positive-exp2", 1716 json: "5e+06", 1717 expectedResult: 5000000, 1718 }, 1719 { 1720 name: "basic-exponent-positive-positive-exp3", 1721 json: "3e+3", 1722 expectedResult: 3000, 1723 }, 1724 { 1725 name: "basic-exponent-positive-positive-exp4", 1726 json: "8e+005 ", 1727 expectedResult: 800000, 1728 }, 1729 { 1730 name: "basic-exponent-positive-negative-exp", 1731 json: "1e-2 ", 1732 expectedResult: 0, 1733 }, 1734 { 1735 name: "basic-exponent-positive-negative-exp2", 1736 json: "5E-6", 1737 expectedResult: 0, 1738 }, 1739 { 1740 name: "basic-exponent-positive-negative-exp3", 1741 json: "3e-3", 1742 expectedResult: 0, 1743 }, 1744 { 1745 name: "basic-exponent-positive-negative-exp4", 1746 json: "8e-005", 1747 expectedResult: 0, 1748 }, 1749 { 1750 name: "basic-exponent-negative-positive-exp", 1751 json: "-1e2", 1752 expectedResult: -100, 1753 }, 1754 { 1755 name: "basic-exponent-negative-positive-exp2", 1756 json: "-5e+06", 1757 expectedResult: -5000000, 1758 }, 1759 { 1760 name: "basic-exponent-negative-positive-exp3", 1761 json: "-3e03", 1762 expectedResult: -3000, 1763 }, 1764 { 1765 name: "basic-exponent-negative-positive-exp4", 1766 json: "-8e+005", 1767 expectedResult: -800000, 1768 }, 1769 { 1770 name: "exponent-err-", 1771 json: "0.1e", 1772 expectedResult: 0, 1773 err: true, 1774 }, 1775 { 1776 name: "exponent-err-too-big", 1777 json: "0.1e10000000000000000000", 1778 expectedResult: 0, 1779 err: true, 1780 }, 1781 { 1782 name: "exponent-err-too-big", 1783 json: "0.1e1000000000", 1784 expectedResult: 0, 1785 err: true, 1786 }, 1787 { 1788 name: "exponent-err-too-big", 1789 json: "0.1e1000000000 ", 1790 expectedResult: 0, 1791 err: true, 1792 }, 1793 { 1794 name: "exponent-err-too-big", 1795 json: "0e100000000000", 1796 expectedResult: 0, 1797 err: true, 1798 }, 1799 { 1800 name: "exponent-err-too-big", 1801 json: "0e100000000000 ", 1802 expectedResult: 0, 1803 err: true, 1804 }, 1805 { 1806 name: "basic-exponent-err", 1807 json: "3e", 1808 expectedResult: 0, 1809 err: true, 1810 }, 1811 { 1812 name: "error3", 1813 json: "0E40", 1814 expectedResult: 0, 1815 err: true, 1816 errType: InvalidJSONError(""), 1817 }, 1818 { 1819 name: "error4", 1820 json: "0.E----", 1821 expectedResult: 0, 1822 err: true, 1823 errType: InvalidJSONError(""), 1824 }, 1825 { 1826 name: "error5", 1827 json: "0E40", 1828 expectedResult: 0, 1829 err: true, 1830 errType: InvalidJSONError(""), 1831 }, 1832 { 1833 name: "error6", 1834 json: "0.e-9", 1835 expectedResult: 0, 1836 err: true, 1837 errType: InvalidJSONError(""), 1838 }, 1839 { 1840 name: "error7", 1841 json: "-5.e-2", 1842 expectedResult: 0, 1843 err: true, 1844 errType: InvalidJSONError(""), 1845 }, 1846 { 1847 name: "basic-float", 1848 json: "8.32 ", 1849 expectedResult: 8, 1850 }, 1851 { 1852 name: "error", 1853 json: "83zez4", 1854 expectedResult: 0, 1855 err: true, 1856 errType: InvalidJSONError(""), 1857 }, 1858 { 1859 name: "error", 1860 json: "8ea00$aa5", 1861 expectedResult: 0, 1862 err: true, 1863 errType: InvalidJSONError(""), 1864 }, 1865 { 1866 name: "error2", 1867 json: "-8e+00$aa5", 1868 expectedResult: 0, 1869 err: true, 1870 }, 1871 { 1872 name: "invalid-type", 1873 json: `"string"`, 1874 expectedResult: 0, 1875 err: true, 1876 errType: InvalidUnmarshalError(""), 1877 }, 1878 } 1879 for _, testCase := range testCases { 1880 t.Run(testCase.name, func(t *testing.T) { 1881 json := []byte(testCase.json) 1882 var v = (*int32)(nil) 1883 err := Unmarshal(json, &v) 1884 if testCase.err { 1885 assert.NotNil(t, err, "Err must not be nil") 1886 if testCase.errType != nil { 1887 assert.IsType( 1888 t, 1889 testCase.errType, 1890 err, 1891 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 1892 ) 1893 } 1894 return 1895 } 1896 1897 assert.Nil(t, err, "Err must be nil") 1898 if testCase.resultIsNil { 1899 assert.Nil(t, v) 1900 } else { 1901 assert.Equal(t, testCase.expectedResult, *v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 1902 } 1903 }) 1904 } 1905 t.Run("decoder-api-invalid-json", func(t *testing.T) { 1906 var v = new(int32) 1907 err := Unmarshal([]byte(``), &v) 1908 assert.NotNil(t, err, "Err must not be nil") 1909 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 1910 }) 1911 t.Run("decoder-api-invalid-json2", func(t *testing.T) { 1912 var v = new(int32) 1913 var dec = NewDecoder(strings.NewReader(``)) 1914 err := dec.Int32Null(&v) 1915 assert.NotNil(t, err, "Err must not be nil") 1916 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 1917 }) 1918 } 1919 1920 func TestDecoderInt16(t *testing.T) { 1921 testCases := []struct { 1922 name string 1923 json string 1924 expectedResult int16 1925 err bool 1926 errType interface{} 1927 }{ 1928 { 1929 name: "basic-positive", 1930 json: "100", 1931 expectedResult: 100, 1932 }, 1933 { 1934 name: "basic-positive2", 1935 json: " 5321", 1936 expectedResult: 5321, 1937 }, 1938 { 1939 name: "basic-negative", 1940 json: "-2", 1941 expectedResult: -2, 1942 }, 1943 { 1944 name: "basic-null", 1945 json: "null", 1946 expectedResult: 0, 1947 }, 1948 { 1949 name: "basic-null-err", 1950 json: "nxll", 1951 expectedResult: 0, 1952 err: true, 1953 errType: InvalidJSONError(""), 1954 }, 1955 { 1956 name: "basic-negative-err", 1957 json: "-", 1958 expectedResult: 0, 1959 err: true, 1960 errType: InvalidJSONError(""), 1961 }, 1962 { 1963 name: "basic-negative-err", 1964 json: "-q", 1965 expectedResult: 0, 1966 err: true, 1967 errType: InvalidJSONError(""), 1968 }, 1969 { 1970 name: "basic-skip-data-err", 1971 json: "trua", 1972 expectedResult: 0, 1973 err: true, 1974 errType: InvalidJSONError(""), 1975 }, 1976 { 1977 name: "basic-negative2", 1978 json: "-2456", 1979 expectedResult: -2456, 1980 }, 1981 { 1982 name: "basic-big", 1983 json: " 24566", 1984 expectedResult: 24566, 1985 }, 1986 { 1987 name: "basic-big-overflow", 1988 json: "66535", 1989 expectedResult: 0, 1990 err: true, 1991 }, 1992 { 1993 name: "basic-big-overflow", 1994 json: "32768", 1995 expectedResult: 0, 1996 err: true, 1997 }, 1998 { 1999 name: "basic-big-overflow", 2000 json: " 2147483648", 2001 expectedResult: 0, 2002 err: true, 2003 }, 2004 { 2005 name: "basic-big-overflow2", 2006 json: "21474836483", 2007 expectedResult: 0, 2008 err: true, 2009 }, 2010 { 2011 name: "basic-float", 2012 json: "2.4595", 2013 expectedResult: 2, 2014 }, 2015 { 2016 name: "basic-float2", 2017 json: "-7.8876", 2018 expectedResult: -7, 2019 }, 2020 { 2021 name: "basic-float2", 2022 json: "-7.8876a", 2023 expectedResult: 0, 2024 err: true, 2025 }, 2026 { 2027 name: "basic-exponent-positive-positive-exp", 2028 json: "1.2E2", 2029 expectedResult: 120, 2030 }, 2031 { 2032 name: "exponent too big", 2033 json: "1000.202302302422324435342E2", 2034 err: true, 2035 }, 2036 { 2037 name: "basic-exponent-positive-positive-exp1", 2038 json: "3.5e+001 ", 2039 expectedResult: 35, 2040 }, 2041 { 2042 name: "basic-exponent-positive-positive-exp1", 2043 json: "3.5e+002", 2044 expectedResult: 350, 2045 }, 2046 { 2047 name: "basic-exponent-positive-positive-exp2", 2048 json: "5e+03", 2049 expectedResult: 5000, 2050 }, 2051 { 2052 name: "basic-exponent-positive-positive-exp3", 2053 json: "3e+3", 2054 expectedResult: 3000, 2055 }, 2056 { 2057 name: "basic-exponent-positive-positive-exp4", 2058 json: "8e+02 ", 2059 expectedResult: 800, 2060 }, 2061 { 2062 name: "basic-exponent-positive-negative-exp", 2063 json: "1e-2 ", 2064 expectedResult: 0, 2065 }, 2066 { 2067 name: "basic-exponent-positive-negative-exp2", 2068 json: "5E-6", 2069 expectedResult: 0, 2070 }, 2071 { 2072 name: "basic-exponent-positive-negative-exp3", 2073 json: "3e-3", 2074 expectedResult: 0, 2075 }, 2076 { 2077 name: "basic-exponent-positive-negative-exp4", 2078 json: "8e-005", 2079 expectedResult: 0, 2080 }, 2081 { 2082 name: "basic-exponent-negative-positive-exp", 2083 json: "-1e2", 2084 expectedResult: -100, 2085 }, 2086 { 2087 name: "exponent-err-", 2088 json: "0.1e", 2089 expectedResult: 0, 2090 err: true, 2091 }, 2092 { 2093 name: "exponent-err-too-big", 2094 json: "0.1e10000000000000000000", 2095 expectedResult: 0, 2096 err: true, 2097 }, 2098 { 2099 name: "exponent-err-too-big", 2100 json: "0.1e10000000000 ", 2101 expectedResult: 0, 2102 err: true, 2103 }, 2104 { 2105 name: "exponent-err-too-big", 2106 json: "0e10000000000 ", 2107 expectedResult: 0, 2108 err: true, 2109 }, 2110 { 2111 name: "exponent-err-too-big", 2112 json: "0.1932242242424244244e1000000000000000000000000", 2113 expectedResult: 0, 2114 err: true, 2115 }, 2116 { 2117 name: "basic-exponent-negative-positive-exp2", 2118 json: "-5e+03", 2119 expectedResult: -5000, 2120 }, 2121 { 2122 name: "basic-exponent-negative-positive-exp3", 2123 json: "-3e03", 2124 expectedResult: -3000, 2125 }, 2126 { 2127 name: "basic-exponent-negative-positive-exp4", 2128 json: "-8e+003", 2129 expectedResult: -8000, 2130 }, 2131 { 2132 name: "basic-exponent-err", 2133 json: "3e", 2134 expectedResult: 0, 2135 err: true, 2136 }, 2137 { 2138 name: "basic-float", 2139 json: "8.32 ", 2140 expectedResult: 8, 2141 }, 2142 { 2143 name: "error", 2144 json: "83zez4", 2145 expectedResult: 0, 2146 err: true, 2147 errType: InvalidJSONError(""), 2148 }, 2149 { 2150 name: "error", 2151 json: "8ea00$aa5", 2152 expectedResult: 0, 2153 err: true, 2154 errType: InvalidJSONError(""), 2155 }, 2156 { 2157 name: "error2", 2158 json: "-8e+00$aa5", 2159 expectedResult: 0, 2160 err: true, 2161 }, 2162 { 2163 name: "error3", 2164 json: "0E40", 2165 expectedResult: 0, 2166 err: true, 2167 errType: InvalidJSONError(""), 2168 }, 2169 { 2170 name: "error4", 2171 json: "0.E----", 2172 expectedResult: 0, 2173 err: true, 2174 errType: InvalidJSONError(""), 2175 }, 2176 { 2177 name: "error5", 2178 json: "0E40", 2179 expectedResult: 0, 2180 err: true, 2181 errType: InvalidJSONError(""), 2182 }, 2183 { 2184 name: "error6", 2185 json: "0.e-9", 2186 expectedResult: 0, 2187 err: true, 2188 errType: InvalidJSONError(""), 2189 }, 2190 { 2191 name: "error7", 2192 json: "0.e", 2193 expectedResult: 0, 2194 err: true, 2195 errType: InvalidJSONError(""), 2196 }, 2197 { 2198 name: "error8", 2199 json: "-5.e-2", 2200 expectedResult: 0, 2201 err: true, 2202 errType: InvalidJSONError(""), 2203 }, 2204 { 2205 name: "invalid-type", 2206 json: `"string"`, 2207 expectedResult: 0, 2208 err: true, 2209 errType: InvalidUnmarshalError(""), 2210 }, 2211 } 2212 for _, testCase := range testCases { 2213 t.Run(testCase.name, func(t *testing.T) { 2214 json := []byte(testCase.json) 2215 var v int16 2216 err := Unmarshal(json, &v) 2217 if testCase.err { 2218 assert.NotNil(t, err, "Err must not be nil") 2219 if testCase.errType != nil { 2220 assert.IsType( 2221 t, 2222 testCase.errType, 2223 err, 2224 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 2225 ) 2226 } 2227 } else { 2228 assert.Nil(t, err, "Err must be nil") 2229 } 2230 assert.Equal(t, testCase.expectedResult, v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 2231 }) 2232 } 2233 t.Run("pool-error", func(t *testing.T) { 2234 result := int16(1) 2235 dec := NewDecoder(nil) 2236 dec.Release() 2237 defer func() { 2238 err := recover() 2239 assert.NotNil(t, err, "err shouldnt be nil") 2240 assert.IsType(t, InvalidUsagePooledDecoderError(""), err, "err should be of type InvalidUsagePooledDecoderError") 2241 }() 2242 _ = dec.DecodeInt16(&result) 2243 assert.True(t, false, "should not be called as decoder should have panicked") 2244 2245 }) 2246 t.Run("decoder-api", func(t *testing.T) { 2247 var v int16 2248 dec := NewDecoder(strings.NewReader(`33`)) 2249 defer dec.Release() 2250 err := dec.DecodeInt16(&v) 2251 assert.Nil(t, err, "Err must be nil") 2252 assert.Equal(t, int16(33), v, "v must be equal to 33") 2253 }) 2254 t.Run("decoder-api2", func(t *testing.T) { 2255 var v int16 2256 dec := NewDecoder(strings.NewReader(`33`)) 2257 defer dec.Release() 2258 err := dec.Decode(&v) 2259 assert.Nil(t, err, "Err must be nil") 2260 assert.Equal(t, int16(33), v, "v must be equal to 33") 2261 }) 2262 t.Run("decoder-api-invalid-json", func(t *testing.T) { 2263 var v int16 2264 dec := NewDecoder(strings.NewReader(``)) 2265 defer dec.Release() 2266 err := dec.DecodeInt16(&v) 2267 assert.NotNil(t, err, "Err must not be nil") 2268 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 2269 }) 2270 } 2271 func TestDecoderInt16Null(t *testing.T) { 2272 testCases := []struct { 2273 name string 2274 json string 2275 expectedResult int16 2276 err bool 2277 errType interface{} 2278 resultIsNil bool 2279 }{ 2280 { 2281 name: "basic-positive", 2282 json: "100", 2283 expectedResult: 100, 2284 }, 2285 { 2286 name: "basic-positive2", 2287 json: " 5321", 2288 expectedResult: 5321, 2289 }, 2290 { 2291 name: "basic-negative", 2292 json: "-2", 2293 expectedResult: -2, 2294 }, 2295 { 2296 name: "basic-null", 2297 json: "null", 2298 expectedResult: 0, 2299 resultIsNil: true, 2300 }, 2301 { 2302 name: "basic-null-err", 2303 json: "nxll", 2304 expectedResult: 0, 2305 err: true, 2306 errType: InvalidJSONError(""), 2307 }, 2308 { 2309 name: "basic-negative-err", 2310 json: "-", 2311 expectedResult: 0, 2312 err: true, 2313 errType: InvalidJSONError(""), 2314 }, 2315 { 2316 name: "basic-negative-err", 2317 json: "-q", 2318 expectedResult: 0, 2319 err: true, 2320 errType: InvalidJSONError(""), 2321 }, 2322 { 2323 name: "basic-skip-data-err", 2324 json: "trua", 2325 expectedResult: 0, 2326 err: true, 2327 errType: InvalidJSONError(""), 2328 }, 2329 { 2330 name: "basic-negative2", 2331 json: "-2456", 2332 expectedResult: -2456, 2333 }, 2334 { 2335 name: "basic-big", 2336 json: " 24566", 2337 expectedResult: 24566, 2338 }, 2339 { 2340 name: "basic-big-overflow", 2341 json: "66535", 2342 expectedResult: 0, 2343 err: true, 2344 }, 2345 { 2346 name: "basic-big-overflow", 2347 json: "32768", 2348 expectedResult: 0, 2349 err: true, 2350 }, 2351 { 2352 name: "basic-big-overflow", 2353 json: " 2147483648", 2354 expectedResult: 0, 2355 err: true, 2356 }, 2357 { 2358 name: "basic-big-overflow2", 2359 json: "21474836483", 2360 expectedResult: 0, 2361 err: true, 2362 }, 2363 { 2364 name: "basic-float", 2365 json: "2.4595", 2366 expectedResult: 2, 2367 }, 2368 { 2369 name: "basic-float2", 2370 json: "-7.8876", 2371 expectedResult: -7, 2372 }, 2373 { 2374 name: "basic-float2", 2375 json: "-7.8876a", 2376 expectedResult: 0, 2377 err: true, 2378 }, 2379 { 2380 name: "basic-exponent-positive-positive-exp", 2381 json: "1.2E2", 2382 expectedResult: 120, 2383 }, 2384 { 2385 name: "basic-exponent-positive-positive-exp1", 2386 json: "3.5e+001 ", 2387 expectedResult: 35, 2388 }, 2389 { 2390 name: "basic-exponent-positive-positive-exp1", 2391 json: "3.5e+002", 2392 expectedResult: 350, 2393 }, 2394 { 2395 name: "basic-exponent-positive-positive-exp2", 2396 json: "5e+03", 2397 expectedResult: 5000, 2398 }, 2399 { 2400 name: "basic-exponent-positive-positive-exp3", 2401 json: "3e+3", 2402 expectedResult: 3000, 2403 }, 2404 { 2405 name: "basic-exponent-positive-positive-exp4", 2406 json: "8e+02 ", 2407 expectedResult: 800, 2408 }, 2409 { 2410 name: "basic-exponent-positive-negative-exp", 2411 json: "1e-2 ", 2412 expectedResult: 0, 2413 }, 2414 { 2415 name: "basic-exponent-positive-negative-exp2", 2416 json: "5E-6", 2417 expectedResult: 0, 2418 }, 2419 { 2420 name: "basic-exponent-positive-negative-exp3", 2421 json: "3e-3", 2422 expectedResult: 0, 2423 }, 2424 { 2425 name: "basic-exponent-positive-negative-exp4", 2426 json: "8e-005", 2427 expectedResult: 0, 2428 }, 2429 { 2430 name: "basic-exponent-negative-positive-exp", 2431 json: "-1e2", 2432 expectedResult: -100, 2433 }, 2434 { 2435 name: "exponent-err-", 2436 json: "0.1e", 2437 expectedResult: 0, 2438 err: true, 2439 }, 2440 { 2441 name: "exponent-err-too-big", 2442 json: "0.1e10000000000000000000", 2443 expectedResult: 0, 2444 err: true, 2445 }, 2446 { 2447 name: "exponent-err-too-big", 2448 json: "0.1e10000000000 ", 2449 expectedResult: 0, 2450 err: true, 2451 }, 2452 { 2453 name: "exponent-err-too-big", 2454 json: "0e10000000000 ", 2455 expectedResult: 0, 2456 err: true, 2457 }, 2458 { 2459 name: "exponent-err-too-big", 2460 json: "0.1932242242424244244e1000000000000000000000000", 2461 expectedResult: 0, 2462 err: true, 2463 }, 2464 { 2465 name: "basic-exponent-negative-positive-exp2", 2466 json: "-5e+03", 2467 expectedResult: -5000, 2468 }, 2469 { 2470 name: "basic-exponent-negative-positive-exp3", 2471 json: "-3e03", 2472 expectedResult: -3000, 2473 }, 2474 { 2475 name: "basic-exponent-negative-positive-exp4", 2476 json: "-8e+003", 2477 expectedResult: -8000, 2478 }, 2479 { 2480 name: "basic-exponent-err", 2481 json: "3e", 2482 expectedResult: 0, 2483 err: true, 2484 }, 2485 { 2486 name: "basic-float", 2487 json: "8.32 ", 2488 expectedResult: 8, 2489 }, 2490 { 2491 name: "error", 2492 json: "83zez4", 2493 expectedResult: 0, 2494 err: true, 2495 errType: InvalidJSONError(""), 2496 }, 2497 { 2498 name: "error", 2499 json: "8ea00$aa5", 2500 expectedResult: 0, 2501 err: true, 2502 errType: InvalidJSONError(""), 2503 }, 2504 { 2505 name: "error2", 2506 json: "-8e+00$aa5", 2507 expectedResult: 0, 2508 err: true, 2509 }, 2510 { 2511 name: "error3", 2512 json: "0E40", 2513 expectedResult: 0, 2514 err: true, 2515 errType: InvalidJSONError(""), 2516 }, 2517 { 2518 name: "error4", 2519 json: "0.E----", 2520 expectedResult: 0, 2521 err: true, 2522 errType: InvalidJSONError(""), 2523 }, 2524 { 2525 name: "error5", 2526 json: "0E40", 2527 expectedResult: 0, 2528 err: true, 2529 errType: InvalidJSONError(""), 2530 }, 2531 { 2532 name: "error6", 2533 json: "0.e-9", 2534 expectedResult: 0, 2535 err: true, 2536 errType: InvalidJSONError(""), 2537 }, 2538 { 2539 name: "error7", 2540 json: "0.e", 2541 expectedResult: 0, 2542 err: true, 2543 errType: InvalidJSONError(""), 2544 }, 2545 { 2546 name: "error8", 2547 json: "-5.e-2", 2548 expectedResult: 0, 2549 err: true, 2550 errType: InvalidJSONError(""), 2551 }, 2552 { 2553 name: "invalid-type", 2554 json: `"string"`, 2555 expectedResult: 0, 2556 err: true, 2557 errType: InvalidUnmarshalError(""), 2558 }, 2559 } 2560 for _, testCase := range testCases { 2561 t.Run(testCase.name, func(t *testing.T) { 2562 json := []byte(testCase.json) 2563 var v = (*int16)(nil) 2564 err := Unmarshal(json, &v) 2565 if testCase.err { 2566 assert.NotNil(t, err, "Err must not be nil") 2567 if testCase.errType != nil { 2568 assert.IsType( 2569 t, 2570 testCase.errType, 2571 err, 2572 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 2573 ) 2574 } 2575 return 2576 } 2577 assert.Nil(t, err, "Err must be nil") 2578 if testCase.resultIsNil { 2579 assert.Nil(t, v) 2580 } else { 2581 assert.Equal(t, testCase.expectedResult, *v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 2582 } 2583 }) 2584 } 2585 t.Run("decoder-api-invalid-json", func(t *testing.T) { 2586 var v = new(int16) 2587 err := Unmarshal([]byte(``), &v) 2588 assert.NotNil(t, err, "Err must not be nil") 2589 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 2590 }) 2591 t.Run("decoder-api-invalid-json2", func(t *testing.T) { 2592 var v = new(int16) 2593 var dec = NewDecoder(strings.NewReader(``)) 2594 err := dec.Int16Null(&v) 2595 assert.NotNil(t, err, "Err must not be nil") 2596 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 2597 }) 2598 } 2599 2600 func TestDecoderInt8(t *testing.T) { 2601 testCases := []struct { 2602 name string 2603 json string 2604 expectedResult int8 2605 err bool 2606 errType interface{} 2607 }{ 2608 { 2609 name: "basic-positive", 2610 json: "100", 2611 expectedResult: 100, 2612 }, 2613 { 2614 name: "basic-positive2", 2615 json: " 127", 2616 expectedResult: 127, 2617 }, 2618 { 2619 name: "basic-negative", 2620 json: "-2", 2621 expectedResult: -2, 2622 }, 2623 { 2624 name: "basic-null", 2625 json: "null", 2626 expectedResult: 0, 2627 }, 2628 { 2629 name: "basic-negative-err", 2630 json: "-", 2631 expectedResult: 0, 2632 err: true, 2633 errType: InvalidJSONError(""), 2634 }, 2635 { 2636 name: "basic-negative-err", 2637 json: "-q", 2638 expectedResult: 0, 2639 err: true, 2640 errType: InvalidJSONError(""), 2641 }, 2642 { 2643 name: "basic-null-err", 2644 json: "nxll", 2645 expectedResult: 0, 2646 err: true, 2647 errType: InvalidJSONError(""), 2648 }, 2649 { 2650 name: "basic-skip-data-err", 2651 json: "trua", 2652 expectedResult: 0, 2653 err: true, 2654 errType: InvalidJSONError(""), 2655 }, 2656 { 2657 name: "basic-negative2", 2658 json: "-123", 2659 expectedResult: -123, 2660 }, 2661 { 2662 name: "basic-big", 2663 json: " 43", 2664 expectedResult: 43, 2665 }, 2666 { 2667 name: "basic-big-overflow", 2668 json: " 2147483648", 2669 expectedResult: 0, 2670 err: true, 2671 }, 2672 { 2673 name: "basic-big-overflow", 2674 json: "137", 2675 expectedResult: 0, 2676 err: true, 2677 }, 2678 { 2679 name: "basic-big-overflow", 2680 json: "128", 2681 expectedResult: 0, 2682 err: true, 2683 }, 2684 { 2685 name: "basic-big-overflow2", 2686 json: "21474836483", 2687 expectedResult: 0, 2688 err: true, 2689 }, 2690 { 2691 name: "basic-float", 2692 json: "2.4595", 2693 expectedResult: 2, 2694 }, 2695 { 2696 name: "basic-float2", 2697 json: "-7.8876", 2698 expectedResult: -7, 2699 }, 2700 { 2701 name: "basic-float2", 2702 json: "-7.8876a", 2703 expectedResult: 0, 2704 err: true, 2705 }, 2706 { 2707 name: "basic-exponent-positive-positive-exp", 2708 json: "1.2E2", 2709 expectedResult: 120, 2710 }, 2711 { 2712 name: "basic-exponent-positive-positive-exp1", 2713 json: "3.5e+001 ", 2714 expectedResult: 35, 2715 }, 2716 { 2717 name: "basic-exponent-positive-positive-exp1", 2718 json: "3.5e+001", 2719 expectedResult: 35, 2720 }, 2721 { 2722 name: "basic-exponent-positive-positive-exp2", 2723 json: "5e+01", 2724 expectedResult: 50, 2725 }, 2726 { 2727 name: "basic-exponent-positive-negative-exp", 2728 json: "1e-2 ", 2729 expectedResult: 0, 2730 }, 2731 { 2732 name: "basic-exponent-positive-negative-exp2", 2733 json: "5E-6", 2734 expectedResult: 0, 2735 }, 2736 { 2737 name: "basic-exponent-positive-negative-exp3", 2738 json: "3e-3", 2739 expectedResult: 0, 2740 }, 2741 { 2742 name: "basic-exponent-positive-negative-exp4", 2743 json: "8e-1 ", 2744 expectedResult: 0, 2745 }, 2746 { 2747 name: "basic-exponent-positive-negative-exp4", 2748 json: "8e1 ", 2749 expectedResult: 80, 2750 }, 2751 { 2752 name: "basic-exponent-positive-negative-exp4", 2753 json: "8e-1", 2754 expectedResult: 0, 2755 }, 2756 { 2757 name: "basic-exponent-negative-positive-exp", 2758 json: "-1e2", 2759 expectedResult: -100, 2760 }, 2761 { 2762 name: "basic-exponent-negative-positive-exp2", 2763 json: "-5e+01", 2764 expectedResult: -50, 2765 }, 2766 { 2767 name: "basic-exponent-negative-positive-exp3", 2768 json: "-3e01", 2769 expectedResult: -30, 2770 }, 2771 2772 { 2773 name: "error3", 2774 json: "0E40", 2775 expectedResult: 0, 2776 err: true, 2777 errType: InvalidJSONError(""), 2778 }, 2779 { 2780 name: "exponent-err-", 2781 json: "0.1e", 2782 expectedResult: 0, 2783 err: true, 2784 }, 2785 { 2786 name: "before-exp-err-too-big", 2787 json: "10.11231242345325435464364643e1", 2788 expectedResult: 0, 2789 err: true, 2790 }, 2791 { 2792 name: "exponent-err-too-big", 2793 json: "0.1e10000000000000000000", 2794 expectedResult: 0, 2795 err: true, 2796 }, 2797 { 2798 name: "exponent-err-too-big", 2799 json: "0.1932242242424244244e1000000000000000000000000", 2800 expectedResult: 0, 2801 err: true, 2802 }, 2803 { 2804 name: "basic-exponent-negative-positive-exp4", 2805 json: "-8e+001", 2806 expectedResult: -80, 2807 }, 2808 { 2809 name: "exponent-err-too-big2", 2810 json: "0e100 ", 2811 expectedResult: 0, 2812 err: true, 2813 }, 2814 { 2815 name: "exponent-err-too-big2", 2816 json: "0.1e100 ", 2817 expectedResult: 0, 2818 err: true, 2819 }, 2820 { 2821 name: "basic-exponent-err", 2822 json: "3e", 2823 expectedResult: 0, 2824 err: true, 2825 }, 2826 { 2827 name: "basic-float", 2828 json: "8.32 ", 2829 expectedResult: 8, 2830 }, 2831 { 2832 name: "error", 2833 json: "83zez4", 2834 expectedResult: 0, 2835 err: true, 2836 errType: InvalidJSONError(""), 2837 }, 2838 { 2839 name: "error", 2840 json: "8ea00$aa5", 2841 expectedResult: 0, 2842 err: true, 2843 errType: InvalidJSONError(""), 2844 }, 2845 { 2846 name: "error2", 2847 json: "-8e+00$aa5", 2848 expectedResult: 0, 2849 err: true, 2850 }, 2851 { 2852 name: "error4", 2853 json: "0.E----", 2854 expectedResult: 0, 2855 err: true, 2856 errType: InvalidJSONError(""), 2857 }, 2858 { 2859 name: "error5", 2860 json: "0E40", 2861 expectedResult: 0, 2862 err: true, 2863 errType: InvalidJSONError(""), 2864 }, 2865 { 2866 name: "error6", 2867 json: "0.e-9", 2868 expectedResult: 0, 2869 err: true, 2870 errType: InvalidJSONError(""), 2871 }, 2872 { 2873 name: "error7", 2874 json: "0.e", 2875 expectedResult: 0, 2876 err: true, 2877 errType: InvalidJSONError(""), 2878 }, 2879 { 2880 name: "error8", 2881 json: "-5.e-2", 2882 expectedResult: 0, 2883 err: true, 2884 errType: InvalidJSONError(""), 2885 }, 2886 { 2887 name: "error8", 2888 json: "-5.01e", 2889 expectedResult: 0, 2890 err: true, 2891 errType: InvalidJSONError(""), 2892 }, 2893 { 2894 name: "invalid-type", 2895 json: `"string"`, 2896 expectedResult: 0, 2897 err: true, 2898 errType: InvalidUnmarshalError(""), 2899 }, 2900 } 2901 for _, testCase := range testCases { 2902 t.Run(testCase.name, func(t *testing.T) { 2903 json := []byte(testCase.json) 2904 var v int8 2905 err := Unmarshal(json, &v) 2906 if testCase.err { 2907 assert.NotNil(t, err, "Err must not be nil") 2908 if testCase.errType != nil { 2909 assert.IsType( 2910 t, 2911 testCase.errType, 2912 err, 2913 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 2914 ) 2915 } 2916 } else { 2917 assert.Nil(t, err, "Err must be nil") 2918 } 2919 assert.Equal(t, testCase.expectedResult, v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 2920 }) 2921 } 2922 t.Run("pool-error", func(t *testing.T) { 2923 result := int8(1) 2924 dec := NewDecoder(nil) 2925 dec.Release() 2926 defer func() { 2927 err := recover() 2928 assert.NotNil(t, err, "err shouldnt be nil") 2929 assert.IsType(t, InvalidUsagePooledDecoderError(""), err, "err should be of type InvalidUsagePooledDecoderError") 2930 }() 2931 _ = dec.DecodeInt8(&result) 2932 assert.True(t, false, "should not be called as decoder should have panicked") 2933 2934 }) 2935 t.Run("decoder-api", func(t *testing.T) { 2936 var v int8 2937 dec := NewDecoder(strings.NewReader(`33`)) 2938 defer dec.Release() 2939 err := dec.DecodeInt8(&v) 2940 assert.Nil(t, err, "Err must be nil") 2941 assert.Equal(t, int8(33), v, "v must be equal to 33") 2942 }) 2943 t.Run("decoder-api2", func(t *testing.T) { 2944 var v int8 2945 dec := NewDecoder(strings.NewReader(`33`)) 2946 defer dec.Release() 2947 err := dec.Decode(&v) 2948 assert.Nil(t, err, "Err must be nil") 2949 assert.Equal(t, int8(33), v, "v must be equal to 33") 2950 }) 2951 t.Run("decoder-api-invalid-json", func(t *testing.T) { 2952 var v int8 2953 dec := NewDecoder(strings.NewReader(``)) 2954 defer dec.Release() 2955 err := dec.DecodeInt8(&v) 2956 assert.NotNil(t, err, "Err must not be nil") 2957 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 2958 }) 2959 } 2960 func TestDecoderInt8Null(t *testing.T) { 2961 testCases := []struct { 2962 name string 2963 json string 2964 expectedResult int8 2965 err bool 2966 errType interface{} 2967 resultIsNil bool 2968 }{ 2969 { 2970 name: "basic-positive", 2971 json: "100", 2972 expectedResult: 100, 2973 }, 2974 { 2975 name: "basic-positive2", 2976 json: " 127", 2977 expectedResult: 127, 2978 }, 2979 { 2980 name: "basic-negative", 2981 json: "-2", 2982 expectedResult: -2, 2983 }, 2984 { 2985 name: "basic-null", 2986 json: "null", 2987 expectedResult: 0, 2988 resultIsNil: true, 2989 }, 2990 { 2991 name: "basic-negative-err", 2992 json: "-", 2993 expectedResult: 0, 2994 err: true, 2995 errType: InvalidJSONError(""), 2996 }, 2997 { 2998 name: "basic-negative-err", 2999 json: "-q", 3000 expectedResult: 0, 3001 err: true, 3002 errType: InvalidJSONError(""), 3003 }, 3004 { 3005 name: "basic-null-err", 3006 json: "nxll", 3007 expectedResult: 0, 3008 err: true, 3009 errType: InvalidJSONError(""), 3010 }, 3011 { 3012 name: "basic-skip-data-err", 3013 json: "trua", 3014 expectedResult: 0, 3015 err: true, 3016 errType: InvalidJSONError(""), 3017 }, 3018 { 3019 name: "basic-negative2", 3020 json: "-123", 3021 expectedResult: -123, 3022 }, 3023 { 3024 name: "basic-big", 3025 json: " 43", 3026 expectedResult: 43, 3027 }, 3028 { 3029 name: "basic-big-overflow", 3030 json: " 2147483648", 3031 expectedResult: 0, 3032 err: true, 3033 }, 3034 { 3035 name: "basic-big-overflow", 3036 json: "137", 3037 expectedResult: 0, 3038 err: true, 3039 }, 3040 { 3041 name: "basic-big-overflow", 3042 json: "128", 3043 expectedResult: 0, 3044 err: true, 3045 }, 3046 { 3047 name: "basic-big-overflow2", 3048 json: "21474836483", 3049 expectedResult: 0, 3050 err: true, 3051 }, 3052 { 3053 name: "basic-float", 3054 json: "2.4595", 3055 expectedResult: 2, 3056 }, 3057 { 3058 name: "basic-float2", 3059 json: "-7.8876", 3060 expectedResult: -7, 3061 }, 3062 { 3063 name: "basic-float2", 3064 json: "-7.8876a", 3065 expectedResult: 0, 3066 err: true, 3067 }, 3068 { 3069 name: "basic-exponent-positive-positive-exp", 3070 json: "1.2E2", 3071 expectedResult: 120, 3072 }, 3073 { 3074 name: "basic-exponent-positive-positive-exp1", 3075 json: "3.5e+001 ", 3076 expectedResult: 35, 3077 }, 3078 { 3079 name: "basic-exponent-positive-positive-exp1", 3080 json: "3.5e+001", 3081 expectedResult: 35, 3082 }, 3083 { 3084 name: "basic-exponent-positive-positive-exp2", 3085 json: "5e+01", 3086 expectedResult: 50, 3087 }, 3088 { 3089 name: "basic-exponent-positive-negative-exp", 3090 json: "1e-2 ", 3091 expectedResult: 0, 3092 }, 3093 { 3094 name: "basic-exponent-positive-negative-exp2", 3095 json: "5E-6", 3096 expectedResult: 0, 3097 }, 3098 { 3099 name: "basic-exponent-positive-negative-exp3", 3100 json: "3e-3", 3101 expectedResult: 0, 3102 }, 3103 { 3104 name: "basic-exponent-positive-negative-exp4", 3105 json: "8e-1 ", 3106 expectedResult: 0, 3107 }, 3108 { 3109 name: "basic-exponent-positive-negative-exp4", 3110 json: "8e1 ", 3111 expectedResult: 80, 3112 }, 3113 { 3114 name: "basic-exponent-positive-negative-exp4", 3115 json: "8e-1", 3116 expectedResult: 0, 3117 }, 3118 { 3119 name: "basic-exponent-negative-positive-exp", 3120 json: "-1e2", 3121 expectedResult: -100, 3122 }, 3123 { 3124 name: "basic-exponent-negative-positive-exp2", 3125 json: "-5e+01", 3126 expectedResult: -50, 3127 }, 3128 { 3129 name: "basic-exponent-negative-positive-exp3", 3130 json: "-3e01", 3131 expectedResult: -30, 3132 }, 3133 { 3134 name: "error3", 3135 json: "0E40", 3136 expectedResult: 0, 3137 err: true, 3138 errType: InvalidJSONError(""), 3139 }, 3140 { 3141 name: "exponent-err-", 3142 json: "0.1e", 3143 expectedResult: 0, 3144 err: true, 3145 }, 3146 { 3147 name: "exponent-err-too-big", 3148 json: "0.1e10000000000000000000", 3149 expectedResult: 0, 3150 err: true, 3151 }, 3152 { 3153 name: "exponent-err-too-big", 3154 json: "0.1932242242424244244e1000000000000000000000000", 3155 expectedResult: 0, 3156 err: true, 3157 }, 3158 { 3159 name: "basic-exponent-negative-positive-exp4", 3160 json: "-8e+001", 3161 expectedResult: -80, 3162 }, 3163 { 3164 name: "exponent-err-too-big2", 3165 json: "0e100 ", 3166 expectedResult: 0, 3167 err: true, 3168 }, 3169 { 3170 name: "exponent-err-too-big2", 3171 json: "0.1e100 ", 3172 expectedResult: 0, 3173 err: true, 3174 }, 3175 { 3176 name: "basic-exponent-err", 3177 json: "3e", 3178 expectedResult: 0, 3179 err: true, 3180 }, 3181 { 3182 name: "basic-float", 3183 json: "8.32 ", 3184 expectedResult: 8, 3185 }, 3186 { 3187 name: "error", 3188 json: "83zez4", 3189 expectedResult: 0, 3190 err: true, 3191 errType: InvalidJSONError(""), 3192 }, 3193 { 3194 name: "error", 3195 json: "8ea00$aa5", 3196 expectedResult: 0, 3197 err: true, 3198 errType: InvalidJSONError(""), 3199 }, 3200 { 3201 name: "error2", 3202 json: "-8e+00$aa5", 3203 expectedResult: 0, 3204 err: true, 3205 }, 3206 { 3207 name: "error4", 3208 json: "0.E----", 3209 expectedResult: 0, 3210 err: true, 3211 errType: InvalidJSONError(""), 3212 }, 3213 { 3214 name: "error5", 3215 json: "0E40", 3216 expectedResult: 0, 3217 err: true, 3218 errType: InvalidJSONError(""), 3219 }, 3220 { 3221 name: "error6", 3222 json: "0.e-9", 3223 expectedResult: 0, 3224 err: true, 3225 errType: InvalidJSONError(""), 3226 }, 3227 { 3228 name: "error7", 3229 json: "0.e", 3230 expectedResult: 0, 3231 err: true, 3232 errType: InvalidJSONError(""), 3233 }, 3234 { 3235 name: "error8", 3236 json: "-5.e-2", 3237 expectedResult: 0, 3238 err: true, 3239 errType: InvalidJSONError(""), 3240 }, 3241 { 3242 name: "error8", 3243 json: "-5.01e", 3244 expectedResult: 0, 3245 err: true, 3246 errType: InvalidJSONError(""), 3247 }, 3248 { 3249 name: "invalid-type", 3250 json: `"string"`, 3251 expectedResult: 0, 3252 err: true, 3253 errType: InvalidUnmarshalError(""), 3254 }, 3255 } 3256 for _, testCase := range testCases { 3257 t.Run(testCase.name, func(t *testing.T) { 3258 json := []byte(testCase.json) 3259 var v = (*int8)(nil) 3260 err := Unmarshal(json, &v) 3261 if testCase.err { 3262 assert.NotNil(t, err, "Err must not be nil") 3263 if testCase.errType != nil { 3264 assert.IsType( 3265 t, 3266 testCase.errType, 3267 err, 3268 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 3269 ) 3270 } 3271 return 3272 } 3273 assert.Nil(t, err, "Err must be nil") 3274 if testCase.resultIsNil { 3275 assert.Nil(t, v) 3276 } else { 3277 assert.Equal(t, testCase.expectedResult, *v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 3278 } 3279 }) 3280 } 3281 t.Run("decoder-api-invalid-json", func(t *testing.T) { 3282 var v = new(int8) 3283 err := Unmarshal([]byte(``), &v) 3284 assert.NotNil(t, err, "Err must not be nil") 3285 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 3286 }) 3287 t.Run("decoder-api-invalid-json2", func(t *testing.T) { 3288 var v = new(int8) 3289 var dec = NewDecoder(strings.NewReader(``)) 3290 err := dec.Int8Null(&v) 3291 assert.NotNil(t, err, "Err must not be nil") 3292 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 3293 }) 3294 }