@@ -647,40 +647,6 @@ BOOST_AUTO_TEST_CASE(util_overflow)
647
647
TestAddMatrix<signed >();
648
648
}
649
649
650
- BOOST_AUTO_TEST_CASE (test_ParseInt32)
651
- {
652
- int32_t n;
653
- // Valid values
654
- BOOST_CHECK (ParseInt32 (" 1234" , nullptr ));
655
- BOOST_CHECK (ParseInt32 (" 0" , &n) && n == 0 );
656
- BOOST_CHECK (ParseInt32 (" 1234" , &n) && n == 1234 );
657
- BOOST_CHECK (ParseInt32 (" 01234" , &n) && n == 1234 ); // no octal
658
- BOOST_CHECK (ParseInt32 (" 2147483647" , &n) && n == 2147483647 );
659
- BOOST_CHECK (ParseInt32 (" -2147483648" , &n) && n == (-2147483647 - 1 )); // (-2147483647 - 1) equals INT_MIN
660
- BOOST_CHECK (ParseInt32 (" -1234" , &n) && n == -1234 );
661
- BOOST_CHECK (ParseInt32 (" 00000000000000001234" , &n) && n == 1234 );
662
- BOOST_CHECK (ParseInt32 (" -00000000000000001234" , &n) && n == -1234 );
663
- BOOST_CHECK (ParseInt32 (" 00000000000000000000" , &n) && n == 0 );
664
- BOOST_CHECK (ParseInt32 (" -00000000000000000000" , &n) && n == 0 );
665
- // Invalid values
666
- BOOST_CHECK (!ParseInt32 (" " , &n));
667
- BOOST_CHECK (!ParseInt32 (" 1" , &n)); // no padding inside
668
- BOOST_CHECK (!ParseInt32 (" 1 " , &n));
669
- BOOST_CHECK (!ParseInt32 (" ++1" , &n));
670
- BOOST_CHECK (!ParseInt32 (" +-1" , &n));
671
- BOOST_CHECK (!ParseInt32 (" -+1" , &n));
672
- BOOST_CHECK (!ParseInt32 (" --1" , &n));
673
- BOOST_CHECK (!ParseInt32 (" 1a" , &n));
674
- BOOST_CHECK (!ParseInt32 (" aap" , &n));
675
- BOOST_CHECK (!ParseInt32 (" 0x1" , &n)); // no hex
676
- BOOST_CHECK (!ParseInt32 (STRING_WITH_EMBEDDED_NULL_CHAR, &n));
677
- // Overflow and underflow
678
- BOOST_CHECK (!ParseInt32 (" -2147483649" , nullptr ));
679
- BOOST_CHECK (!ParseInt32 (" 2147483648" , nullptr ));
680
- BOOST_CHECK (!ParseInt32 (" -32482348723847471234" , nullptr ));
681
- BOOST_CHECK (!ParseInt32 (" 32482348723847471234" , nullptr ));
682
- }
683
-
684
650
template <typename T>
685
651
static void RunToIntegralTests ()
686
652
{
@@ -868,171 +834,6 @@ BOOST_AUTO_TEST_CASE(test_LocaleIndependentAtoi)
868
834
BOOST_CHECK_EQUAL (LocaleIndependentAtoi<uint8_t >(" 256" ), 255U );
869
835
}
870
836
871
- BOOST_AUTO_TEST_CASE (test_ParseInt64)
872
- {
873
- int64_t n;
874
- // Valid values
875
- BOOST_CHECK (ParseInt64 (" 1234" , nullptr ));
876
- BOOST_CHECK (ParseInt64 (" 0" , &n) && n == 0LL );
877
- BOOST_CHECK (ParseInt64 (" 1234" , &n) && n == 1234LL );
878
- BOOST_CHECK (ParseInt64 (" 01234" , &n) && n == 1234LL ); // no octal
879
- BOOST_CHECK (ParseInt64 (" 2147483647" , &n) && n == 2147483647LL );
880
- BOOST_CHECK (ParseInt64 (" -2147483648" , &n) && n == -2147483648LL );
881
- BOOST_CHECK (ParseInt64 (" 9223372036854775807" , &n) && n == int64_t {9223372036854775807 });
882
- BOOST_CHECK (ParseInt64 (" -9223372036854775808" , &n) && n == int64_t {-9223372036854775807 -1 });
883
- BOOST_CHECK (ParseInt64 (" -1234" , &n) && n == -1234LL );
884
- // Invalid values
885
- BOOST_CHECK (!ParseInt64 (" " , &n));
886
- BOOST_CHECK (!ParseInt64 (" 1" , &n)); // no padding inside
887
- BOOST_CHECK (!ParseInt64 (" 1 " , &n));
888
- BOOST_CHECK (!ParseInt64 (" 1a" , &n));
889
- BOOST_CHECK (!ParseInt64 (" aap" , &n));
890
- BOOST_CHECK (!ParseInt64 (" 0x1" , &n)); // no hex
891
- BOOST_CHECK (!ParseInt64 (STRING_WITH_EMBEDDED_NULL_CHAR, &n));
892
- // Overflow and underflow
893
- BOOST_CHECK (!ParseInt64 (" -9223372036854775809" , nullptr ));
894
- BOOST_CHECK (!ParseInt64 (" 9223372036854775808" , nullptr ));
895
- BOOST_CHECK (!ParseInt64 (" -32482348723847471234" , nullptr ));
896
- BOOST_CHECK (!ParseInt64 (" 32482348723847471234" , nullptr ));
897
- }
898
-
899
- BOOST_AUTO_TEST_CASE (test_ParseUInt8)
900
- {
901
- uint8_t n;
902
- // Valid values
903
- BOOST_CHECK (ParseUInt8 (" 255" , nullptr ));
904
- BOOST_CHECK (ParseUInt8 (" 0" , &n) && n == 0 );
905
- BOOST_CHECK (ParseUInt8 (" 255" , &n) && n == 255 );
906
- BOOST_CHECK (ParseUInt8 (" 0255" , &n) && n == 255 ); // no octal
907
- BOOST_CHECK (ParseUInt8 (" 255" , &n) && n == static_cast <uint8_t >(255 ));
908
- BOOST_CHECK (ParseUInt8 (" +255" , &n) && n == 255 );
909
- BOOST_CHECK (ParseUInt8 (" 00000000000000000012" , &n) && n == 12 );
910
- BOOST_CHECK (ParseUInt8 (" 00000000000000000000" , &n) && n == 0 );
911
- // Invalid values
912
- BOOST_CHECK (!ParseUInt8 (" -00000000000000000000" , &n));
913
- BOOST_CHECK (!ParseUInt8 (" " , &n));
914
- BOOST_CHECK (!ParseUInt8 (" 1" , &n)); // no padding inside
915
- BOOST_CHECK (!ParseUInt8 (" -1" , &n));
916
- BOOST_CHECK (!ParseUInt8 (" ++1" , &n));
917
- BOOST_CHECK (!ParseUInt8 (" +-1" , &n));
918
- BOOST_CHECK (!ParseUInt8 (" -+1" , &n));
919
- BOOST_CHECK (!ParseUInt8 (" --1" , &n));
920
- BOOST_CHECK (!ParseUInt8 (" -1" , &n));
921
- BOOST_CHECK (!ParseUInt8 (" 1 " , &n));
922
- BOOST_CHECK (!ParseUInt8 (" 1a" , &n));
923
- BOOST_CHECK (!ParseUInt8 (" aap" , &n));
924
- BOOST_CHECK (!ParseUInt8 (" 0x1" , &n)); // no hex
925
- BOOST_CHECK (!ParseUInt8 (STRING_WITH_EMBEDDED_NULL_CHAR, &n));
926
- // Overflow and underflow
927
- BOOST_CHECK (!ParseUInt8 (" -255" , &n));
928
- BOOST_CHECK (!ParseUInt8 (" 256" , &n));
929
- BOOST_CHECK (!ParseUInt8 (" -123" , &n));
930
- BOOST_CHECK (!ParseUInt8 (" -123" , nullptr ));
931
- BOOST_CHECK (!ParseUInt8 (" 256" , nullptr ));
932
- }
933
-
934
- BOOST_AUTO_TEST_CASE (test_ParseUInt16)
935
- {
936
- uint16_t n;
937
- // Valid values
938
- BOOST_CHECK (ParseUInt16 (" 1234" , nullptr ));
939
- BOOST_CHECK (ParseUInt16 (" 0" , &n) && n == 0 );
940
- BOOST_CHECK (ParseUInt16 (" 1234" , &n) && n == 1234 );
941
- BOOST_CHECK (ParseUInt16 (" 01234" , &n) && n == 1234 ); // no octal
942
- BOOST_CHECK (ParseUInt16 (" 65535" , &n) && n == static_cast <uint16_t >(65535 ));
943
- BOOST_CHECK (ParseUInt16 (" +65535" , &n) && n == 65535 );
944
- BOOST_CHECK (ParseUInt16 (" 00000000000000000012" , &n) && n == 12 );
945
- BOOST_CHECK (ParseUInt16 (" 00000000000000000000" , &n) && n == 0 );
946
- // Invalid values
947
- BOOST_CHECK (!ParseUInt16 (" -00000000000000000000" , &n));
948
- BOOST_CHECK (!ParseUInt16 (" " , &n));
949
- BOOST_CHECK (!ParseUInt16 (" 1" , &n)); // no padding inside
950
- BOOST_CHECK (!ParseUInt16 (" -1" , &n));
951
- BOOST_CHECK (!ParseUInt16 (" ++1" , &n));
952
- BOOST_CHECK (!ParseUInt16 (" +-1" , &n));
953
- BOOST_CHECK (!ParseUInt16 (" -+1" , &n));
954
- BOOST_CHECK (!ParseUInt16 (" --1" , &n));
955
- BOOST_CHECK (!ParseUInt16 (" -1" , &n));
956
- BOOST_CHECK (!ParseUInt16 (" 1 " , &n));
957
- BOOST_CHECK (!ParseUInt16 (" 1a" , &n));
958
- BOOST_CHECK (!ParseUInt16 (" aap" , &n));
959
- BOOST_CHECK (!ParseUInt16 (" 0x1" , &n)); // no hex
960
- BOOST_CHECK (!ParseUInt16 (STRING_WITH_EMBEDDED_NULL_CHAR, &n));
961
- // Overflow and underflow
962
- BOOST_CHECK (!ParseUInt16 (" -65535" , &n));
963
- BOOST_CHECK (!ParseUInt16 (" 65536" , &n));
964
- BOOST_CHECK (!ParseUInt16 (" -123" , &n));
965
- BOOST_CHECK (!ParseUInt16 (" -123" , nullptr ));
966
- BOOST_CHECK (!ParseUInt16 (" 65536" , nullptr ));
967
- }
968
-
969
- BOOST_AUTO_TEST_CASE (test_ParseUInt32)
970
- {
971
- uint32_t n;
972
- // Valid values
973
- BOOST_CHECK (ParseUInt32 (" 1234" , nullptr ));
974
- BOOST_CHECK (ParseUInt32 (" 0" , &n) && n == 0 );
975
- BOOST_CHECK (ParseUInt32 (" 1234" , &n) && n == 1234 );
976
- BOOST_CHECK (ParseUInt32 (" 01234" , &n) && n == 1234 ); // no octal
977
- BOOST_CHECK (ParseUInt32 (" 2147483647" , &n) && n == 2147483647 );
978
- BOOST_CHECK (ParseUInt32 (" 2147483648" , &n) && n == uint32_t {2147483648 });
979
- BOOST_CHECK (ParseUInt32 (" 4294967295" , &n) && n == uint32_t {4294967295 });
980
- BOOST_CHECK (ParseUInt32 (" +1234" , &n) && n == 1234 );
981
- BOOST_CHECK (ParseUInt32 (" 00000000000000001234" , &n) && n == 1234 );
982
- BOOST_CHECK (ParseUInt32 (" 00000000000000000000" , &n) && n == 0 );
983
- // Invalid values
984
- BOOST_CHECK (!ParseUInt32 (" -00000000000000000000" , &n));
985
- BOOST_CHECK (!ParseUInt32 (" " , &n));
986
- BOOST_CHECK (!ParseUInt32 (" 1" , &n)); // no padding inside
987
- BOOST_CHECK (!ParseUInt32 (" -1" , &n));
988
- BOOST_CHECK (!ParseUInt32 (" ++1" , &n));
989
- BOOST_CHECK (!ParseUInt32 (" +-1" , &n));
990
- BOOST_CHECK (!ParseUInt32 (" -+1" , &n));
991
- BOOST_CHECK (!ParseUInt32 (" --1" , &n));
992
- BOOST_CHECK (!ParseUInt32 (" -1" , &n));
993
- BOOST_CHECK (!ParseUInt32 (" 1 " , &n));
994
- BOOST_CHECK (!ParseUInt32 (" 1a" , &n));
995
- BOOST_CHECK (!ParseUInt32 (" aap" , &n));
996
- BOOST_CHECK (!ParseUInt32 (" 0x1" , &n)); // no hex
997
- BOOST_CHECK (!ParseUInt32 (STRING_WITH_EMBEDDED_NULL_CHAR, &n));
998
- // Overflow and underflow
999
- BOOST_CHECK (!ParseUInt32 (" -2147483648" , &n));
1000
- BOOST_CHECK (!ParseUInt32 (" 4294967296" , &n));
1001
- BOOST_CHECK (!ParseUInt32 (" -1234" , &n));
1002
- BOOST_CHECK (!ParseUInt32 (" -32482348723847471234" , nullptr ));
1003
- BOOST_CHECK (!ParseUInt32 (" 32482348723847471234" , nullptr ));
1004
- }
1005
-
1006
- BOOST_AUTO_TEST_CASE (test_ParseUInt64)
1007
- {
1008
- uint64_t n;
1009
- // Valid values
1010
- BOOST_CHECK (ParseUInt64 (" 1234" , nullptr ));
1011
- BOOST_CHECK (ParseUInt64 (" 0" , &n) && n == 0LL );
1012
- BOOST_CHECK (ParseUInt64 (" 1234" , &n) && n == 1234LL );
1013
- BOOST_CHECK (ParseUInt64 (" 01234" , &n) && n == 1234LL ); // no octal
1014
- BOOST_CHECK (ParseUInt64 (" 2147483647" , &n) && n == 2147483647LL );
1015
- BOOST_CHECK (ParseUInt64 (" 9223372036854775807" , &n) && n == 9223372036854775807ULL );
1016
- BOOST_CHECK (ParseUInt64 (" 9223372036854775808" , &n) && n == 9223372036854775808ULL );
1017
- BOOST_CHECK (ParseUInt64 (" 18446744073709551615" , &n) && n == 18446744073709551615ULL );
1018
- // Invalid values
1019
- BOOST_CHECK (!ParseUInt64 (" " , &n));
1020
- BOOST_CHECK (!ParseUInt64 (" 1" , &n)); // no padding inside
1021
- BOOST_CHECK (!ParseUInt64 (" -1" , &n));
1022
- BOOST_CHECK (!ParseUInt64 (" 1 " , &n));
1023
- BOOST_CHECK (!ParseUInt64 (" 1a" , &n));
1024
- BOOST_CHECK (!ParseUInt64 (" aap" , &n));
1025
- BOOST_CHECK (!ParseUInt64 (" 0x1" , &n)); // no hex
1026
- BOOST_CHECK (!ParseUInt64 (STRING_WITH_EMBEDDED_NULL_CHAR, &n));
1027
- // Overflow and underflow
1028
- BOOST_CHECK (!ParseUInt64 (" -9223372036854775809" , nullptr ));
1029
- BOOST_CHECK (!ParseUInt64 (" 18446744073709551616" , nullptr ));
1030
- BOOST_CHECK (!ParseUInt64 (" -32482348723847471234" , nullptr ));
1031
- BOOST_CHECK (!ParseUInt64 (" -2147483648" , &n));
1032
- BOOST_CHECK (!ParseUInt64 (" -9223372036854775808" , &n));
1033
- BOOST_CHECK (!ParseUInt64 (" -1234" , &n));
1034
- }
1035
-
1036
837
BOOST_AUTO_TEST_CASE (test_FormatParagraph)
1037
838
{
1038
839
BOOST_CHECK_EQUAL (FormatParagraph (" " , 79 , 0 ), " " );
0 commit comments