decode_number_uint_test.go (32236B)
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 TestDecoderUint64(t *testing.T) { 13 testCases := []struct { 14 name string 15 json string 16 expectedResult uint64 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: 0, 34 err: true, 35 }, 36 { 37 name: "basic-null", 38 json: "null", 39 expectedResult: 0, 40 }, 41 { 42 name: "basic-null-err", 43 json: "nxll", 44 expectedResult: 0, 45 err: true, 46 errType: InvalidJSONError(""), 47 }, 48 { 49 name: "basic-skip-data-err", 50 json: "trua", 51 expectedResult: 0, 52 err: true, 53 errType: InvalidJSONError(""), 54 }, 55 { 56 name: "basic-big", 57 json: "18446744073709551615", 58 expectedResult: 18446744073709551615, 59 }, 60 { 61 name: "basic-big-overflow", 62 json: "18446744073709551616", 63 expectedResult: 0, 64 err: true, 65 }, 66 { 67 name: "basic-big-overflow", 68 json: "18446744073709551625", 69 expectedResult: 0, 70 err: true, 71 }, 72 { 73 name: "basic-big-overflow2", 74 json: "184467440737095516161", 75 expectedResult: 0, 76 err: true, 77 }, 78 { 79 name: "basic-negative2", 80 json: "-2349557", 81 expectedResult: 0, 82 err: true, 83 }, 84 { 85 name: "basic-float", 86 json: "2.4595", 87 expectedResult: 2, 88 }, 89 { 90 name: "basic-float2", 91 json: "-7.8876", 92 expectedResult: 0, 93 err: true, 94 }, 95 { 96 name: "error1", 97 json: "132zz4", 98 expectedResult: 0, 99 err: true, 100 }, 101 { 102 name: "error", 103 json: "-83zez4", 104 expectedResult: 0, 105 err: true, 106 errType: InvalidJSONError(""), 107 }, 108 { 109 name: "invalid-type", 110 json: `"string"`, 111 expectedResult: 0, 112 err: true, 113 errType: InvalidUnmarshalError(""), 114 }, 115 } 116 for _, testCase := range testCases { 117 t.Run(testCase.name, func(t *testing.T) { 118 json := []byte(testCase.json) 119 var v uint64 120 err := Unmarshal(json, &v) 121 if testCase.err { 122 assert.NotNil(t, err, "Err must not be nil") 123 if testCase.errType != nil { 124 assert.IsType( 125 t, 126 testCase.errType, 127 err, 128 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 129 ) 130 } 131 } else { 132 assert.Nil(t, err, "Err must be nil") 133 } 134 assert.Equal(t, testCase.expectedResult, v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 135 }) 136 } 137 t.Run("pool-error", func(t *testing.T) { 138 result := uint64(1) 139 dec := NewDecoder(nil) 140 dec.Release() 141 defer func() { 142 err := recover() 143 assert.NotNil(t, err, "err shouldnt be nil") 144 assert.IsType(t, InvalidUsagePooledDecoderError(""), err, "err should be of type InvalidUsagePooledDecoderError") 145 }() 146 _ = dec.DecodeUint64(&result) 147 assert.True(t, false, "should not be called as decoder should have panicked") 148 }) 149 t.Run("decoder-api", func(t *testing.T) { 150 var v uint64 151 dec := NewDecoder(strings.NewReader(`33`)) 152 defer dec.Release() 153 err := dec.DecodeUint64(&v) 154 assert.Nil(t, err, "Err must be nil") 155 assert.Equal(t, uint64(33), v, "v must be equal to 33") 156 }) 157 t.Run("decoder-api-json-error", func(t *testing.T) { 158 var v uint64 159 dec := NewDecoder(strings.NewReader(``)) 160 defer dec.Release() 161 err := dec.DecodeUint64(&v) 162 assert.NotNil(t, err, "Err must not be nil") 163 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 164 }) 165 } 166 func TestDecoderUint64Null(t *testing.T) { 167 testCases := []struct { 168 name string 169 json string 170 expectedResult uint64 171 err bool 172 errType interface{} 173 resultIsNil bool 174 }{ 175 { 176 name: "basic-positive", 177 json: "100", 178 expectedResult: 100, 179 }, 180 { 181 name: "basic-positive2", 182 json: " 1039405", 183 expectedResult: 1039405, 184 }, 185 { 186 name: "basic-negative", 187 json: "-2", 188 expectedResult: 0, 189 err: true, 190 }, 191 { 192 name: "basic-null", 193 json: "null", 194 expectedResult: 0, 195 resultIsNil: true, 196 }, 197 { 198 name: "basic-null-err", 199 json: "nxll", 200 expectedResult: 0, 201 err: true, 202 errType: InvalidJSONError(""), 203 }, 204 { 205 name: "basic-skip-data-err", 206 json: "trua", 207 expectedResult: 0, 208 err: true, 209 errType: InvalidJSONError(""), 210 }, 211 { 212 name: "basic-big", 213 json: "18446744073709551615", 214 expectedResult: 18446744073709551615, 215 }, 216 { 217 name: "basic-big-overflow", 218 json: "18446744073709551616", 219 expectedResult: 0, 220 err: true, 221 }, 222 { 223 name: "basic-big-overflow", 224 json: "18446744073709551625", 225 expectedResult: 0, 226 err: true, 227 }, 228 { 229 name: "basic-big-overflow2", 230 json: "184467440737095516161", 231 expectedResult: 0, 232 err: true, 233 }, 234 { 235 name: "basic-negative2", 236 json: "-2349557", 237 expectedResult: 0, 238 err: true, 239 }, 240 { 241 name: "basic-float", 242 json: "2.4595", 243 expectedResult: 2, 244 }, 245 { 246 name: "basic-float2", 247 json: "-7.8876", 248 expectedResult: 0, 249 err: true, 250 }, 251 { 252 name: "error1", 253 json: "132zz4", 254 expectedResult: 0, 255 err: true, 256 }, 257 { 258 name: "error", 259 json: "-83zez4", 260 expectedResult: 0, 261 err: true, 262 errType: InvalidJSONError(""), 263 }, 264 { 265 name: "invalid-type", 266 json: `"string"`, 267 expectedResult: 0, 268 err: true, 269 errType: InvalidUnmarshalError(""), 270 }, 271 } 272 for _, testCase := range testCases { 273 t.Run(testCase.name, func(t *testing.T) { 274 json := []byte(testCase.json) 275 var v = (*uint64)(nil) 276 err := Unmarshal(json, &v) 277 if testCase.err { 278 assert.NotNil(t, err, "Err must not be nil") 279 if testCase.errType != nil { 280 assert.IsType( 281 t, 282 testCase.errType, 283 err, 284 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 285 ) 286 } 287 return 288 } 289 assert.Nil(t, err, "Err must be nil") 290 if testCase.resultIsNil { 291 assert.Nil(t, v) 292 } else { 293 assert.Equal(t, testCase.expectedResult, *v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 294 } 295 }) 296 } 297 t.Run("decoder-api-invalid-json", func(t *testing.T) { 298 var v = new(uint64) 299 err := Unmarshal([]byte(``), &v) 300 assert.NotNil(t, err, "Err must not be nil") 301 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 302 }) 303 t.Run("decoder-api-invalid-json2", func(t *testing.T) { 304 var v = new(uint64) 305 var dec = NewDecoder(strings.NewReader(``)) 306 err := dec.Uint64Null(&v) 307 assert.NotNil(t, err, "Err must not be nil") 308 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 309 }) 310 } 311 312 func TestDecoderUint32(t *testing.T) { 313 testCases := []struct { 314 name string 315 json string 316 expectedResult uint32 317 err bool 318 errType interface{} 319 }{ 320 { 321 name: "basic-positive", 322 json: "100", 323 expectedResult: 100, 324 }, 325 { 326 name: "basic-positive2", 327 json: " 1039405 ", 328 expectedResult: 1039405, 329 }, 330 { 331 name: "basic-negative", 332 json: "-2", 333 expectedResult: 0, 334 err: true, 335 }, 336 { 337 name: "basic-null", 338 json: "null", 339 expectedResult: 0, 340 }, 341 { 342 name: "basic-null-err", 343 json: "nxll", 344 expectedResult: 0, 345 err: true, 346 errType: InvalidJSONError(""), 347 }, 348 { 349 name: "basic-skip-data-err", 350 json: "trua", 351 expectedResult: 0, 352 err: true, 353 errType: InvalidJSONError(""), 354 }, 355 { 356 name: "basic-negative2", 357 json: "-2349557", 358 expectedResult: 0, 359 err: true, 360 }, 361 { 362 name: "basic-big", 363 json: "4294967295", 364 expectedResult: 4294967295, 365 }, 366 { 367 name: "basic-big-overflow", 368 json: " 4294967298", 369 expectedResult: 0, 370 err: true, 371 }, 372 { 373 name: "basic-big-overflow", 374 json: "4294967395", 375 expectedResult: 0, 376 err: true, 377 }, 378 { 379 name: "basic-big-overflow2", 380 json: "42949672983", 381 expectedResult: 0, 382 err: true, 383 }, 384 { 385 name: "basic-float", 386 json: "2.4595", 387 expectedResult: 2, 388 }, 389 { 390 name: "basic-float2", 391 json: "-7.8876", 392 expectedResult: 0, 393 err: true, 394 }, 395 { 396 name: "error", 397 json: "83zez4", 398 expectedResult: 0, 399 err: true, 400 errType: InvalidJSONError(""), 401 }, 402 { 403 name: "error", 404 json: "-83zez4", 405 expectedResult: 0, 406 err: true, 407 errType: InvalidJSONError(""), 408 }, 409 { 410 name: "invalid-type", 411 json: `"string"`, 412 expectedResult: 0, 413 err: true, 414 errType: InvalidUnmarshalError(""), 415 }, 416 { 417 name: "invalid-json", 418 json: `123invalid`, 419 expectedResult: 0, 420 err: true, 421 errType: InvalidJSONError(""), 422 }, 423 } 424 for _, testCase := range testCases { 425 t.Run(testCase.name, func(t *testing.T) { 426 json := []byte(testCase.json) 427 var v uint32 428 err := Unmarshal(json, &v) 429 if testCase.err { 430 assert.NotNil(t, err, "Err must not be nil") 431 if testCase.errType != nil { 432 assert.IsType( 433 t, 434 testCase.errType, 435 err, 436 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 437 ) 438 } 439 } else { 440 assert.Nil(t, err, "Err must be nil") 441 } 442 assert.Equal(t, testCase.expectedResult, v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 443 }) 444 } 445 t.Run("pool-error", func(t *testing.T) { 446 result := uint32(1) 447 dec := NewDecoder(nil) 448 dec.Release() 449 defer func() { 450 err := recover() 451 assert.NotNil(t, err, "err shouldnt be nil") 452 assert.IsType(t, InvalidUsagePooledDecoderError(""), err, "err should be of type InvalidUsagePooledDecoderError") 453 }() 454 _ = dec.DecodeUint32(&result) 455 assert.True(t, false, "should not be called as decoder should have panicked") 456 }) 457 t.Run("decoder-api", func(t *testing.T) { 458 var v uint32 459 dec := NewDecoder(strings.NewReader(`33`)) 460 defer dec.Release() 461 err := dec.DecodeUint32(&v) 462 assert.Nil(t, err, "Err must be nil") 463 assert.Equal(t, uint32(33), v, "v must be equal to 33") 464 }) 465 t.Run("decoder-api-json-error", func(t *testing.T) { 466 var v uint32 467 dec := NewDecoder(strings.NewReader(``)) 468 defer dec.Release() 469 err := dec.DecodeUint32(&v) 470 assert.NotNil(t, err, "Err must not be nil") 471 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 472 }) 473 } 474 func TestDecoderUint32Null(t *testing.T) { 475 testCases := []struct { 476 name string 477 json string 478 expectedResult uint32 479 err bool 480 errType interface{} 481 resultIsNil bool 482 }{ 483 { 484 name: "basic-positive", 485 json: "100", 486 expectedResult: 100, 487 }, 488 { 489 name: "basic-positive2", 490 json: " 1039405 ", 491 expectedResult: 1039405, 492 }, 493 { 494 name: "basic-negative", 495 json: "-2", 496 expectedResult: 0, 497 err: true, 498 }, 499 { 500 name: "basic-null", 501 json: "null", 502 expectedResult: 0, 503 resultIsNil: true, 504 }, 505 { 506 name: "basic-null-err", 507 json: "nxll", 508 expectedResult: 0, 509 err: true, 510 errType: InvalidJSONError(""), 511 }, 512 { 513 name: "basic-skip-data-err", 514 json: "trua", 515 expectedResult: 0, 516 err: true, 517 errType: InvalidJSONError(""), 518 }, 519 { 520 name: "basic-negative2", 521 json: "-2349557", 522 expectedResult: 0, 523 err: true, 524 }, 525 { 526 name: "basic-big", 527 json: "4294967295", 528 expectedResult: 4294967295, 529 }, 530 { 531 name: "basic-big-overflow", 532 json: " 4294967298", 533 expectedResult: 0, 534 err: true, 535 }, 536 { 537 name: "basic-big-overflow", 538 json: "4294967395", 539 expectedResult: 0, 540 err: true, 541 }, 542 { 543 name: "basic-big-overflow2", 544 json: "42949672983", 545 expectedResult: 0, 546 err: true, 547 }, 548 { 549 name: "basic-float", 550 json: "2.4595", 551 expectedResult: 2, 552 }, 553 { 554 name: "basic-float2", 555 json: "-7.8876", 556 expectedResult: 0, 557 err: true, 558 }, 559 { 560 name: "error", 561 json: "83zez4", 562 expectedResult: 0, 563 err: true, 564 errType: InvalidJSONError(""), 565 }, 566 { 567 name: "error", 568 json: "-83zez4", 569 expectedResult: 0, 570 err: true, 571 errType: InvalidJSONError(""), 572 }, 573 { 574 name: "invalid-type", 575 json: `"string"`, 576 expectedResult: 0, 577 err: true, 578 errType: InvalidUnmarshalError(""), 579 }, 580 { 581 name: "invalid-json", 582 json: `123invalid`, 583 expectedResult: 0, 584 err: true, 585 errType: InvalidJSONError(""), 586 }, 587 } 588 for _, testCase := range testCases { 589 t.Run(testCase.name, func(t *testing.T) { 590 json := []byte(testCase.json) 591 var v = (*uint32)(nil) 592 err := Unmarshal(json, &v) 593 if testCase.err { 594 assert.NotNil(t, err, "Err must not be nil") 595 if testCase.errType != nil { 596 assert.IsType( 597 t, 598 testCase.errType, 599 err, 600 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 601 ) 602 } 603 return 604 } 605 assert.Nil(t, err, "Err must be nil") 606 if testCase.resultIsNil { 607 assert.Nil(t, v) 608 } else { 609 assert.Equal(t, testCase.expectedResult, *v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 610 } 611 }) 612 } 613 t.Run("decoder-api-invalid-json", func(t *testing.T) { 614 var v = new(uint32) 615 err := Unmarshal([]byte(``), &v) 616 assert.NotNil(t, err, "Err must not be nil") 617 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 618 }) 619 t.Run("decoder-api-invalid-json2", func(t *testing.T) { 620 var v = new(uint32) 621 var dec = NewDecoder(strings.NewReader(``)) 622 err := dec.Uint32Null(&v) 623 assert.NotNil(t, err, "Err must not be nil") 624 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 625 }) 626 } 627 628 func TestDecoderUint16(t *testing.T) { 629 testCases := []struct { 630 name string 631 json string 632 expectedResult uint16 633 err bool 634 errType interface{} 635 }{ 636 { 637 name: "basic-positive", 638 json: "100", 639 expectedResult: 100, 640 }, 641 { 642 name: "basic-positive2", 643 json: " 3224 ", 644 expectedResult: 3224, 645 }, 646 { 647 name: "basic-negative", 648 json: "-2", 649 expectedResult: 0, 650 err: true, 651 }, 652 { 653 name: "basic-null", 654 json: "null", 655 expectedResult: 0, 656 }, 657 { 658 name: "basic-null-err", 659 json: "nxll", 660 expectedResult: 0, 661 err: true, 662 errType: InvalidJSONError(""), 663 }, 664 { 665 name: "basic-skip-data-err", 666 json: "trua", 667 expectedResult: 0, 668 err: true, 669 errType: InvalidJSONError(""), 670 }, 671 { 672 name: "basic-skip-data-err", 673 json: "trua", 674 expectedResult: 0, 675 err: true, 676 errType: InvalidJSONError(""), 677 }, 678 { 679 name: "basic-overflow", 680 json: "335346564", 681 expectedResult: 0, 682 err: true, 683 errType: InvalidUnmarshalError(""), 684 }, 685 { 686 name: "basic-negative2", 687 json: "-24467", 688 expectedResult: 0, 689 err: true, 690 }, 691 { 692 name: "basic-big", 693 json: "54546", 694 expectedResult: 54546, 695 }, 696 { 697 name: "basic-big-overflow", 698 json: " 4294967298", 699 expectedResult: 0, 700 err: true, 701 }, 702 { 703 name: "basic-big-overflow", 704 json: " 65537", 705 expectedResult: 0, 706 err: true, 707 }, 708 { 709 name: "basic-big-overflow", 710 json: " 66537", 711 expectedResult: 0, 712 err: true, 713 }, 714 { 715 name: "basic-big-overflow2", 716 json: "42949672983", 717 expectedResult: 0, 718 err: true, 719 }, 720 { 721 name: "basic-float", 722 json: "2.4595", 723 expectedResult: 2, 724 }, 725 { 726 name: "basic-float2", 727 json: "-7.8876", 728 expectedResult: 0, 729 err: true, 730 }, 731 { 732 name: "error", 733 json: "83zez4", 734 expectedResult: 0, 735 err: true, 736 errType: InvalidJSONError(""), 737 }, 738 { 739 name: "error", 740 json: "-83zez4", 741 expectedResult: 0, 742 err: true, 743 errType: InvalidJSONError(""), 744 }, 745 { 746 name: "invalid-type", 747 json: `"string"`, 748 expectedResult: 0, 749 err: true, 750 errType: InvalidUnmarshalError(""), 751 }, 752 { 753 name: "invalid-json", 754 json: `123invalid`, 755 expectedResult: 0, 756 err: true, 757 errType: InvalidJSONError(""), 758 }, 759 } 760 for _, testCase := range testCases { 761 t.Run(testCase.name, func(t *testing.T) { 762 json := []byte(testCase.json) 763 var v uint16 764 err := Unmarshal(json, &v) 765 if testCase.err { 766 assert.NotNil(t, err, "Err must not be nil") 767 if testCase.errType != nil { 768 assert.IsType( 769 t, 770 testCase.errType, 771 err, 772 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 773 ) 774 } 775 } else { 776 assert.Nil(t, err, "Err must be nil") 777 } 778 assert.Equal(t, testCase.expectedResult, v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 779 }) 780 } 781 t.Run("pool-error", func(t *testing.T) { 782 result := uint16(1) 783 dec := NewDecoder(nil) 784 dec.Release() 785 defer func() { 786 err := recover() 787 assert.NotNil(t, err, "err shouldnt be nil") 788 assert.IsType(t, InvalidUsagePooledDecoderError(""), err, "err should be of type InvalidUsagePooledDecoderError") 789 }() 790 _ = dec.DecodeUint16(&result) 791 assert.True(t, false, "should not be called as decoder should have panicked") 792 }) 793 t.Run("decoder-api", func(t *testing.T) { 794 var v uint16 795 dec := NewDecoder(strings.NewReader(`33`)) 796 defer dec.Release() 797 err := dec.DecodeUint16(&v) 798 assert.Nil(t, err, "Err must be nil") 799 assert.Equal(t, uint16(33), v, "v must be equal to 33") 800 }) 801 t.Run("decoder-api2", func(t *testing.T) { 802 var v uint16 803 dec := NewDecoder(strings.NewReader(`33`)) 804 defer dec.Release() 805 err := dec.Decode(&v) 806 assert.Nil(t, err, "Err must be nil") 807 assert.Equal(t, uint16(33), v, "v must be equal to 33") 808 }) 809 t.Run("decoder-api-json-error", func(t *testing.T) { 810 var v uint16 811 dec := NewDecoder(strings.NewReader(``)) 812 defer dec.Release() 813 err := dec.DecodeUint16(&v) 814 assert.NotNil(t, err, "Err must not be nil") 815 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 816 }) 817 } 818 func TestDecoderUint16Null(t *testing.T) { 819 testCases := []struct { 820 name string 821 json string 822 expectedResult uint16 823 err bool 824 errType interface{} 825 resultIsNil bool 826 }{ 827 { 828 name: "basic-positive", 829 json: "100", 830 expectedResult: 100, 831 }, 832 { 833 name: "basic-positive2", 834 json: " 3224 ", 835 expectedResult: 3224, 836 }, 837 { 838 name: "basic-negative", 839 json: "-2", 840 expectedResult: 0, 841 err: true, 842 }, 843 { 844 name: "basic-null", 845 json: "null", 846 expectedResult: 0, 847 resultIsNil: true, 848 }, 849 { 850 name: "basic-null-err", 851 json: "nxll", 852 expectedResult: 0, 853 err: true, 854 errType: InvalidJSONError(""), 855 }, 856 { 857 name: "basic-skip-data-err", 858 json: "trua", 859 expectedResult: 0, 860 err: true, 861 errType: InvalidJSONError(""), 862 }, 863 { 864 name: "basic-skip-data-err", 865 json: "trua", 866 expectedResult: 0, 867 err: true, 868 errType: InvalidJSONError(""), 869 }, 870 { 871 name: "basic-overflow", 872 json: "335346564", 873 expectedResult: 0, 874 err: true, 875 errType: InvalidUnmarshalError(""), 876 }, 877 { 878 name: "basic-negative2", 879 json: "-24467", 880 expectedResult: 0, 881 err: true, 882 }, 883 { 884 name: "basic-big", 885 json: "54546", 886 expectedResult: 54546, 887 }, 888 { 889 name: "basic-big-overflow", 890 json: " 4294967298", 891 expectedResult: 0, 892 err: true, 893 }, 894 { 895 name: "basic-big-overflow", 896 json: " 65537", 897 expectedResult: 0, 898 err: true, 899 }, 900 { 901 name: "basic-big-overflow", 902 json: " 66537", 903 expectedResult: 0, 904 err: true, 905 }, 906 { 907 name: "basic-big-overflow2", 908 json: "42949672983", 909 expectedResult: 0, 910 err: true, 911 }, 912 { 913 name: "basic-float", 914 json: "2.4595", 915 expectedResult: 2, 916 }, 917 { 918 name: "basic-float2", 919 json: "-7.8876", 920 expectedResult: 0, 921 err: true, 922 }, 923 { 924 name: "error", 925 json: "83zez4", 926 expectedResult: 0, 927 err: true, 928 errType: InvalidJSONError(""), 929 }, 930 { 931 name: "error", 932 json: "-83zez4", 933 expectedResult: 0, 934 err: true, 935 errType: InvalidJSONError(""), 936 }, 937 { 938 name: "invalid-type", 939 json: `"string"`, 940 expectedResult: 0, 941 err: true, 942 errType: InvalidUnmarshalError(""), 943 }, 944 { 945 name: "invalid-json", 946 json: `123invalid`, 947 expectedResult: 0, 948 err: true, 949 errType: InvalidJSONError(""), 950 }, 951 } 952 for _, testCase := range testCases { 953 t.Run(testCase.name, func(t *testing.T) { 954 json := []byte(testCase.json) 955 var v = (*uint16)(nil) 956 err := Unmarshal(json, &v) 957 if testCase.err { 958 assert.NotNil(t, err, "Err must not be nil") 959 if testCase.errType != nil { 960 assert.IsType( 961 t, 962 testCase.errType, 963 err, 964 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 965 ) 966 } 967 return 968 } 969 assert.Nil(t, err, "Err must be nil") 970 if testCase.resultIsNil { 971 assert.Nil(t, v) 972 } else { 973 assert.Equal(t, testCase.expectedResult, *v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 974 } 975 }) 976 } 977 t.Run("decoder-api-invalid-json", func(t *testing.T) { 978 var v = new(uint16) 979 err := Unmarshal([]byte(``), &v) 980 assert.NotNil(t, err, "Err must not be nil") 981 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 982 }) 983 t.Run("decoder-api-invalid-json2", func(t *testing.T) { 984 var v = new(uint16) 985 var dec = NewDecoder(strings.NewReader(``)) 986 err := dec.Uint16Null(&v) 987 assert.NotNil(t, err, "Err must not be nil") 988 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 989 }) 990 } 991 992 func TestDecoderUint8(t *testing.T) { 993 testCases := []struct { 994 name string 995 json string 996 expectedResult uint8 997 err bool 998 errType interface{} 999 }{ 1000 { 1001 name: "basic-positive", 1002 json: "100", 1003 expectedResult: 100, 1004 }, 1005 { 1006 name: "basic-positive2", 1007 json: " 255 ", 1008 expectedResult: 255, 1009 }, 1010 { 1011 name: "basic-negative", 1012 json: "-2", 1013 expectedResult: 0, 1014 err: true, 1015 }, 1016 { 1017 name: "basic-null", 1018 json: "null", 1019 expectedResult: 0, 1020 }, 1021 { 1022 name: "basic-null-err", 1023 json: "nxll", 1024 expectedResult: 0, 1025 err: true, 1026 errType: InvalidJSONError(""), 1027 }, 1028 { 1029 name: "basic-skip-data-err", 1030 json: "trua", 1031 expectedResult: 0, 1032 err: true, 1033 errType: InvalidJSONError(""), 1034 }, 1035 { 1036 name: "basic-negative2", 1037 json: "-234", 1038 expectedResult: 0, 1039 err: true, 1040 }, 1041 { 1042 name: "basic-big", 1043 json: "200", 1044 expectedResult: 200, 1045 }, 1046 { 1047 name: "basic-overflow", 1048 json: "256", 1049 expectedResult: 0, 1050 err: true, 1051 errType: InvalidUnmarshalError(""), 1052 }, 1053 { 1054 name: "basic-overflow", 1055 json: "274", 1056 expectedResult: 0, 1057 err: true, 1058 errType: InvalidUnmarshalError(""), 1059 }, 1060 { 1061 name: "basic-big-overflow", 1062 json: " 4294967298", 1063 expectedResult: 0, 1064 err: true, 1065 }, 1066 { 1067 name: "basic-big-overflow2", 1068 json: "42949672983", 1069 expectedResult: 0, 1070 err: true, 1071 }, 1072 { 1073 name: "basic-float", 1074 json: "2.4595", 1075 expectedResult: 2, 1076 }, 1077 { 1078 name: "basic-float2", 1079 json: "-7.8876", 1080 expectedResult: 0, 1081 err: true, 1082 }, 1083 { 1084 name: "error", 1085 json: "83zez4", 1086 expectedResult: 0, 1087 err: true, 1088 errType: InvalidJSONError(""), 1089 }, 1090 { 1091 name: "error", 1092 json: "-83zez4", 1093 expectedResult: 0, 1094 err: true, 1095 errType: InvalidJSONError(""), 1096 }, 1097 { 1098 name: "invalid-type", 1099 json: `"string"`, 1100 expectedResult: 0, 1101 err: true, 1102 errType: InvalidUnmarshalError(""), 1103 }, 1104 { 1105 name: "invalid-json", 1106 json: `123invalid`, 1107 expectedResult: 0, 1108 err: true, 1109 errType: InvalidJSONError(""), 1110 }, 1111 } 1112 for _, testCase := range testCases { 1113 t.Run(testCase.name, func(t *testing.T) { 1114 json := []byte(testCase.json) 1115 var v uint8 1116 err := Unmarshal(json, &v) 1117 if testCase.err { 1118 assert.NotNil(t, err, "Err must not be nil") 1119 if testCase.errType != nil { 1120 assert.IsType( 1121 t, 1122 testCase.errType, 1123 err, 1124 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 1125 ) 1126 } 1127 } else { 1128 assert.Nil(t, err, "Err must be nil") 1129 } 1130 assert.Equal(t, testCase.expectedResult, v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 1131 }) 1132 } 1133 t.Run("pool-error", func(t *testing.T) { 1134 result := uint8(1) 1135 dec := NewDecoder(nil) 1136 dec.Release() 1137 defer func() { 1138 err := recover() 1139 assert.NotNil(t, err, "err shouldnt be nil") 1140 assert.IsType(t, InvalidUsagePooledDecoderError(""), err, "err should be of type InvalidUsagePooledDecoderError") 1141 }() 1142 _ = dec.DecodeUint8(&result) 1143 assert.True(t, false, "should not be called as decoder should have panicked") 1144 }) 1145 t.Run("decoder-api", func(t *testing.T) { 1146 var v uint8 1147 dec := NewDecoder(strings.NewReader(`33`)) 1148 defer dec.Release() 1149 err := dec.DecodeUint8(&v) 1150 assert.Nil(t, err, "Err must be nil") 1151 assert.Equal(t, uint8(33), v, "v must be equal to 33") 1152 }) 1153 t.Run("decoder-api2", func(t *testing.T) { 1154 var v uint8 1155 dec := NewDecoder(strings.NewReader(`33`)) 1156 defer dec.Release() 1157 err := dec.Decode(&v) 1158 assert.Nil(t, err, "Err must be nil") 1159 assert.Equal(t, uint8(33), v, "v must be equal to 33") 1160 }) 1161 t.Run("decoder-api-json-error", func(t *testing.T) { 1162 var v uint8 1163 dec := NewDecoder(strings.NewReader(``)) 1164 defer dec.Release() 1165 err := dec.DecodeUint8(&v) 1166 assert.NotNil(t, err, "Err must not be nil") 1167 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 1168 }) 1169 } 1170 1171 func TestDecoderUint8Null(t *testing.T) { 1172 testCases := []struct { 1173 name string 1174 json string 1175 expectedResult uint8 1176 err bool 1177 errType interface{} 1178 resultIsNil bool 1179 }{ 1180 { 1181 name: "basic-positive", 1182 json: "100", 1183 expectedResult: 100, 1184 }, 1185 { 1186 name: "basic-positive2", 1187 json: " 255 ", 1188 expectedResult: 255, 1189 }, 1190 { 1191 name: "basic-negative", 1192 json: "-2", 1193 expectedResult: 0, 1194 err: true, 1195 }, 1196 { 1197 name: "basic-null", 1198 json: "null", 1199 expectedResult: 0, 1200 resultIsNil: true, 1201 }, 1202 { 1203 name: "basic-null-err", 1204 json: "nxll", 1205 expectedResult: 0, 1206 err: true, 1207 errType: InvalidJSONError(""), 1208 }, 1209 { 1210 name: "basic-skip-data-err", 1211 json: "trua", 1212 expectedResult: 0, 1213 err: true, 1214 errType: InvalidJSONError(""), 1215 }, 1216 { 1217 name: "basic-negative2", 1218 json: "-234", 1219 expectedResult: 0, 1220 err: true, 1221 }, 1222 { 1223 name: "basic-big", 1224 json: "200", 1225 expectedResult: 200, 1226 }, 1227 { 1228 name: "basic-overflow", 1229 json: "256", 1230 expectedResult: 0, 1231 err: true, 1232 errType: InvalidUnmarshalError(""), 1233 }, 1234 { 1235 name: "basic-overflow", 1236 json: "274", 1237 expectedResult: 0, 1238 err: true, 1239 errType: InvalidUnmarshalError(""), 1240 }, 1241 { 1242 name: "basic-big-overflow", 1243 json: " 4294967298", 1244 expectedResult: 0, 1245 err: true, 1246 }, 1247 { 1248 name: "basic-big-overflow2", 1249 json: "42949672983", 1250 expectedResult: 0, 1251 err: true, 1252 }, 1253 { 1254 name: "basic-float", 1255 json: "2.4595", 1256 expectedResult: 2, 1257 }, 1258 { 1259 name: "basic-float2", 1260 json: "-7.8876", 1261 expectedResult: 0, 1262 err: true, 1263 }, 1264 { 1265 name: "error", 1266 json: "83zez4", 1267 expectedResult: 0, 1268 err: true, 1269 errType: InvalidJSONError(""), 1270 }, 1271 { 1272 name: "error", 1273 json: "-83zez4", 1274 expectedResult: 0, 1275 err: true, 1276 errType: InvalidJSONError(""), 1277 }, 1278 { 1279 name: "invalid-type", 1280 json: `"string"`, 1281 expectedResult: 0, 1282 err: true, 1283 errType: InvalidUnmarshalError(""), 1284 }, 1285 { 1286 name: "invalid-json", 1287 json: `123invalid`, 1288 expectedResult: 0, 1289 err: true, 1290 errType: InvalidJSONError(""), 1291 }, 1292 } 1293 for _, testCase := range testCases { 1294 t.Run(testCase.name, func(t *testing.T) { 1295 json := []byte(testCase.json) 1296 var v = (*uint8)(nil) 1297 err := Unmarshal(json, &v) 1298 if testCase.err { 1299 assert.NotNil(t, err, "Err must not be nil") 1300 if testCase.errType != nil { 1301 assert.IsType( 1302 t, 1303 testCase.errType, 1304 err, 1305 fmt.Sprintf("err should be of type %s", reflect.TypeOf(err).String()), 1306 ) 1307 } 1308 return 1309 } 1310 assert.Nil(t, err, "Err must be nil") 1311 if testCase.resultIsNil { 1312 assert.Nil(t, v) 1313 } else { 1314 assert.Equal(t, testCase.expectedResult, *v, fmt.Sprintf("v must be equal to %d", testCase.expectedResult)) 1315 } 1316 }) 1317 } 1318 t.Run("decoder-api-invalid-json", func(t *testing.T) { 1319 var v = new(uint8) 1320 err := Unmarshal([]byte(``), &v) 1321 assert.NotNil(t, err, "Err must not be nil") 1322 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 1323 }) 1324 t.Run("decoder-api-invalid-json2", func(t *testing.T) { 1325 var v = new(uint8) 1326 var dec = NewDecoder(strings.NewReader(``)) 1327 err := dec.Uint8Null(&v) 1328 assert.NotNil(t, err, "Err must not be nil") 1329 assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError") 1330 }) 1331 }