Skip site navigation (1)Skip section navigation (2)
Date:      Thu, 7 Sep 2023 06:41:59 GMT
From:      Dag-Erling =?utf-8?Q?Sm=C3=B8rgrav?= <des@FreeBSD.org>
To:        src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-main@FreeBSD.org
Subject:   git: 12b1c1e3fb44 - main - libc: Add test cases for N2680.
Message-ID:  <202309070641.3876fxe5002854@gitrepo.freebsd.org>

next in thread | raw e-mail | index | archive | help
The branch main has been updated by des:

URL: https://cgit.FreeBSD.org/src/commit/?id=12b1c1e3fb446021a881d9815465137843fca50b

commit 12b1c1e3fb446021a881d9815465137843fca50b
Author:     Dag-Erling Smørgrav <des@FreeBSD.org>
AuthorDate: 2023-09-07 06:14:49 +0000
Commit:     Dag-Erling Smørgrav <des@FreeBSD.org>
CommitDate: 2023-09-07 06:40:14 +0000

    libc: Add test cases for N2680.
    
    This adds test cases for %wN and %wfN to the printf(3) and scanf(3) tests.
    
    While here, fix a few nits in the N2630 test cases.
    
    Reviewed by:    imp
    Differential Revision:  https://reviews.freebsd.org/D41743
---
 lib/libc/tests/stdio/snprintf_test.c | 66 ++++++++++++++++++++++++++++++++
 lib/libc/tests/stdio/sscanf_test.c   | 65 ++++++++++++++++++++++++++++++++
 lib/libc/tests/stdio/swprintf_test.c | 66 ++++++++++++++++++++++++++++++++
 lib/libc/tests/stdio/swscanf_test.c  | 73 ++++++++++++++++++++++++++++++++++--
 4 files changed, 267 insertions(+), 3 deletions(-)

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 <limits.h>
 #include <locale.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -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 <limits.h>
 #include <locale.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -11,6 +12,8 @@
 
 #include <atf-c.h>
 
+#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());
 }



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?202309070641.3876fxe5002854>