From 840638404af7ebd473eb4fe470012f6798711e16 Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Mon, 30 Dec 2024 23:23:36 +0100 Subject: [PATCH] testautomation: port back SDL3's strtol and strtod tests Triggered by b713e7581b300f25b6356c975178452728185539 --- test/testautomation_stdlib.c | 119 +++++++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+) diff --git a/test/testautomation_stdlib.c b/test/testautomation_stdlib.c index 969dd39b48..30abf0a7f7 100644 --- a/test/testautomation_stdlib.c +++ b/test/testautomation_stdlib.c @@ -392,6 +392,9 @@ int stdlib_getsetenv(void *arg) #endif #endif +#define FMT_PRILLd "%lld" +#define FMT_PRILLu "%llu" + /** * @brief Call to SDL_sscanf */ @@ -713,6 +716,112 @@ stdlib_overflow(void *arg) return TEST_COMPLETED; } +static int +stdlib_strtox(void *arg) +{ + const unsigned long long ullong_max = ~0ULL; + +#define STRTOX_TEST_CASE(func_name, type, format_spec, str, base, expected_result, expected_endp_offset) do { \ + const char *s = str; \ + type r, expected_r = expected_result; \ + char *ep, *expected_ep = (char *)s + expected_endp_offset; \ + r = func_name(s, &ep, base); \ + SDLTest_AssertPass("Call to " #func_name "(" #str ", &endp, " #base ")"); \ + SDLTest_AssertCheck(r == expected_r, "Check result value, expected: " format_spec ", got: " format_spec, expected_r, r); \ + SDLTest_AssertCheck(ep == expected_ep, "Check endp value, expected: %p, got: %p", expected_ep, ep); \ + } while (0) + + // infer decimal + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "\t 123abcxyz", 0, 123, 6); // skip leading space + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "+123abcxyz", 0, 123, 4); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "+123abcxyz", 0, 123, 4); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "-123abcxyz", 0, -123, 4); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "9999999999999999999999999999999999999999abcxyz", 0, ullong_max, 40); + + // infer hexadecimal + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "0x123abcxyz", 0, 0x123abc, 8); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "0X123ABCXYZ", 0, 0x123abc, 8); // uppercase X + + // infer octal + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "0123abcxyz", 0, 0123, 4); + + // arbitrary bases + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "00110011", 2, 51, 8); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "-uvwxyz", 32, -991, 3); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "ZzZzZzZzZzZzZzZzZzZzZzZzZ", 36, ullong_max, 25); + + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "0", 0, 0, 1); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "0", 10, 0, 1); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "-0", 0, 0, 2); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, "-0", 10, 0, 2); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLu, " - 1", 0, 0, 0); // invalid input + + // We know that SDL_strtol, SDL_strtoul and SDL_strtoll share the same code path as SDL_strtoull under the hood, + // so the most interesting test cases are those close to the bounds of the integer type. + + // For simplicity, we only run long/long long tests when they are 32-bit/64-bit, respectively. + // Suppressing warnings would be difficult otherwise. + // Since the CI runs the tests against a variety of targets, this should be fine in practice. + + if (sizeof(long) == 4) { + STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "0", 0, 0, 1); + STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "0", 10, 0, 1); + STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "-0", 0, 0, 2); + STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "-0", 10, 0, 2); + STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "2147483647", 10, 2147483647, 10); + STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "2147483648", 10, 2147483647, 10); + STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "-2147483648", 10, -2147483647L - 1, 11); + STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "-2147483649", 10, -2147483647L - 1, 11); + STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "-9999999999999999999999999999999999999999", 10, -2147483647L - 1, 41); + + STRTOX_TEST_CASE(SDL_strtoul, unsigned long, "%lu", "4294967295", 10, 4294967295UL, 10); + STRTOX_TEST_CASE(SDL_strtoul, unsigned long, "%lu", "4294967296", 10, 4294967295UL, 10); + STRTOX_TEST_CASE(SDL_strtoul, unsigned long, "%lu", "-4294967295", 10, 1, 11); + } + + if (sizeof(long long) == 8) { + STRTOX_TEST_CASE(SDL_strtoll, long long, FMT_PRILLd, "0", 0, 0LL, 1); + STRTOX_TEST_CASE(SDL_strtoll, long long, FMT_PRILLd, "0", 10, 0LL, 1); + STRTOX_TEST_CASE(SDL_strtoll, long long, FMT_PRILLd, "-0", 0, 0LL, 2); + STRTOX_TEST_CASE(SDL_strtoll, long long, FMT_PRILLd, "-0", 10, 0LL, 2); + STRTOX_TEST_CASE(SDL_strtoll, long long, FMT_PRILLd, "9223372036854775807", 10, 9223372036854775807LL, 19); + STRTOX_TEST_CASE(SDL_strtoll, long long, FMT_PRILLd, "9223372036854775808", 10, 9223372036854775807LL, 19); + STRTOX_TEST_CASE(SDL_strtoll, long long, FMT_PRILLd, "-9223372036854775808", 10, -9223372036854775807LL - 1, 20); + STRTOX_TEST_CASE(SDL_strtoll, long long, FMT_PRILLd, "-9223372036854775809", 10, -9223372036854775807LL - 1, 20); + STRTOX_TEST_CASE(SDL_strtoll, long long, FMT_PRILLd, "-9999999999999999999999999999999999999999", 10, -9223372036854775807LL - 1, 41); + + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLd, "18446744073709551615", 10, 18446744073709551615ULL, 20); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLd, "18446744073709551616", 10, 18446744073709551615ULL, 20); + STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, FMT_PRILLd, "-18446744073709551615", 10, 1, 21); + } + +#undef STRTOX_TEST_CASE + + return TEST_COMPLETED; +} + +static int +stdlib_strtod(void *arg) +{ +#define STRTOD_TEST_CASE(str, expected_result, expected_endp_offset) do { \ + const char *s = str; \ + double r, expected_r = expected_result; \ + char *ep, *expected_ep = (char *)s + expected_endp_offset; \ + r = SDL_strtod(s, &ep); \ + SDLTest_AssertPass("Call to SDL_strtod(" #str ", &endp)"); \ + SDLTest_AssertCheck(r == expected_r, "Check result value, expected: %f, got: %f", expected_r, r); \ + SDLTest_AssertCheck(ep == expected_ep, "Check endp value, expected: %p, got: %p", expected_ep, ep); \ + } while (0) + + STRTOD_TEST_CASE("\t 123.75abcxyz", 123.75, 9); // skip leading space + STRTOD_TEST_CASE("+999.555", 999.555, 8); + STRTOD_TEST_CASE("-999.555", -999.555, 8); + +#undef STRTOD_TEST_CASE + + return TEST_COMPLETED; +} + /* ================= Test References ================== */ /* Standard C routine test cases */ @@ -736,6 +845,14 @@ static const SDLTest_TestCaseReference stdlibTestOverflow = { stdlib_overflow, "stdlib_overflow", "Overflow detection", TEST_ENABLED }; +static const SDLTest_TestCaseReference stdlibTest_strtox = { + stdlib_strtox, "stdlib_strtox", "Calls to SDL_strtol, SDL_strtoul, SDL_strtoll and SDL_strtoull", TEST_ENABLED +}; + +static const SDLTest_TestCaseReference stdlibTest_strtod = { + stdlib_strtod, "stdlib_strtod", "Calls to SDL_strtod", TEST_ENABLED +}; + /* Sequence of Standard C routine test cases */ static const SDLTest_TestCaseReference *stdlibTests[] = { &stdlibTest1, @@ -743,6 +860,8 @@ static const SDLTest_TestCaseReference *stdlibTests[] = { &stdlibTest3, &stdlibTest4, &stdlibTestOverflow, + &stdlibTest_strtox, + &stdlibTest_strtod, NULL };