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