diff --git a/lib/libc/tests/stdio/snprintf_test.c b/lib/libc/tests/stdio/snprintf_test.c index 10d938435b96..323356b37a7d 100644 --- a/lib/libc/tests/stdio/snprintf_test.c +++ b/lib/libc/tests/stdio/snprintf_test.c @@ -127,6 +127,70 @@ ATF_TC_BODY(snprintf_X, tc) SNPRINTF_TEST("0X007FFFFFFF", "%#012X", INT_MAX); } +ATF_TC_WITHOUT_HEAD(snprintf_wN); +ATF_TC_BODY(snprintf_wN, tc) +{ + SNPRINTF_TEST("0", "%w8d", (int8_t)0); + SNPRINTF_TEST("-128", "%w8d", (int8_t)CHAR_MIN); + SNPRINTF_TEST("127", "%w8d", (int8_t)CHAR_MAX); + SNPRINTF_TEST("0", "%w8u", (uint8_t)0); + SNPRINTF_TEST("255", "%w8u", (uint8_t)UCHAR_MAX); + + SNPRINTF_TEST("0", "%w16d", (int16_t)0); + SNPRINTF_TEST("-32768", "%w16d", (int16_t)SHRT_MIN); + SNPRINTF_TEST("32767", "%w16d", (int16_t)SHRT_MAX); + SNPRINTF_TEST("0", "%w16u", (uint16_t)0); + SNPRINTF_TEST("65535", "%w16u", (uint16_t)USHRT_MAX); + + SNPRINTF_TEST("0", "%w32d", (int32_t)0); + SNPRINTF_TEST("-2147483648", "%w32d", (int32_t)INT_MIN); + SNPRINTF_TEST("2147483647", "%w32d", (int32_t)INT_MAX); + SNPRINTF_TEST("0", "%w32u", (uint32_t)0); + SNPRINTF_TEST("4294967295", "%w32u", (uint32_t)UINT_MAX); + + SNPRINTF_TEST("0", "%w64d", (int64_t)0); + SNPRINTF_TEST("-9223372036854775808", "%w64d", (int64_t)LLONG_MIN); + SNPRINTF_TEST("9223372036854775807", "%w64d", (int64_t)LLONG_MAX); + SNPRINTF_TEST("0", "%w64u", (uint64_t)0); + SNPRINTF_TEST("18446744073709551615", "%w64u", (uint64_t)ULLONG_MAX); + + SNPRINTF_TEST("wd", "%wd", 0); + SNPRINTF_TEST("w1d", "%w1d", 0); + SNPRINTF_TEST("w128d", "%w128d", 0); +} + +ATF_TC_WITHOUT_HEAD(snprintf_wfN); +ATF_TC_BODY(snprintf_wfN, tc) +{ + SNPRINTF_TEST("0", "%wf8d", (int_fast8_t)0); + SNPRINTF_TEST("-2147483648", "%wf8d", (int_fast8_t)INT_MIN); + SNPRINTF_TEST("2147483647", "%wf8d", (int_fast8_t)INT_MAX); + SNPRINTF_TEST("0", "%wf8u", (uint8_t)0); + SNPRINTF_TEST("4294967295", "%wf8u", (uint_fast8_t)UINT_MAX); + + SNPRINTF_TEST("0", "%wf16d", (int_fast16_t)0); + SNPRINTF_TEST("-2147483648", "%wf16d", (int_fast16_t)INT_MIN); + SNPRINTF_TEST("2147483647", "%wf16d", (int_fast16_t)INT_MAX); + SNPRINTF_TEST("0", "%wf16u", (uint16_t)0); + SNPRINTF_TEST("4294967295", "%wf16u", (uint_fast16_t)UINT_MAX); + + SNPRINTF_TEST("0", "%wf32d", (int_fast32_t)0); + SNPRINTF_TEST("-2147483648", "%wf32d", (int_fast32_t)INT_MIN); + SNPRINTF_TEST("2147483647", "%wf32d", (int_fast32_t)INT_MAX); + SNPRINTF_TEST("0", "%wf32u", (uint32_t)0); + SNPRINTF_TEST("4294967295", "%wf32u", (uint_fast32_t)UINT_MAX); + + SNPRINTF_TEST("0", "%wf64d", (int_fast64_t)0); + SNPRINTF_TEST("-9223372036854775808", "%wf64d", (int_fast64_t)LLONG_MIN); + SNPRINTF_TEST("9223372036854775807", "%wf64d", (int_fast64_t)LLONG_MAX); + SNPRINTF_TEST("0", "%wf64u", (uint64_t)0); + SNPRINTF_TEST("18446744073709551615", "%wf64u", (uint_fast64_t)ULLONG_MAX); + + SNPRINTF_TEST("wfd", "%wfd", 0); + SNPRINTF_TEST("wf1d", "%wf1d", 0); + SNPRINTF_TEST("wf128d", "%wf128d", 0); +} + ATF_TP_ADD_TCS(tp) { setlocale(LC_NUMERIC, "en_US.UTF-8"); @@ -135,5 +199,7 @@ ATF_TP_ADD_TCS(tp) ATF_TP_ADD_TC(tp, snprintf_d); ATF_TP_ADD_TC(tp, snprintf_x); ATF_TP_ADD_TC(tp, snprintf_X); + ATF_TP_ADD_TC(tp, snprintf_wN); + ATF_TP_ADD_TC(tp, snprintf_wfN); return (atf_no_error()); } diff --git a/lib/libc/tests/stdio/sscanf_test.c b/lib/libc/tests/stdio/sscanf_test.c index 462b4a6586da..e916873d38c3 100644 --- a/lib/libc/tests/stdio/sscanf_test.c +++ b/lib/libc/tests/stdio/sscanf_test.c @@ -4,6 +4,7 @@ * SPDX-License-Identifier: BSD-2-Clause */ +#include #include #include #include @@ -237,6 +238,68 @@ ATF_TC_BODY(sscanf_i, tc) } } +ATF_TC_WITHOUT_HEAD(sscanf_wN); +ATF_TC_BODY(sscanf_wN, tc) +{ + const char x00[] = "0x00"; + const char x7f[] = "0x7fffffffffffffff"; + const char xff[] = "0xffffffffffffffff"; + +#define SSCANF_WN_TEST(N, imin, umax) \ + do { \ + int##N##_t i; \ + uint##N##_t u; \ + ATF_CHECK_EQ(1, sscanf(x00, "%w" #N "i", &i)); \ + ATF_CHECK_EQ(0, i); \ + ATF_CHECK_EQ(1, sscanf(x7f, "%w" #N "i", &i)); \ + ATF_CHECK_EQ(imin, i); \ + ATF_CHECK_EQ(1, sscanf(x00, "%w" #N "x", &u)); \ + ATF_CHECK_EQ(0, u); \ + ATF_CHECK_EQ(1, sscanf(xff, "%w" #N "x", &u)); \ + ATF_CHECK_EQ(umax, u); \ + } while (0) + SSCANF_WN_TEST(8, -1, UCHAR_MAX); + SSCANF_WN_TEST(16, -1, USHRT_MAX); + SSCANF_WN_TEST(32, -1, UINT_MAX); + SSCANF_WN_TEST(64, LLONG_MAX, ULLONG_MAX); +#undef SSCANF_WN_TEST + + ATF_CHECK_EQ(0, sscanf(x00, "%wi", (int *)NULL)); + ATF_CHECK_EQ(0, sscanf(x00, "%w1i", (int *)NULL)); + ATF_CHECK_EQ(0, sscanf(x00, "%w128i", (int *)NULL)); +} + +ATF_TC_WITHOUT_HEAD(sscanf_wfN); +ATF_TC_BODY(sscanf_wfN, tc) +{ + const char x00[] = "0x00"; + const char x7f[] = "0x7fffffffffffffff"; + const char xff[] = "0xffffffffffffffff"; + +#define SSCANF_WFN_TEST(N, imin, umax) \ + do { \ + int_fast##N##_t i; \ + uint_fast##N##_t u; \ + ATF_CHECK_EQ(1, sscanf(x00, "%wf" #N "i", &i)); \ + ATF_CHECK_EQ(0, i); \ + ATF_CHECK_EQ(1, sscanf(x7f, "%wf" #N "i", &i)); \ + ATF_CHECK_EQ(imin, i); \ + ATF_CHECK_EQ(1, sscanf(x00, "%wf" #N "x", &u)); \ + ATF_CHECK_EQ(0, u); \ + ATF_CHECK_EQ(1, sscanf(xff, "%wf" #N "x", &u)); \ + ATF_CHECK_EQ(umax, u); \ + } while (0) + SSCANF_WFN_TEST(8, -1, UINT_MAX); + SSCANF_WFN_TEST(16, -1, UINT_MAX); + SSCANF_WFN_TEST(32, -1, UINT_MAX); + SSCANF_WFN_TEST(64, LLONG_MAX, ULLONG_MAX); +#undef SSCANF_WFN_TEST + + ATF_CHECK_EQ(0, sscanf(x00, "%wfi", (int *)NULL)); + ATF_CHECK_EQ(0, sscanf(x00, "%wf1i", (int *)NULL)); + ATF_CHECK_EQ(0, sscanf(x00, "%wf128i", (int *)NULL)); +} + /* * Test termination cases: non-numeric character, fixed width, EOF */ @@ -261,6 +324,8 @@ ATF_TP_ADD_TCS(tp) ATF_TP_ADD_TC(tp, sscanf_d); ATF_TP_ADD_TC(tp, sscanf_x); ATF_TP_ADD_TC(tp, sscanf_i); + ATF_TP_ADD_TC(tp, sscanf_wN); + ATF_TP_ADD_TC(tp, sscanf_wfN); ATF_TP_ADD_TC(tp, sscanf_termination); return (atf_no_error()); } diff --git a/lib/libc/tests/stdio/swprintf_test.c b/lib/libc/tests/stdio/swprintf_test.c index 23859b5cd2e1..f5dde349412b 100644 --- a/lib/libc/tests/stdio/swprintf_test.c +++ b/lib/libc/tests/stdio/swprintf_test.c @@ -128,6 +128,70 @@ ATF_TC_BODY(swprintf_X, tc) SWPRINTF_TEST("0X007FFFFFFF", "%#012X", INT_MAX); } +ATF_TC_WITHOUT_HEAD(swprintf_wN); +ATF_TC_BODY(swprintf_wN, tc) +{ + SWPRINTF_TEST("0", "%w8d", (int8_t)0); + SWPRINTF_TEST("-128", "%w8d", (int8_t)CHAR_MIN); + SWPRINTF_TEST("127", "%w8d", (int8_t)CHAR_MAX); + SWPRINTF_TEST("0", "%w8u", (uint8_t)0); + SWPRINTF_TEST("255", "%w8u", (uint8_t)UCHAR_MAX); + + SWPRINTF_TEST("0", "%w16d", (int16_t)0); + SWPRINTF_TEST("-32768", "%w16d", (int16_t)SHRT_MIN); + SWPRINTF_TEST("32767", "%w16d", (int16_t)SHRT_MAX); + SWPRINTF_TEST("0", "%w16u", (uint16_t)0); + SWPRINTF_TEST("65535", "%w16u", (uint16_t)USHRT_MAX); + + SWPRINTF_TEST("0", "%w32d", (int32_t)0); + SWPRINTF_TEST("-2147483648", "%w32d", (int32_t)INT_MIN); + SWPRINTF_TEST("2147483647", "%w32d", (int32_t)INT_MAX); + SWPRINTF_TEST("0", "%w32u", (uint32_t)0); + SWPRINTF_TEST("4294967295", "%w32u", (uint32_t)UINT_MAX); + + SWPRINTF_TEST("0", "%w64d", (int64_t)0); + SWPRINTF_TEST("-9223372036854775808", "%w64d", (int64_t)LLONG_MIN); + SWPRINTF_TEST("9223372036854775807", "%w64d", (int64_t)LLONG_MAX); + SWPRINTF_TEST("0", "%w64u", (uint64_t)0); + SWPRINTF_TEST("18446744073709551615", "%w64u", (uint64_t)ULLONG_MAX); + + SWPRINTF_TEST("wd", "%wd", 0); + SWPRINTF_TEST("w1d", "%w1d", 0); + SWPRINTF_TEST("w128d", "%w128d", 0); +} + +ATF_TC_WITHOUT_HEAD(swprintf_wfN); +ATF_TC_BODY(swprintf_wfN, tc) +{ + SWPRINTF_TEST("0", "%wf8d", (int_fast8_t)0); + SWPRINTF_TEST("-2147483648", "%wf8d", (int_fast8_t)INT_MIN); + SWPRINTF_TEST("2147483647", "%wf8d", (int_fast8_t)INT_MAX); + SWPRINTF_TEST("0", "%wf8u", (uint8_t)0); + SWPRINTF_TEST("4294967295", "%wf8u", (uint_fast8_t)UINT_MAX); + + SWPRINTF_TEST("0", "%wf16d", (int_fast16_t)0); + SWPRINTF_TEST("-2147483648", "%wf16d", (int_fast16_t)INT_MIN); + SWPRINTF_TEST("2147483647", "%wf16d", (int_fast16_t)INT_MAX); + SWPRINTF_TEST("0", "%wf16u", (uint16_t)0); + SWPRINTF_TEST("4294967295", "%wf16u", (uint_fast16_t)UINT_MAX); + + SWPRINTF_TEST("0", "%wf32d", (int_fast32_t)0); + SWPRINTF_TEST("-2147483648", "%wf32d", (int_fast32_t)INT_MIN); + SWPRINTF_TEST("2147483647", "%wf32d", (int_fast32_t)INT_MAX); + SWPRINTF_TEST("0", "%wf32u", (uint32_t)0); + SWPRINTF_TEST("4294967295", "%wf32u", (uint_fast32_t)UINT_MAX); + + SWPRINTF_TEST("0", "%wf64d", (int_fast64_t)0); + SWPRINTF_TEST("-9223372036854775808", "%wf64d", (int_fast64_t)LLONG_MIN); + SWPRINTF_TEST("9223372036854775807", "%wf64d", (int_fast64_t)LLONG_MAX); + SWPRINTF_TEST("0", "%wf64u", (uint64_t)0); + SWPRINTF_TEST("18446744073709551615", "%wf64u", (uint_fast64_t)ULLONG_MAX); + + SWPRINTF_TEST("wfd", "%wfd", 0); + SWPRINTF_TEST("wf1d", "%wf1d", 0); + SWPRINTF_TEST("wf128d", "%wf128d", 0); +} + ATF_TP_ADD_TCS(tp) { setlocale(LC_NUMERIC, "en_US.UTF-8"); @@ -136,5 +200,7 @@ ATF_TP_ADD_TCS(tp) ATF_TP_ADD_TC(tp, swprintf_d); ATF_TP_ADD_TC(tp, swprintf_x); ATF_TP_ADD_TC(tp, swprintf_X); + ATF_TP_ADD_TC(tp, swprintf_wN); + ATF_TP_ADD_TC(tp, swprintf_wfN); return (atf_no_error()); } diff --git a/lib/libc/tests/stdio/swscanf_test.c b/lib/libc/tests/stdio/swscanf_test.c index 10eaf786e5fa..f7ad30b963a7 100644 --- a/lib/libc/tests/stdio/swscanf_test.c +++ b/lib/libc/tests/stdio/swscanf_test.c @@ -4,6 +4,7 @@ * SPDX-License-Identifier: BSD-2-Clause */ +#include #include #include #include @@ -11,6 +12,8 @@ #include +#define L(s) L ## s + static const struct swscanf_test_case { wchar_t input[8]; struct { @@ -150,7 +153,7 @@ static const struct swscanf_test_case { #define SWSCANF_TEST(string, format, expret, expval, explen) \ do { \ int ret = 0, val = 0, len = 0; \ - ret = swscanf(string, format "%n", &val, &len); \ + ret = swscanf(string, format L"%n", &val, &len); \ ATF_CHECK_EQ(expret, ret); \ if (expret && ret) { \ ATF_CHECK_EQ(expval, val); \ @@ -238,6 +241,68 @@ ATF_TC_BODY(swscanf_i, tc) } } +ATF_TC_WITHOUT_HEAD(swscanf_wN); +ATF_TC_BODY(swscanf_wN, tc) +{ + const wchar_t x00[] = L"0x00"; + const wchar_t x7f[] = L"0x7fffffffffffffff"; + const wchar_t xff[] = L"0xffffffffffffffff"; + +#define SWSCANF_WN_TEST(N, imin, umax) \ + do { \ + int##N##_t i; \ + uint##N##_t u; \ + ATF_CHECK_EQ(1, swscanf(x00, L"%w" L(#N) L"i", &i)); \ + ATF_CHECK_EQ(0, i); \ + ATF_CHECK_EQ(1, swscanf(x7f, L"%w" L(#N) L"i", &i)); \ + ATF_CHECK_EQ(imin, i); \ + ATF_CHECK_EQ(1, swscanf(x00, L"%w" L(#N) L"x", &u)); \ + ATF_CHECK_EQ(0, u); \ + ATF_CHECK_EQ(1, swscanf(xff, L"%w" L(#N) L"x", &u)); \ + ATF_CHECK_EQ(umax, u); \ + } while (0) + SWSCANF_WN_TEST(8, -1, UCHAR_MAX); + SWSCANF_WN_TEST(16, -1, USHRT_MAX); + SWSCANF_WN_TEST(32, -1, UINT_MAX); + SWSCANF_WN_TEST(64, LLONG_MAX, ULLONG_MAX); +#undef SWSCANF_WN_TEST + + ATF_CHECK_EQ(0, swscanf(x00, L"%wi", (int *)NULL)); + ATF_CHECK_EQ(0, swscanf(x00, L"%w1i", (int *)NULL)); + ATF_CHECK_EQ(0, swscanf(x00, L"%w128i", (int *)NULL)); +} + +ATF_TC_WITHOUT_HEAD(swscanf_wfN); +ATF_TC_BODY(swscanf_wfN, tc) +{ + const wchar_t x00[] = L"0x00"; + const wchar_t x7f[] = L"0x7fffffffffffffff"; + const wchar_t xff[] = L"0xffffffffffffffff"; + +#define SWSCANF_WFN_TEST(N, imin, umax) \ + do { \ + int_fast##N##_t i; \ + uint_fast##N##_t u; \ + ATF_CHECK_EQ(1, swscanf(x00, L"%wf" L(#N) L"i", &i)); \ + ATF_CHECK_EQ(0, i); \ + ATF_CHECK_EQ(1, swscanf(x7f, L"%wf" L(#N) L"i", &i)); \ + ATF_CHECK_EQ(imin, i); \ + ATF_CHECK_EQ(1, swscanf(x00, L"%wf" L(#N) L"x", &u)); \ + ATF_CHECK_EQ(0, u); \ + ATF_CHECK_EQ(1, swscanf(xff, L"%wf" L(#N) L"x", &u)); \ + ATF_CHECK_EQ(umax, u); \ + } while (0) + SWSCANF_WFN_TEST(8, -1, UINT_MAX); + SWSCANF_WFN_TEST(16, -1, UINT_MAX); + SWSCANF_WFN_TEST(32, -1, UINT_MAX); + SWSCANF_WFN_TEST(64, LLONG_MAX, ULLONG_MAX); +#undef SWSCANF_WFN_TEST + + ATF_CHECK_EQ(0, swscanf(x00, L"%wfi", (int *)NULL)); + ATF_CHECK_EQ(0, swscanf(x00, L"%wf1i", (int *)NULL)); + ATF_CHECK_EQ(0, swscanf(x00, L"%wf128i", (int *)NULL)); +} + /* * Test termination cases: non-numeric character, fixed width, EOF */ @@ -245,9 +310,9 @@ ATF_TC_WITHOUT_HEAD(swscanf_termination); ATF_TC_BODY(swscanf_termination, tc) { int a = 0, b = 0, c = 0; - char d = 0; + wchar_t d = 0; - ATF_CHECK_EQ(4, swscanf(L"3.1415", L"%d%c%2d%d", &a, &d, &b, &c)); + ATF_CHECK_EQ(4, swscanf(L"3.1415", L"%d%lc%2d%d", &a, &d, &b, &c)); ATF_CHECK_EQ(3, a); ATF_CHECK_EQ(14, b); ATF_CHECK_EQ(15, c); @@ -262,6 +327,8 @@ ATF_TP_ADD_TCS(tp) ATF_TP_ADD_TC(tp, swscanf_d); ATF_TP_ADD_TC(tp, swscanf_x); ATF_TP_ADD_TC(tp, swscanf_i); + ATF_TP_ADD_TC(tp, swscanf_wN); + ATF_TP_ADD_TC(tp, swscanf_wfN); ATF_TP_ADD_TC(tp, swscanf_termination); return (atf_no_error()); }