Skip to content

Commit 3333282

Browse files
author
MarcoFalke
committed
refactor: Remove unused Parse(U)Int*
1 parent fa84e6c commit 3333282

File tree

5 files changed

+41
-327
lines changed

5 files changed

+41
-327
lines changed

‎src/test/fuzz/locale.cpp‎

Lines changed: 0 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -46,35 +46,15 @@ FUZZ_TARGET(locale)
4646
assert(c_locale != nullptr);
4747

4848
const std::string random_string = fuzzed_data_provider.ConsumeRandomLengthString(5);
49-
int32_t parseint32_out_without_locale;
50-
const bool parseint32_without_locale = ParseInt32(random_string, &parseint32_out_without_locale);
51-
int64_t parseint64_out_without_locale;
52-
const bool parseint64_without_locale = ParseInt64(random_string, &parseint64_out_without_locale);
5349
const int64_t random_int64 = fuzzed_data_provider.ConsumeIntegral<int64_t>();
5450
const std::string tostring_without_locale = util::ToString(random_int64);
55-
// The variable `random_int32` is no longer used, but the harness still needs to
56-
// consume the same data that it did previously to not invalidate existing seeds.
57-
const int32_t random_int32 = fuzzed_data_provider.ConsumeIntegral<int32_t>();
58-
(void)random_int32;
5951
const std::string strprintf_int_without_locale = strprintf("%d", random_int64);
6052
const double random_double = fuzzed_data_provider.ConsumeFloatingPoint<double>();
6153
const std::string strprintf_double_without_locale = strprintf("%f", random_double);
6254

6355
const char* new_locale = std::setlocale(LC_ALL, locale_identifier.c_str());
6456
assert(new_locale != nullptr);
6557

66-
int32_t parseint32_out_with_locale;
67-
const bool parseint32_with_locale = ParseInt32(random_string, &parseint32_out_with_locale);
68-
assert(parseint32_without_locale == parseint32_with_locale);
69-
if (parseint32_without_locale) {
70-
assert(parseint32_out_without_locale == parseint32_out_with_locale);
71-
}
72-
int64_t parseint64_out_with_locale;
73-
const bool parseint64_with_locale = ParseInt64(random_string, &parseint64_out_with_locale);
74-
assert(parseint64_without_locale == parseint64_with_locale);
75-
if (parseint64_without_locale) {
76-
assert(parseint64_out_without_locale == parseint64_out_with_locale);
77-
}
7858
const std::string tostring_with_locale = util::ToString(random_int64);
7959
assert(tostring_without_locale == tostring_with_locale);
8060
const std::string strprintf_int_with_locale = strprintf("%d", random_int64);

‎src/test/fuzz/parse_numbers.cpp‎

Lines changed: 41 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -5,33 +5,59 @@
55
#include <test/fuzz/fuzz.h>
66
#include <util/moneystr.h>
77
#include <util/strencodings.h>
8+
#include <util/string.h>
89

10+
#include <cassert>
11+
#include <cstdint>
12+
#include <optional>
913
#include <string>
1014

1115
FUZZ_TARGET(parse_numbers)
1216
{
1317
const std::string random_string(buffer.begin(), buffer.end());
18+
{
19+
const auto i8{ToIntegral<int8_t>(random_string)};
20+
const auto u8{ToIntegral<uint8_t>(random_string)};
21+
const auto i16{ToIntegral<int16_t>(random_string)};
22+
const auto u16{ToIntegral<uint16_t>(random_string)};
23+
const auto i32{ToIntegral<int32_t>(random_string)};
24+
const auto u32{ToIntegral<uint32_t>(random_string)};
25+
const auto i64{ToIntegral<int64_t>(random_string)};
26+
const auto u64{ToIntegral<uint64_t>(random_string)};
27+
// Dont check any values, just that each success result must fit into
28+
// the one with the largest bit-width.
29+
if (i8) {
30+
assert(i8 == i64);
31+
}
32+
if (u8) {
33+
assert(u8 == u64);
34+
}
35+
if (i16) {
36+
assert(i16 == i64);
37+
}
38+
if (u16) {
39+
assert(u16 == u64);
40+
}
41+
if (i32) {
42+
assert(i32 == i64);
43+
}
44+
if (u32) {
45+
assert(u32 == u64);
46+
}
47+
constexpr auto digits{"0123456789"};
48+
if (i64) {
49+
assert(util::RemovePrefixView(random_string, "-").find_first_not_of(digits) == std::string::npos);
50+
}
51+
if (u64) {
52+
assert(random_string.find_first_not_of(digits) == std::string::npos);
53+
}
54+
}
1455

1556
(void)ParseMoney(random_string);
1657

17-
uint8_t u8;
18-
(void)ParseUInt8(random_string, &u8);
19-
20-
uint16_t u16;
21-
(void)ParseUInt16(random_string, &u16);
22-
23-
int32_t i32;
24-
(void)ParseInt32(random_string, &i32);
2558
(void)LocaleIndependentAtoi<int>(random_string);
2659

27-
uint32_t u32;
28-
(void)ParseUInt32(random_string, &u32);
29-
3060
int64_t i64;
3161
(void)LocaleIndependentAtoi<int64_t>(random_string);
3262
(void)ParseFixedPoint(random_string, 3, &i64);
33-
(void)ParseInt64(random_string, &i64);
34-
35-
uint64_t u64;
36-
(void)ParseUInt64(random_string, &u64);
3763
}

‎src/test/util_tests.cpp‎

Lines changed: 0 additions & 199 deletions
Original file line numberDiff line numberDiff line change
@@ -647,40 +647,6 @@ BOOST_AUTO_TEST_CASE(util_overflow)
647647
TestAddMatrix<signed>();
648648
}
649649

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-
684650
template <typename T>
685651
static void RunToIntegralTests()
686652
{
@@ -868,171 +834,6 @@ BOOST_AUTO_TEST_CASE(test_LocaleIndependentAtoi)
868834
BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint8_t>("256"), 255U);
869835
}
870836

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-
1036837
BOOST_AUTO_TEST_CASE(test_FormatParagraph)
1037838
{
1038839
BOOST_CHECK_EQUAL(FormatParagraph("", 79, 0), "");

‎src/util/strencodings.cpp‎

Lines changed: 0 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -199,57 +199,6 @@ std::optional<std::vector<unsigned char>> DecodeBase32(std::string_view str)
199199
return ret;
200200
}
201201

202-
namespace {
203-
template <typename T>
204-
bool ParseIntegral(std::string_view str, T* out)
205-
{
206-
static_assert(std::is_integral_v<T>);
207-
// Replicate the exact behavior of strtol/strtoll/strtoul/strtoull when
208-
// handling leading +/- for backwards compatibility.
209-
if (str.length() >= 2 && str[0] == '+' && str[1] == '-') {
210-
return false;
211-
}
212-
const std::optional<T> opt_int = ToIntegral<T>((!str.empty() && str[0] == '+') ? str.substr(1) : str);
213-
if (!opt_int) {
214-
return false;
215-
}
216-
if (out != nullptr) {
217-
*out = *opt_int;
218-
}
219-
return true;
220-
}
221-
}; // namespace
222-
223-
bool ParseInt32(std::string_view str, int32_t* out)
224-
{
225-
return ParseIntegral<int32_t>(str, out);
226-
}
227-
228-
bool ParseInt64(std::string_view str, int64_t* out)
229-
{
230-
return ParseIntegral<int64_t>(str, out);
231-
}
232-
233-
bool ParseUInt8(std::string_view str, uint8_t* out)
234-
{
235-
return ParseIntegral<uint8_t>(str, out);
236-
}
237-
238-
bool ParseUInt16(std::string_view str, uint16_t* out)
239-
{
240-
return ParseIntegral<uint16_t>(str, out);
241-
}
242-
243-
bool ParseUInt32(std::string_view str, uint32_t* out)
244-
{
245-
return ParseIntegral<uint32_t>(str, out);
246-
}
247-
248-
bool ParseUInt64(std::string_view str, uint64_t* out)
249-
{
250-
return ParseIntegral<uint64_t>(str, out);
251-
}
252-
253202
std::string FormatParagraph(std::string_view in, size_t width, size_t indent)
254203
{
255204
assert(width >= indent);

0 commit comments

Comments
 (0)