From: Paul Eggert Date: Fri, 8 May 2026 19:48:04 +0000 (-0700) Subject: Pacify -Wuseless-cast via compound literals in tests X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=33cc6fca55f61a5d57b4b65a9c9cc6fcf28d95bc;p=thirdparty%2Fgnulib.git Pacify -Wuseless-cast via compound literals in tests * tests/from-glibc/tst-stdbit.h (TEST_STDBIT_T): * tests/jit/test-cache.c, tests/test-boot-time.c: * tests/test-ceilf2.c, tests/test-fflush.c, tests/test-floorf2.c: * tests/test-mbrtoc32-regular.c, tests/test-mbrtoc32.c: * tests/test-mbrtowc-w32utf8.c, tests/test-mbrtowc.c: * tests/test-mbsnrtoc32s.c, tests/test-mbsnrtowcs.c: * tests/test-mbsrtoc32s.c, tests/test-mbsrtowcs.c: * tests/test-mbstoc32s.c, tests/test-mbstowcs.c: * tests/test-sameacls.c, tests/test-towctrans.c: * tests/test-truncf2.c, tests/test-wcscmp.c, tests/test-wcsncmp.c: * tests/test-wmemcmp.c: (main) * tests/test-c32isalnum.c, tests/test-c32isalpha.c: * tests/test-c32isblank.c, tests/test-c32iscntrl.c: * tests/test-c32isdigit.c, tests/test-c32isgraph.c: * tests/test-c32islower.c, tests/test-c32isprint.c: * tests/test-c32ispunct.c, tests/test-c32isspace.c: * tests/test-c32isupper.c, tests/test-c32isxdigit.c: * tests/test-c32tolower.c, tests/test-c32toupper.c: * tests/test-iswdigit.c, tests/test-iswpunct.c, tests/test-iswxdigit.c: (for_character): * tests/test-c32rtomb.c, tests/test-wcrtomb.c: (check_character): * tests/test-mbrtoc32-w32.c, tests/test-mbrtowc-w32.c: (test_one_locale): * tests/test-snprintf-posix.h, tests/test-sprintf-posix.h: * tests/test-vasnprintf-posix.c, tests/test-vasnwprintf-posix.c: * tests/test-vasprintf-posix.c: (test_function): * tests/test-stat-time.c (initialize_filenames): * tests/uniwidth/test-uc_width2.c (finish_interval): Use compound literal when it is safer than a cast and it pacifies -Wuseless-cast. Also, omit unnecessary casts to a type when the context is already that type and omitting pacifies -Wuseless-cast. --- diff --git a/ChangeLog b/ChangeLog index 2d26bbcd89..e3b0863ac8 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,41 @@ 2026-05-08 Paul Eggert + Pacify -Wuseless-cast via compound literals in tests + * tests/from-glibc/tst-stdbit.h (TEST_STDBIT_T): + * tests/jit/test-cache.c, tests/test-boot-time.c: + * tests/test-ceilf2.c, tests/test-fflush.c, tests/test-floorf2.c: + * tests/test-mbrtoc32-regular.c, tests/test-mbrtoc32.c: + * tests/test-mbrtowc-w32utf8.c, tests/test-mbrtowc.c: + * tests/test-mbsnrtoc32s.c, tests/test-mbsnrtowcs.c: + * tests/test-mbsrtoc32s.c, tests/test-mbsrtowcs.c: + * tests/test-mbstoc32s.c, tests/test-mbstowcs.c: + * tests/test-sameacls.c, tests/test-towctrans.c: + * tests/test-truncf2.c, tests/test-wcscmp.c, tests/test-wcsncmp.c: + * tests/test-wmemcmp.c: + (main) + * tests/test-c32isalnum.c, tests/test-c32isalpha.c: + * tests/test-c32isblank.c, tests/test-c32iscntrl.c: + * tests/test-c32isdigit.c, tests/test-c32isgraph.c: + * tests/test-c32islower.c, tests/test-c32isprint.c: + * tests/test-c32ispunct.c, tests/test-c32isspace.c: + * tests/test-c32isupper.c, tests/test-c32isxdigit.c: + * tests/test-c32tolower.c, tests/test-c32toupper.c: + * tests/test-iswdigit.c, tests/test-iswpunct.c, tests/test-iswxdigit.c: + (for_character): + * tests/test-c32rtomb.c, tests/test-wcrtomb.c: + (check_character): + * tests/test-mbrtoc32-w32.c, tests/test-mbrtowc-w32.c: + (test_one_locale): + * tests/test-snprintf-posix.h, tests/test-sprintf-posix.h: + * tests/test-vasnprintf-posix.c, tests/test-vasnwprintf-posix.c: + * tests/test-vasprintf-posix.c: + (test_function): + * tests/test-stat-time.c (initialize_filenames): + * tests/uniwidth/test-uc_width2.c (finish_interval): + Use compound literal when it is safer than a cast and it pacifies + -Wuseless-cast. Also, omit unnecessary casts to a type when the + context is already that type and omitting pacifies -Wuseless-cast. + Pacify -Wuseless-cast via compound literals in lib * lib/bitset.c (bitset_print): * lib/bitset/list.c (LBITSET_ELT_BITS, debug_lbitset): diff --git a/tests/from-glibc/tst-stdbit.h b/tests/from-glibc/tst-stdbit.h index 8453ffef93..bafd8d4c1d 100644 --- a/tests/from-glibc/tst-stdbit.h +++ b/tests/from-glibc/tst-stdbit.h @@ -85,36 +85,36 @@ struct stdbit_test TEST_TYPE (FUNC ## SUFFIX (X), TTYPE); \ TEST_COMPARE ((FUNC ## SUFFIX) (X), (RES)); \ TEST_TYPE ((FUNC ## SUFFIX) (X), TTYPE); \ - TEST_COMPARE (FUNC ## SUFFIX ((TYPE) (X)), (RES)); \ - TEST_TYPE (FUNC ## SUFFIX ((TYPE) (X)), TTYPE); \ - TEST_COMPARE ((FUNC ## SUFFIX) ((TYPE) (X)), (RES)); \ - TEST_TYPE ((FUNC ## SUFFIX) ((TYPE) (X)), TTYPE); \ - TEST_COMPARE (FUNC ((TYPE) (X)), (RES)); \ - TEST_TYPE (FUNC ((TYPE) (X)), TTYPE); \ + TEST_COMPARE (FUNC ## SUFFIX ((TYPE) {(X)}), (RES)); \ + TEST_TYPE (FUNC ## SUFFIX ((TYPE) {(X)}), TTYPE); \ + TEST_COMPARE ((FUNC ## SUFFIX) ((TYPE) {(X)}), (RES)); \ + TEST_TYPE ((FUNC ## SUFFIX) ((TYPE) {(X)}), TTYPE); \ + TEST_COMPARE (FUNC ((TYPE) {(X)}), (RES)); \ + TEST_TYPE (FUNC ((TYPE) {(X)}), TTYPE); \ if (sizeof (TYPE) <= 2) \ { \ - TEST_COMPARE (FUNC ## SUFFIX ((float) (TYPE) (X)), (RES)); \ - TEST_TYPE (FUNC ## SUFFIX ((float) (TYPE) (X)), TTYPE); \ - TEST_COMPARE ((FUNC ## SUFFIX) ((float) (TYPE) (X)), (RES)); \ - TEST_TYPE ((FUNC ## SUFFIX) ((float) (TYPE) (X)), TTYPE); \ + TEST_COMPARE (FUNC ## SUFFIX ((float) (TYPE) {(X)}), (RES)); \ + TEST_TYPE (FUNC ## SUFFIX ((float) (TYPE) {(X)}), TTYPE); \ + TEST_COMPARE ((FUNC ## SUFFIX) ((float) (TYPE) {(X)}), (RES)); \ + TEST_TYPE ((FUNC ## SUFFIX) ((float) (TYPE) {(X)}), TTYPE); \ } \ if (sizeof (TYPE) <= 4) \ { \ - TEST_COMPARE (FUNC ## SUFFIX ((double) (TYPE) (X)), (RES)); \ - TEST_TYPE (FUNC ## SUFFIX ((double) (TYPE) (X)), TTYPE); \ - TEST_COMPARE ((FUNC ## SUFFIX) ((double) (TYPE) (X)), (RES)); \ - TEST_TYPE ((FUNC ## SUFFIX) ((double) (TYPE) (X)), TTYPE); \ - TEST_COMPARE (FUNC ## SUFFIX ((long double) (TYPE) (X)), (RES)); \ - TEST_TYPE (FUNC ## SUFFIX ((long double) (TYPE) (X)), TTYPE); \ - TEST_COMPARE ((FUNC ## SUFFIX) ((long double) (TYPE) (X)), (RES)); \ - TEST_TYPE ((FUNC ## SUFFIX) ((long double) (TYPE) (X)), TTYPE); \ + TEST_COMPARE (FUNC ## SUFFIX ((double) (TYPE) {(X)}), (RES)); \ + TEST_TYPE (FUNC ## SUFFIX ((double) (TYPE) {(X)}), TTYPE); \ + TEST_COMPARE ((FUNC ## SUFFIX) ((double) (TYPE) {(X)}), (RES)); \ + TEST_TYPE ((FUNC ## SUFFIX) ((double) (TYPE) {(X)}), TTYPE); \ + TEST_COMPARE (FUNC ## SUFFIX ((long double) (TYPE) {(X)}), (RES)); \ + TEST_TYPE (FUNC ## SUFFIX ((long double) (TYPE) {(X)}), TTYPE); \ + TEST_COMPARE ((FUNC ## SUFFIX) ((long double) (TYPE) {(X)}), (RES));\ + TEST_TYPE ((FUNC ## SUFFIX) ((long double) (TYPE) {(X)}), TTYPE); \ } \ TYPE xt = (X); \ TEST_COMPARE (FUNC ## SUFFIX (xt++), (RES)); \ - TEST_COMPARE (xt, (TYPE) ((X) + 1)); \ + TEST_COMPARE (xt, (TYPE) {(X) + 1}); \ xt = (X); \ TEST_COMPARE (FUNC (xt++), (RES)); \ - TEST_COMPARE (xt, (TYPE) ((X) + 1)); \ + TEST_COMPARE (xt, (TYPE) {(X) + 1}); \ } \ while (0) diff --git a/tests/jit/test-cache.c b/tests/jit/test-cache.c index 65da24018e..d465fba0ed 100644 --- a/tests/jit/test-cache.c +++ b/tests/jit/test-cache.c @@ -318,7 +318,8 @@ main () char filename[100]; sprintf (filename, "%s/gnulib-test-cache-%u-%d-%ld", - "/tmp", (unsigned int) getuid (), (int) getpid (), random ()); + "/tmp", (unsigned int) {getuid ()}, (int) {getpid ()}, + random ()); # ifdef KEEP_TEMP_FILE_VISIBLE if (register_temporary_file (filename) < 0) return 2; diff --git a/tests/test-boot-time.c b/tests/test-boot-time.c index 4997f148fd..52ad6c06b4 100644 --- a/tests/test-boot-time.c +++ b/tests/test-boot-time.c @@ -39,7 +39,7 @@ main (int argc, char *argv[]) char timbuf[100]; ASSERT (strftime (timbuf, sizeof (timbuf), "%Y-%m-%d %H:%M:%S", gmt) > 0); - printf ("Boot time (UTC): %s.%09ld\n", timbuf, (long) boot_time.tv_nsec); + printf ("Boot time (UTC): %s.%09ld\n", timbuf, (long) {boot_time.tv_nsec}); /* If the boot time is more than 5 years in the past or more than a week in the future, the value must be wrong. diff --git a/tests/test-c32isalnum.c b/tests/test-c32isalnum.c index 17880fa14b..fd7fb77584 100644 --- a/tests/test-c32isalnum.c +++ b/tests/test-c32isalnum.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32isalpha.c b/tests/test-c32isalpha.c index bd47384264..cec64cad90 100644 --- a/tests/test-c32isalpha.c +++ b/tests/test-c32isalpha.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32isblank.c b/tests/test-c32isblank.c index 33e7c3c8ff..87dad230c4 100644 --- a/tests/test-c32isblank.c +++ b/tests/test-c32isblank.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32iscntrl.c b/tests/test-c32iscntrl.c index 8bf7d35cdc..812be2ec8a 100644 --- a/tests/test-c32iscntrl.c +++ b/tests/test-c32iscntrl.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32isdigit.c b/tests/test-c32isdigit.c index 97b3538e51..90ac4fcab1 100644 --- a/tests/test-c32isdigit.c +++ b/tests/test-c32isdigit.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32isgraph.c b/tests/test-c32isgraph.c index 471710f37a..2733280d2d 100644 --- a/tests/test-c32isgraph.c +++ b/tests/test-c32isgraph.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32islower.c b/tests/test-c32islower.c index ea176b1428..b9fc7a070c 100644 --- a/tests/test-c32islower.c +++ b/tests/test-c32islower.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32isprint.c b/tests/test-c32isprint.c index c64eec431e..9d91ef3640 100644 --- a/tests/test-c32isprint.c +++ b/tests/test-c32isprint.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32ispunct.c b/tests/test-c32ispunct.c index 52be41e02d..d7493d0589 100644 --- a/tests/test-c32ispunct.c +++ b/tests/test-c32ispunct.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32isspace.c b/tests/test-c32isspace.c index 1b1a679d26..55eb50383c 100644 --- a/tests/test-c32isspace.c +++ b/tests/test-c32isspace.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32isupper.c b/tests/test-c32isupper.c index 3c70a0d801..5adfbeaa3e 100644 --- a/tests/test-c32isupper.c +++ b/tests/test-c32isupper.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32isxdigit.c b/tests/test-c32isxdigit.c index 9367de8ba2..20c5c0e7a3 100644 --- a/tests/test-c32isxdigit.c +++ b/tests/test-c32isxdigit.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32rtomb.c b/tests/test-c32rtomb.c index 9f3c690fe1..20cbc85baf 100644 --- a/tests/test-c32rtomb.c +++ b/tests/test-c32rtomb.c @@ -40,7 +40,7 @@ check_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; iret = mbrtoc32 (&wc, s, n, &state); ASSERT (iret == n); diff --git a/tests/test-c32tolower.c b/tests/test-c32tolower.c index 62ac907121..982657fa17 100644 --- a/tests/test-c32tolower.c +++ b/tests/test-c32tolower.c @@ -47,7 +47,7 @@ for_character (const char *s, size_t n) struct multibyte result; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-c32toupper.c b/tests/test-c32toupper.c index 8d050cb058..10a2a1f55b 100644 --- a/tests/test-c32toupper.c +++ b/tests/test-c32toupper.c @@ -47,7 +47,7 @@ for_character (const char *s, size_t n) struct multibyte result; memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, s, n, &state); ASSERT (ret == n); diff --git a/tests/test-ceilf2.c b/tests/test-ceilf2.c index 66641469f6..02e809f2f3 100644 --- a/tests/test-ceilf2.c +++ b/tests/test-ceilf2.c @@ -160,8 +160,8 @@ main () /* Combine highbits and lowbits into a floating-point number, sign-extending the lowbits to 32-NUM_HIGHBITS bits. */ union { float f; uint32_t i; } janus; - janus.i = ((uint32_t) highbits << (32 - NUM_HIGHBITS)) - | ((uint32_t) ((int32_t) ((uint32_t) lowbits << (32 - NUM_LOWBITS)) + janus.i = ((uint32_t) {highbits} << (32 - NUM_HIGHBITS)) + | ((uint32_t) ((int32_t) ((uint32_t) {lowbits} << (32 - NUM_LOWBITS)) >> (32 - NUM_LOWBITS - NUM_HIGHBITS)) >> NUM_HIGHBITS); error |= check (janus.f); diff --git a/tests/test-fflush.c b/tests/test-fflush.c index 1380b126ca..43429ed24c 100644 --- a/tests/test-fflush.c +++ b/tests/test-fflush.c @@ -82,7 +82,7 @@ main (void) if (lseek (fd, 0, SEEK_CUR) != 5) { fprintf (stderr, "File offset is wrong after fseek: %ld.\n", - (long) lseek (fd, 0, SEEK_CUR)); + (long) {lseek (fd, 0, SEEK_CUR)}); fclose (f); unlink ("test-fflush.txt"); return 1; @@ -90,7 +90,7 @@ main (void) if (ftell (f) != 5) { fprintf (stderr, "ftell result is wrong after fseek: %ld.\n", - (long) ftell (f)); + ftell (f)); fclose (f); unlink ("test-fflush.txt"); return 1; @@ -123,7 +123,7 @@ main (void) if (lseek (fd, 0, SEEK_CUR) != 6) { fprintf (stderr, "File offset is wrong after fseeko: %ld.\n", - (long) lseek (fd, 0, SEEK_CUR)); + (long) {lseek (fd, 0, SEEK_CUR)}); fclose (f); unlink ("test-fflush.txt"); return 1; @@ -131,7 +131,7 @@ main (void) if (ftell (f) != 6) { fprintf (stderr, "ftell result is wrong after fseeko: %ld.\n", - (long) ftell (f)); + ftell (f)); fclose (f); unlink ("test-fflush.txt"); return 1; diff --git a/tests/test-floorf2.c b/tests/test-floorf2.c index 877a128bbb..3b7d78bdb8 100644 --- a/tests/test-floorf2.c +++ b/tests/test-floorf2.c @@ -156,8 +156,8 @@ main () /* Combine highbits and lowbits into a floating-point number, sign-extending the lowbits to 32-NUM_HIGHBITS bits. */ union { float f; uint32_t i; } janus; - janus.i = ((uint32_t) highbits << (32 - NUM_HIGHBITS)) - | ((uint32_t) ((int32_t) ((uint32_t) lowbits << (32 - NUM_LOWBITS)) + janus.i = ((uint32_t) {highbits} << (32 - NUM_HIGHBITS)) + | ((uint32_t) ((int32_t) ((uint32_t) {lowbits} << (32 - NUM_LOWBITS)) >> (32 - NUM_LOWBITS - NUM_HIGHBITS)) >> NUM_HIGHBITS); error |= check (janus.f); diff --git a/tests/test-iswdigit.c b/tests/test-iswdigit.c index 38104cb148..df81839fd9 100644 --- a/tests/test-iswdigit.c +++ b/tests/test-iswdigit.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, s, n, &state); if (ret == n) return iswdigit (wc); diff --git a/tests/test-iswpunct.c b/tests/test-iswpunct.c index 4fd252dde9..cc49779473 100644 --- a/tests/test-iswpunct.c +++ b/tests/test-iswpunct.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, s, n, &state); if (ret == n) return iswpunct (wc); diff --git a/tests/test-iswxdigit.c b/tests/test-iswxdigit.c index 5b3d2908aa..85dcae7c9d 100644 --- a/tests/test-iswxdigit.c +++ b/tests/test-iswxdigit.c @@ -37,7 +37,7 @@ for_character (const char *s, size_t n) size_t ret; memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, s, n, &state); if (ret == n) return iswxdigit (wc); diff --git a/tests/test-mbrtoc32-regular.c b/tests/test-mbrtoc32-regular.c index 8864559e96..bfb753c397 100644 --- a/tests/test-mbrtoc32-regular.c +++ b/tests/test-mbrtoc32-regular.c @@ -56,7 +56,7 @@ main (int argc, char *argv[]) See . */ mbstate_t state; memset (&state, '\0', sizeof (mbstate_t)); - char32_t c32 = (char32_t) 0xBADFACE; + char32_t c32 = 0xBADFACE; size_t ret = mbrtoc32 (&c32, "\210\142", 2, &state); /* It is OK if this conversion fails. */ if (ret != (size_t)(-1)) diff --git a/tests/test-mbrtoc32-w32.c b/tests/test-mbrtoc32-w32.c index 74070f0fca..19a8074a43 100644 --- a/tests/test-mbrtoc32-w32.c +++ b/tests/test-mbrtoc32-w32.c @@ -89,7 +89,7 @@ test_one_locale (const char *name, int codepage) /* Test zero-length input. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "x", 0, &state); ASSERT (ret == (size_t)(-2)); ASSERT (mbsinit (&state)); @@ -98,7 +98,7 @@ test_one_locale (const char *name, int codepage) /* Test NUL byte input. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "", 1, &state); ASSERT (ret == 0); ASSERT (wc == 0); @@ -139,7 +139,7 @@ test_one_locale (const char *name, int codepage) case 'z': case '{': case '|': case '}': case '~': /* c is in the ISO C "basic character set". */ buf[0] = c; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, buf, 1, &state); ASSERT (ret == 1); ASSERT (wc == c); @@ -154,10 +154,10 @@ test_one_locale (const char *name, int codepage) /* Test special calling convention, passing a NULL pointer. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, NULL, 5, &state); ASSERT (ret == 0); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (mbsinit (&state)); } @@ -169,14 +169,14 @@ test_one_locale (const char *name, int codepage) char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == (unsigned char) '\374'); @@ -189,7 +189,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 1); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == (unsigned char) '\337'); @@ -197,14 +197,14 @@ test_one_locale (const char *name, int codepage) ASSERT (mbsinit (&state)); input[2] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[3] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 4, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); @@ -218,14 +218,14 @@ test_one_locale (const char *name, int codepage) char input[] = "x\302\341\346y"; /* "xآلوy" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'x'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == (unsigned char) '\302'); @@ -238,7 +238,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 1); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == (unsigned char) '\341'); @@ -246,7 +246,7 @@ test_one_locale (const char *name, int codepage) ASSERT (mbsinit (&state)); input[2] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 2, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == (unsigned char) '\346'); @@ -254,7 +254,7 @@ test_one_locale (const char *name, int codepage) ASSERT (mbsinit (&state)); input[3] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 4, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'y'); @@ -270,21 +270,21 @@ test_one_locale (const char *name, int codepage) char input[] = "s\303\274\303\237\360\237\230\213!"; /* "süß😋!" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 's'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 2, 7, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == EOF); @@ -297,7 +297,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 6, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -311,7 +311,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 4); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 5, 4, &state); ASSERT (ret == 4); ASSERT (c32tob (wc) == EOF); @@ -322,7 +322,7 @@ test_one_locale (const char *name, int codepage) input[7] = '\0'; input[8] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 9, 1, &state); ASSERT (ret == 1); ASSERT (wc == '!'); @@ -330,61 +330,61 @@ test_one_locale (const char *name, int codepage) /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\377", 1, &state); /* 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\303\300", 2, &state); /* 0xC3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\343\300", 2, &state); /* 0xE3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\343\300\200", 3, &state); /* 0xE3 0xC0 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\343\200\300", 3, &state); /* 0xE3 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\363\300", 2, &state); /* 0xF3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\363\300\200\200", 4, &state); /* 0xF3 0xC0 0x80 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\363\200\300", 3, &state); /* 0xF3 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\363\200\300\200", 4, &state); /* 0xF3 0x80 0xC0 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\363\200\200\300", 4, &state); /* 0xF3 0x80 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); @@ -397,14 +397,14 @@ test_one_locale (const char *name, int codepage) char input[] = "<\223\372\226\173\214\352>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -413,14 +413,14 @@ test_one_locale (const char *name, int codepage) input[1] = '\0'; input[2] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == EOF); @@ -433,7 +433,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -442,7 +442,7 @@ test_one_locale (const char *name, int codepage) input[5] = '\0'; input[6] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); @@ -450,12 +450,12 @@ test_one_locale (const char *name, int codepage) /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\377", 1, &state); /* 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == 0x30FB)); } @@ -467,14 +467,14 @@ test_one_locale (const char *name, int codepage) char input[] = "<\244\351\245\273\273\171>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -483,14 +483,14 @@ test_one_locale (const char *name, int codepage) input[1] = '\0'; input[2] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == EOF); @@ -503,7 +503,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -512,7 +512,7 @@ test_one_locale (const char *name, int codepage) input[5] = '\0'; input[6] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); @@ -520,12 +520,12 @@ test_one_locale (const char *name, int codepage) /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\377", 1, &state); /* 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == '?')); } @@ -537,14 +537,14 @@ test_one_locale (const char *name, int codepage) char input[] = "<\310\325\261\276\325\132>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -553,14 +553,14 @@ test_one_locale (const char *name, int codepage) input[1] = '\0'; input[2] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == EOF); @@ -573,7 +573,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -582,7 +582,7 @@ test_one_locale (const char *name, int codepage) input[5] = '\0'; input[6] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); @@ -590,12 +590,12 @@ test_one_locale (const char *name, int codepage) /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\377", 1, &state); /* 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == '?')); } @@ -609,21 +609,21 @@ test_one_locale (const char *name, int codepage) char input[] = "s\250\271\201\060\211\070\224\071\375\067!"; /* "süß😋!" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 's'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 2, 9, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == EOF); @@ -636,7 +636,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 4); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 8, &state); ASSERT (ret == 4); ASSERT (c32tob (wc) == EOF); @@ -652,7 +652,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 4); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 7, 4, &state); ASSERT (ret == 4); ASSERT (c32tob (wc) == EOF); @@ -663,7 +663,7 @@ test_one_locale (const char *name, int codepage) input[9] = '\0'; input[10] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 11, 1, &state); ASSERT (ret == 1); ASSERT (wc == '!'); @@ -671,37 +671,37 @@ test_one_locale (const char *name, int codepage) /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\377", 1, &state); /* 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\201\045", 2, &state); /* 0x81 0x25 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\201\060\377", 3, &state); /* 0x81 0x30 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\201\060\377\064", 4, &state); /* 0x81 0x30 0xFF 0x34 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\201\060\211\072", 4, &state); /* 0x81 0x30 0x89 0x3A */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); diff --git a/tests/test-mbrtoc32.c b/tests/test-mbrtoc32.c index 0bd7079d56..01a9180dd8 100644 --- a/tests/test-mbrtoc32.c +++ b/tests/test-mbrtoc32.c @@ -46,7 +46,7 @@ main (int argc, char *argv[]) /* Test zero-length input. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "x", 0, &state); ASSERT (ret == (size_t)(-2)); ASSERT (mbsinit (&state)); @@ -55,7 +55,7 @@ main (int argc, char *argv[]) /* Test NUL byte input. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "", 1, &state); ASSERT (ret == 0); ASSERT (wc == 0); @@ -99,7 +99,7 @@ main (int argc, char *argv[]) /* c is an ASCII character. */ buf[0] = c; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, buf, 1, &state); ASSERT (ret == 1); ASSERT (wc == c); @@ -118,10 +118,10 @@ main (int argc, char *argv[]) /* Test special calling convention, passing a NULL pointer. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, NULL, 5, &state); ASSERT (ret == 0); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (mbsinit (&state)); } @@ -149,7 +149,7 @@ main (int argc, char *argv[]) /* We are testing all nonnull bytes. */ buf[0] = c; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, buf, 1, &state); /* POSIX:2018 says regarding mbrtowc: "In the POSIX locale an [EILSEQ] error cannot occur since all byte values are valid @@ -178,14 +178,14 @@ main (int argc, char *argv[]) char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == (unsigned char) '\374'); @@ -200,7 +200,7 @@ main (int argc, char *argv[]) ASSERT (ret == 1); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == (unsigned char) '\337'); @@ -210,14 +210,14 @@ main (int argc, char *argv[]) ASSERT (mbsinit (&state)); input[2] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[3] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 4, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); @@ -231,21 +231,21 @@ main (int argc, char *argv[]) char input[] = "s\303\274\303\237\360\237\230\213!"; /* "süß😋!" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 's'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 2, 7, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == EOF); @@ -258,7 +258,7 @@ main (int argc, char *argv[]) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 6, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -272,7 +272,7 @@ main (int argc, char *argv[]) ASSERT (ret == 4); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 5, 4, &state); ASSERT (ret == 4); ASSERT (c32tob (wc) == EOF); @@ -283,7 +283,7 @@ main (int argc, char *argv[]) input[7] = '\0'; input[8] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 9, 1, &state); ASSERT (ret == 1); ASSERT (wc == '!'); @@ -292,25 +292,25 @@ main (int argc, char *argv[]) { /* \360\237\220\203 = U+0001F403 */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\360", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\237", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\220", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\203", 1, &state); ASSERT (ret == 1); ASSERT (wc == 0x1F403); /* expect Unicode encoding */ @@ -324,14 +324,14 @@ main (int argc, char *argv[]) char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -342,14 +342,14 @@ main (int argc, char *argv[]) input[1] = '\0'; input[2] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == EOF); @@ -364,7 +364,7 @@ main (int argc, char *argv[]) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -375,7 +375,7 @@ main (int argc, char *argv[]) input[5] = '\0'; input[6] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); @@ -395,21 +395,21 @@ main (int argc, char *argv[]) char input[] = "s\250\271\201\060\211\070\224\071\375\067!"; /* "süß😋!" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 's'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 2, 9, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == EOF); @@ -424,7 +424,7 @@ main (int argc, char *argv[]) ASSERT (ret == 4); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 8, &state); ASSERT (ret == 4); ASSERT (c32tob (wc) == EOF); @@ -442,7 +442,7 @@ main (int argc, char *argv[]) ASSERT (ret == 4); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 7, 4, &state); ASSERT (ret == 4); ASSERT (c32tob (wc) == EOF); @@ -455,7 +455,7 @@ main (int argc, char *argv[]) input[9] = '\0'; input[10] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 11, 1, &state); ASSERT (ret == 1); ASSERT (wc == '!'); @@ -464,25 +464,25 @@ main (int argc, char *argv[]) { /* \224\071\311\067 = U+0001F403 */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\224", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\071", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\311", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, "\067", 1, &state); ASSERT (ret == 1); #if GL_CHAR32_T_IS_UNICODE diff --git a/tests/test-mbrtowc-w32.c b/tests/test-mbrtowc-w32.c index ccffe15262..776e1937b7 100644 --- a/tests/test-mbrtowc-w32.c +++ b/tests/test-mbrtowc-w32.c @@ -88,7 +88,7 @@ test_one_locale (const char *name, int codepage) /* Test zero-length input. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "x", 0, &state); /* gnulib's implementation returns (size_t)(-2). The AIX 5.1 implementation returns (size_t)(-1). @@ -100,7 +100,7 @@ test_one_locale (const char *name, int codepage) /* Test NUL byte input. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "", 1, &state); ASSERT (ret == 0); ASSERT (wc == 0); @@ -141,7 +141,7 @@ test_one_locale (const char *name, int codepage) case 'z': case '{': case '|': case '}': case '~': /* c is in the ISO C "basic character set". */ buf[0] = c; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, buf, 1, &state); ASSERT (ret == 1); ASSERT (wc == c); @@ -156,10 +156,10 @@ test_one_locale (const char *name, int codepage) /* Test special calling convention, passing a NULL pointer. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, NULL, 5, &state); ASSERT (ret == 0); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (mbsinit (&state)); } @@ -171,14 +171,14 @@ test_one_locale (const char *name, int codepage) char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\374'); @@ -191,7 +191,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 1); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\337'); @@ -199,14 +199,14 @@ test_one_locale (const char *name, int codepage) ASSERT (mbsinit (&state)); input[2] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[3] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 4, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); @@ -220,14 +220,14 @@ test_one_locale (const char *name, int codepage) char input[] = "x\302\341\346y"; /* "xآلوy" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'x'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\302'); @@ -240,7 +240,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 1); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\341'); @@ -248,7 +248,7 @@ test_one_locale (const char *name, int codepage) ASSERT (mbsinit (&state)); input[2] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 2, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\346'); @@ -256,7 +256,7 @@ test_one_locale (const char *name, int codepage) ASSERT (mbsinit (&state)); input[3] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 4, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'y'); @@ -272,21 +272,21 @@ test_one_locale (const char *name, int codepage) char input[] = "B\303\274\303\237er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 2, 5, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); @@ -299,7 +299,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 4, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -308,14 +308,14 @@ test_one_locale (const char *name, int codepage) input[3] = '\0'; input[4] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 5, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[5] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 6, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); @@ -323,61 +323,61 @@ test_one_locale (const char *name, int codepage) /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\303\300", 2, &state); /* 0xC3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\343\300", 2, &state); /* 0xE3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\343\300\200", 3, &state); /* 0xE3 0xC0 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\343\200\300", 3, &state); /* 0xE3 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\363\300", 2, &state); /* 0xF3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\363\300\200\200", 4, &state); /* 0xF3 0xC0 0x80 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\363\200\300", 3, &state); /* 0xF3 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\363\200\300\200", 4, &state); /* 0xF3 0x80 0xC0 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\363\200\200\300", 4, &state); /* 0xF3 0x80 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); @@ -390,14 +390,14 @@ test_one_locale (const char *name, int codepage) char input[] = "<\223\372\226\173\214\352>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -406,14 +406,14 @@ test_one_locale (const char *name, int codepage) input[1] = '\0'; input[2] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); @@ -426,7 +426,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -435,7 +435,7 @@ test_one_locale (const char *name, int codepage) input[5] = '\0'; input[6] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); @@ -443,12 +443,12 @@ test_one_locale (const char *name, int codepage) /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == 0x30FB)); } @@ -460,14 +460,14 @@ test_one_locale (const char *name, int codepage) char input[] = "<\244\351\245\273\273\171>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -476,14 +476,14 @@ test_one_locale (const char *name, int codepage) input[1] = '\0'; input[2] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); @@ -496,7 +496,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -505,7 +505,7 @@ test_one_locale (const char *name, int codepage) input[5] = '\0'; input[6] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); @@ -513,12 +513,12 @@ test_one_locale (const char *name, int codepage) /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == '?')); } @@ -530,14 +530,14 @@ test_one_locale (const char *name, int codepage) char input[] = "<\310\325\261\276\325\132>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -546,14 +546,14 @@ test_one_locale (const char *name, int codepage) input[1] = '\0'; input[2] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); @@ -566,7 +566,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -575,7 +575,7 @@ test_one_locale (const char *name, int codepage) input[5] = '\0'; input[6] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); @@ -583,12 +583,12 @@ test_one_locale (const char *name, int codepage) /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == '?')); } @@ -602,21 +602,21 @@ test_one_locale (const char *name, int codepage) char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 2, 7, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); @@ -629,7 +629,7 @@ test_one_locale (const char *name, int codepage) ASSERT (ret == 4); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 6, &state); ASSERT (ret == 4); ASSERT (wctob (wc) == EOF); @@ -640,14 +640,14 @@ test_one_locale (const char *name, int codepage) input[5] = '\0'; input[6] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 7, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[7] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 8, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); @@ -655,37 +655,37 @@ test_one_locale (const char *name, int codepage) /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\201\045", 2, &state); /* 0x81 0x25 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\201\060\377", 3, &state); /* 0x81 0x30 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\201\060\377\064", 4, &state); /* 0x81 0x30 0xFF 0x34 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\201\060\211\072", 4, &state); /* 0x81 0x30 0x89 0x3A */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); diff --git a/tests/test-mbrtowc-w32utf8.c b/tests/test-mbrtowc-w32utf8.c index 5b7a2d9d9f..d68bfa6512 100644 --- a/tests/test-mbrtowc-w32utf8.c +++ b/tests/test-mbrtowc-w32utf8.c @@ -47,21 +47,21 @@ main (void) char input[] = "B\303\274\303\237er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 2, 5, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); @@ -74,7 +74,7 @@ main (void) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 4, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -83,14 +83,14 @@ main (void) input[3] = '\0'; input[4] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 5, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[5] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 6, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); @@ -98,61 +98,61 @@ main (void) /* Test some invalid input. */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\303\300", 2, &state); /* 0xC3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\343\300", 2, &state); /* 0xE3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\343\300\200", 3, &state); /* 0xE3 0xC0 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\343\200\300", 3, &state); /* 0xE3 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\363\300", 2, &state); /* 0xF3 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\363\300\200\200", 4, &state); /* 0xF3 0xC0 0x80 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\363\200\300", 3, &state); /* 0xF3 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\363\200\300\200", 4, &state); /* 0xF3 0x80 0xC0 0x80 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\363\200\200\300", 4, &state); /* 0xF3 0x80 0x80 0xC0 */ ASSERT (ret == (size_t)-1); ASSERT (errno == EILSEQ); diff --git a/tests/test-mbrtowc.c b/tests/test-mbrtowc.c index 9d4b1abc53..0851efbbba 100644 --- a/tests/test-mbrtowc.c +++ b/tests/test-mbrtowc.c @@ -45,7 +45,7 @@ main (int argc, char *argv[]) /* Test zero-length input. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "x", 0, &state); ASSERT (ret == (size_t)(-2)); ASSERT (mbsinit (&state)); @@ -54,7 +54,7 @@ main (int argc, char *argv[]) /* Test NUL byte input. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "", 1, &state); ASSERT (ret == 0); ASSERT (wc == 0); @@ -98,7 +98,7 @@ main (int argc, char *argv[]) /* c is an ASCII character. */ buf[0] = c; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, buf, 1, &state); ASSERT (ret == 1); ASSERT (wc == c); @@ -117,10 +117,10 @@ main (int argc, char *argv[]) /* Test special calling convention, passing a NULL pointer. */ { memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, NULL, 5, &state); ASSERT (ret == 0); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (mbsinit (&state)); } @@ -148,7 +148,7 @@ main (int argc, char *argv[]) /* We are testing all nonnull bytes. */ buf[0] = c; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, buf, 1, &state); /* POSIX:2018 says: "In the POSIX locale an [EILSEQ] error cannot occur since all byte values are valid characters." */ @@ -175,14 +175,14 @@ main (int argc, char *argv[]) char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\374'); @@ -194,21 +194,21 @@ main (int argc, char *argv[]) ASSERT (ret == 1); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 2, 3, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\337'); ASSERT (mbsinit (&state)); input[2] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[3] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 4, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); @@ -222,21 +222,21 @@ main (int argc, char *argv[]) char input[] = "B\303\274\303\237er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 2, 5, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); @@ -248,7 +248,7 @@ main (int argc, char *argv[]) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 4, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -256,14 +256,14 @@ main (int argc, char *argv[]) input[3] = '\0'; input[4] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 5, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[5] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 6, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); @@ -273,25 +273,25 @@ main (int argc, char *argv[]) { /* \360\237\220\203 = U+0001F403 */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\360", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\237", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\220", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\203", 1, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); @@ -305,14 +305,14 @@ main (int argc, char *argv[]) char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -320,14 +320,14 @@ main (int argc, char *argv[]) input[1] = '\0'; input[2] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 4, 4, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); @@ -339,7 +339,7 @@ main (int argc, char *argv[]) ASSERT (ret == 2); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 5, 3, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -347,7 +347,7 @@ main (int argc, char *argv[]) input[5] = '\0'; input[6] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 7, 1, &state); ASSERT (ret == 1); ASSERT (wc == '>'); @@ -361,21 +361,21 @@ main (int argc, char *argv[]) char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 2, 7, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); @@ -387,7 +387,7 @@ main (int argc, char *argv[]) ASSERT (ret == 4); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 6, &state); ASSERT (ret == 4); ASSERT (wctob (wc) == EOF); @@ -397,14 +397,14 @@ main (int argc, char *argv[]) input[5] = '\0'; input[6] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 7, 2, &state); ASSERT (ret == 1); ASSERT (wc == 'e'); ASSERT (mbsinit (&state)); input[7] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 8, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'r'); @@ -414,25 +414,25 @@ main (int argc, char *argv[]) { /* \224\071\311\067 = U+0001F403 */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\224", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\071", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\311", 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, "\067", 1, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == EOF); diff --git a/tests/test-mbsnrtoc32s.c b/tests/test-mbsnrtoc32s.c index 26a9263516..e2cc8d6298 100644 --- a/tests/test-mbsnrtoc32s.c +++ b/tests/test-mbsnrtoc32s.c @@ -58,14 +58,14 @@ main (int argc, char *argv[]) ASSERT (ret == 0); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbsnrtoc32s (&wc, &src, 1, 0, &state); ASSERT (ret == 0); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbsnrtoc32s (&wc, &src, 1, 1, &state); ASSERT (ret == 0); @@ -92,7 +92,7 @@ main (int argc, char *argv[]) mbstate_t temp_state; for (size_t i = 0; i < BUFSIZE; i++) - buf[i] = (char32_t) 0xBADFACE; + buf[i] = 0xBADFACE; switch (argv[1][0]) { @@ -119,10 +119,10 @@ main (int argc, char *argv[]) ASSERT (buf[1] == '/'); ASSERT (buf[2] == 'a'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (char32_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[1] == (char32_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); ASSERT (mbsinit (&state)); } { @@ -142,7 +142,7 @@ main (int argc, char *argv[]) ASSERT (src == input); ASSERT (mbsinit (&state)); - buf[0] = buf[1] = (char32_t) 0xBADFACE; + buf[0] = buf[1] = 0xBADFACE; src = input; ret = mbsnrtoc32s (buf, &src, 2, unlimited ? BUFSIZE : 1, &state); /* POSIX:2018 says regarding mbsnrtowcs: "In the POSIX locale an @@ -169,14 +169,14 @@ main (int argc, char *argv[]) char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == (unsigned char) '\374'); @@ -200,10 +200,10 @@ main (int argc, char *argv[]) ASSERT (buf[1] == 'e'); ASSERT (buf[2] == 'r'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (char32_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[1] == (char32_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -214,17 +214,17 @@ main (int argc, char *argv[]) char input[] = "s\303\274\303\237\360\237\230\213!"; /* "süß😋!" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 's'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; @@ -246,10 +246,10 @@ main (int argc, char *argv[]) ASSERT (buf[2] == 0x1F60B); /* expect Unicode encoding */ ASSERT (buf[3] == '!'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (char32_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[2] == (char32_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -260,14 +260,14 @@ main (int argc, char *argv[]) char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -275,10 +275,10 @@ main (int argc, char *argv[]) input[1] = '\0'; input[2] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; @@ -299,10 +299,10 @@ main (int argc, char *argv[]) { ASSERT (buf[2] == '>'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (char32_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[2] == (char32_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -319,17 +319,17 @@ main (int argc, char *argv[]) char input[] = "s\250\271\201\060\211\070\224\071\375\067!"; /* "süß😋!" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 's'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; @@ -351,10 +351,10 @@ main (int argc, char *argv[]) ASSERT (c32tob (buf[2]) == EOF); ASSERT (buf[3] == '!'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (char32_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[2] == (char32_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; diff --git a/tests/test-mbsnrtowcs.c b/tests/test-mbsnrtowcs.c index 9dc07217dd..a2a5262549 100644 --- a/tests/test-mbsnrtowcs.c +++ b/tests/test-mbsnrtowcs.c @@ -57,14 +57,14 @@ main (int argc, char *argv[]) ASSERT (ret == 0); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbsnrtowcs (&wc, &src, 1, 0, &state); ASSERT (ret == 0); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbsnrtowcs (&wc, &src, 1, 1, &state); ASSERT (ret == 0); @@ -91,7 +91,7 @@ main (int argc, char *argv[]) mbstate_t temp_state; for (size_t i = 0; i < BUFSIZE; i++) - buf[i] = (wchar_t) 0xBADFACE; + buf[i] = 0xBADFACE; switch (argv[1][0]) { @@ -118,10 +118,10 @@ main (int argc, char *argv[]) ASSERT (buf[1] == '/'); ASSERT (buf[2] == 'a'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (wchar_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[1] == (wchar_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); ASSERT (mbsinit (&state)); } { @@ -141,7 +141,7 @@ main (int argc, char *argv[]) ASSERT (src == input); ASSERT (mbsinit (&state)); - buf[0] = buf[1] = (wchar_t) 0xBADFACE; + buf[0] = buf[1] = 0xBADFACE; src = input; ret = mbsnrtowcs (buf, &src, 2, unlimited ? BUFSIZE : 1, &state); /* POSIX:2018 says: "In the POSIX locale an [EILSEQ] error @@ -166,14 +166,14 @@ main (int argc, char *argv[]) char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\374'); @@ -197,10 +197,10 @@ main (int argc, char *argv[]) ASSERT (buf[1] == 'e'); ASSERT (buf[2] == 'r'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (wchar_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[1] == (wchar_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -211,17 +211,17 @@ main (int argc, char *argv[]) char input[] = "B\303\274\303\237er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; @@ -243,10 +243,10 @@ main (int argc, char *argv[]) ASSERT (buf[2] == 'e'); ASSERT (buf[3] == 'r'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (wchar_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[2] == (wchar_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -257,14 +257,14 @@ main (int argc, char *argv[]) char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -272,10 +272,10 @@ main (int argc, char *argv[]) input[1] = '\0'; input[2] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; @@ -296,10 +296,10 @@ main (int argc, char *argv[]) { ASSERT (buf[2] == '>'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (wchar_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[2] == (wchar_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -310,17 +310,17 @@ main (int argc, char *argv[]) char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; @@ -342,10 +342,10 @@ main (int argc, char *argv[]) ASSERT (buf[2] == 'e'); ASSERT (buf[3] == 'r'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (wchar_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[2] == (wchar_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; diff --git a/tests/test-mbsrtoc32s.c b/tests/test-mbsrtoc32s.c index 673eb15197..0a4c0c4236 100644 --- a/tests/test-mbsrtoc32s.c +++ b/tests/test-mbsrtoc32s.c @@ -58,14 +58,14 @@ main (int argc, char *argv[]) ASSERT (ret == 0); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbsrtoc32s (&wc, &src, 0, &state); ASSERT (ret == 0); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (mbsinit (&state)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbsrtoc32s (&wc, &src, 1, &state); ASSERT (ret == 0); @@ -92,7 +92,7 @@ main (int argc, char *argv[]) mbstate_t temp_state; for (size_t i = 0; i < BUFSIZE; i++) - buf[i] = (char32_t) 0xBADFACE; + buf[i] = 0xBADFACE; switch (argv[1][0]) { @@ -119,10 +119,10 @@ main (int argc, char *argv[]) ASSERT (buf[1] == '/'); ASSERT (buf[2] == 'a'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (char32_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[1] == (char32_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); ASSERT (mbsinit (&state)); } { @@ -142,7 +142,7 @@ main (int argc, char *argv[]) ASSERT (src == input); ASSERT (mbsinit (&state)); - buf[0] = buf[1] = (char32_t) 0xBADFACE; + buf[0] = buf[1] = 0xBADFACE; src = input; ret = mbsrtoc32s (buf, &src, unlimited ? BUFSIZE : 1, &state); /* POSIX:2018 says regarding mbsrtowcs: "In the POSIX locale an @@ -169,14 +169,14 @@ main (int argc, char *argv[]) char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (c32tob (wc) == (unsigned char) '\374'); @@ -200,10 +200,10 @@ main (int argc, char *argv[]) ASSERT (buf[1] == 'e'); ASSERT (buf[2] == 'r'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (char32_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[1] == (char32_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -214,17 +214,17 @@ main (int argc, char *argv[]) char input[] = "s\303\274\303\237\360\237\230\213!"; /* "süß😋!" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 's'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; @@ -246,10 +246,10 @@ main (int argc, char *argv[]) ASSERT (buf[2] == 0x1F60B); /* expect Unicode encoding */ ASSERT (buf[3] == '!'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (char32_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[2] == (char32_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -260,14 +260,14 @@ main (int argc, char *argv[]) char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (c32tob (wc) == EOF); @@ -275,10 +275,10 @@ main (int argc, char *argv[]) input[1] = '\0'; input[2] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; @@ -299,10 +299,10 @@ main (int argc, char *argv[]) { ASSERT (buf[2] == '>'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (char32_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[2] == (char32_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -319,17 +319,17 @@ main (int argc, char *argv[]) char input[] = "s\250\271\201\060\211\070\224\071\375\067!"; /* "süß😋!" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 's'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtoc32 (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; @@ -351,10 +351,10 @@ main (int argc, char *argv[]) ASSERT (c32tob (buf[2]) == EOF); ASSERT (buf[3] == '!'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (char32_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[2] == (char32_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; diff --git a/tests/test-mbsrtowcs.c b/tests/test-mbsrtowcs.c index 4cc16cccf5..84bf72ed43 100644 --- a/tests/test-mbsrtowcs.c +++ b/tests/test-mbsrtowcs.c @@ -57,14 +57,14 @@ main (int argc, char *argv[]) ASSERT (ret == 0); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbsrtowcs (&wc, &src, 0, &state); ASSERT (ret == 0); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (mbsinit (&state)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbsrtowcs (&wc, &src, 1, &state); ASSERT (ret == 0); @@ -91,7 +91,7 @@ main (int argc, char *argv[]) mbstate_t temp_state; for (size_t i = 0; i < BUFSIZE; i++) - buf[i] = (wchar_t) 0xBADFACE; + buf[i] = 0xBADFACE; switch (argv[1][0]) { @@ -118,10 +118,10 @@ main (int argc, char *argv[]) ASSERT (buf[1] == '/'); ASSERT (buf[2] == 'a'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (wchar_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[1] == (wchar_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); ASSERT (mbsinit (&state)); } { @@ -141,7 +141,7 @@ main (int argc, char *argv[]) ASSERT (src == input); ASSERT (mbsinit (&state)); - buf[0] = buf[1] = (wchar_t) 0xBADFACE; + buf[0] = buf[1] = 0xBADFACE; src = input; ret = mbsrtowcs (buf, &src, unlimited ? BUFSIZE : 1, &state); /* POSIX:2018 says: "In the POSIX locale an [EILSEQ] error @@ -166,14 +166,14 @@ main (int argc, char *argv[]) char input[] = "B\374\337er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == 1); ASSERT (wctob (wc) == (unsigned char) '\374'); @@ -197,10 +197,10 @@ main (int argc, char *argv[]) ASSERT (buf[1] == 'e'); ASSERT (buf[2] == 'r'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (wchar_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[1] == (wchar_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -211,17 +211,17 @@ main (int argc, char *argv[]) char input[] = "B\303\274\303\237er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; @@ -243,10 +243,10 @@ main (int argc, char *argv[]) ASSERT (buf[2] == 'e'); ASSERT (buf[3] == 'r'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (wchar_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[2] == (wchar_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -257,14 +257,14 @@ main (int argc, char *argv[]) char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == '<'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 2, &state); ASSERT (ret == 2); ASSERT (wctob (wc) == EOF); @@ -272,10 +272,10 @@ main (int argc, char *argv[]) input[1] = '\0'; input[2] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 3, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[3] = '\0'; @@ -296,10 +296,10 @@ main (int argc, char *argv[]) { ASSERT (buf[2] == '>'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (wchar_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[2] == (wchar_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; @@ -310,17 +310,17 @@ main (int argc, char *argv[]) char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */ memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input, 1, &state); ASSERT (ret == 1); ASSERT (wc == 'B'); ASSERT (mbsinit (&state)); input[0] = '\0'; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbrtowc (&wc, input + 1, 1, &state); ASSERT (ret == (size_t)(-2)); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); ASSERT (!mbsinit (&state)); input[1] = '\0'; @@ -342,10 +342,10 @@ main (int argc, char *argv[]) ASSERT (buf[2] == 'e'); ASSERT (buf[3] == 'r'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (wchar_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[2] == (wchar_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); ASSERT (mbsinit (&state)); } break; diff --git a/tests/test-mbstoc32s.c b/tests/test-mbstoc32s.c index d42f14bfa3..9ca43506f4 100644 --- a/tests/test-mbstoc32s.c +++ b/tests/test-mbstoc32s.c @@ -51,13 +51,13 @@ main (int argc, char *argv[]) ret = mbstoc32s (NULL, src, 1); ASSERT (ret == 0); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbstoc32s (&wc, src, 0); ASSERT (ret == 0); - ASSERT (wc == (char32_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbstoc32s (&wc, src, 1); ASSERT (ret == 0); @@ -82,7 +82,7 @@ main (int argc, char *argv[]) const char *src; for (size_t i = 0; i < BUFSIZE; i++) - buf[i] = (char32_t) 0xBADFACE; + buf[i] = 0xBADFACE; switch (argv[1][0]) { @@ -104,10 +104,10 @@ main (int argc, char *argv[]) ASSERT (buf[1] == '/'); ASSERT (buf[2] == 'a'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (char32_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[1] == (char32_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); } { char input[2]; @@ -123,7 +123,7 @@ main (int argc, char *argv[]) ret = mbstoc32s (NULL, src, unlimited ? BUFSIZE : 1); ASSERT (ret == 1); - buf[0] = buf[1] = (char32_t) 0xBADFACE; + buf[0] = buf[1] = 0xBADFACE; src = input; ret = mbstoc32s (buf, src, unlimited ? BUFSIZE : 1); /* POSIX:2018 says regarding mbstowcs: "In the POSIX locale an @@ -147,13 +147,13 @@ main (int argc, char *argv[]) { char input[] = "B\374\337er"; /* "Büßer" */ - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbstoc32s (&wc, input, 1); ASSERT (ret == 1); ASSERT (wc == 'B'); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbstoc32s (&wc, input + 1, 1); ASSERT (ret == 1); ASSERT (c32tob (wc) == (unsigned char) '\374'); @@ -172,10 +172,10 @@ main (int argc, char *argv[]) ASSERT (buf[1] == 'e'); ASSERT (buf[2] == 'r'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (char32_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[1] == (char32_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); } break; @@ -184,13 +184,13 @@ main (int argc, char *argv[]) { char input[] = "s\303\274\303\237\360\237\230\213!"; /* "süß😋!" */ - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbstoc32s (&wc, input, 1); ASSERT (ret == 1); ASSERT (wc == 's'); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbstoc32s (&wc, input + 1, 1); ASSERT (ret == 1); ASSERT (wc == 0x00FC); /* expect Unicode encoding */ @@ -210,10 +210,10 @@ main (int argc, char *argv[]) { ASSERT (buf[2] == '!'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (char32_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[2] == (char32_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); } break; @@ -222,13 +222,13 @@ main (int argc, char *argv[]) { char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */ - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbstoc32s (&wc, input, 1); ASSERT (ret == 1); ASSERT (wc == '<'); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbstoc32s (&wc, input + 1, 1); ASSERT (ret == 1); ASSERT (c32tob (wc) == EOF); @@ -248,10 +248,10 @@ main (int argc, char *argv[]) { ASSERT (buf[2] == '>'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (char32_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[2] == (char32_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); } break; @@ -266,13 +266,13 @@ main (int argc, char *argv[]) { char input[] = "s\250\271\201\060\211\070\224\071\375\067!"; /* "süß😋!" */ - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbstoc32s (&wc, input, 1); ASSERT (ret == 1); ASSERT (wc == 's'); input[0] = '\0'; - wc = (char32_t) 0xBADFACE; + wc = 0xBADFACE; ret = mbstoc32s (&wc, input + 1, 1); ASSERT (ret == 1); ASSERT (c32tob (wc) == EOF); @@ -291,10 +291,10 @@ main (int argc, char *argv[]) { ASSERT (buf[2] == '!'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (char32_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[2] == (char32_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); } break; diff --git a/tests/test-mbstowcs.c b/tests/test-mbstowcs.c index 45042b8c08..21fbc51bea 100644 --- a/tests/test-mbstowcs.c +++ b/tests/test-mbstowcs.c @@ -52,13 +52,13 @@ main (int argc, char *argv[]) ret = mbstowcs (NULL, src, 1); ASSERT (ret == 0); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbstowcs (&wc, src, 0); ASSERT (ret == 0); - ASSERT (wc == (wchar_t) 0xBADFACE); + ASSERT (wc == 0xBADFACE); - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; src = ""; ret = mbstowcs (&wc, src, 1); ASSERT (ret == 0); @@ -83,7 +83,7 @@ main (int argc, char *argv[]) const char *src; for (size_t i = 0; i < BUFSIZE; i++) - buf[i] = (wchar_t) 0xBADFACE; + buf[i] = 0xBADFACE; switch (argv[1][0]) { @@ -105,10 +105,10 @@ main (int argc, char *argv[]) ASSERT (buf[1] == '/'); ASSERT (buf[2] == 'a'); ASSERT (buf[3] == 0); - ASSERT (buf[4] == (wchar_t) 0xBADFACE); + ASSERT (buf[4] == 0xBADFACE); } else - ASSERT (buf[1] == (wchar_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); } { char input[2]; @@ -124,7 +124,7 @@ main (int argc, char *argv[]) ret = mbstowcs (NULL, src, unlimited ? BUFSIZE : 1); ASSERT (ret == 1); - buf[0] = buf[1] = (wchar_t) 0xBADFACE; + buf[0] = buf[1] = 0xBADFACE; src = input; ret = mbstowcs (buf, src, unlimited ? BUFSIZE : 1); /* POSIX:2018 says: "In the POSIX locale an [EILSEQ] error @@ -160,10 +160,10 @@ main (int argc, char *argv[]) ASSERT (buf[2] == 'e'); ASSERT (buf[3] == 'r'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (wchar_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[1] == (wchar_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); } break; @@ -186,10 +186,10 @@ main (int argc, char *argv[]) ASSERT (buf[2] == 'e'); ASSERT (buf[3] == 'r'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (wchar_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[2] == (wchar_t) 0xBADFACE); + ASSERT (buf[2] == 0xBADFACE); } break; @@ -212,10 +212,10 @@ main (int argc, char *argv[]) { ASSERT (buf[3] == '>'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (wchar_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[3] == (wchar_t) 0xBADFACE); + ASSERT (buf[3] == 0xBADFACE); } break; @@ -238,10 +238,10 @@ main (int argc, char *argv[]) ASSERT (buf[2] == 'e'); ASSERT (buf[3] == 'r'); ASSERT (buf[4] == 0); - ASSERT (buf[5] == (wchar_t) 0xBADFACE); + ASSERT (buf[5] == 0xBADFACE); } else - ASSERT (buf[1] == (wchar_t) 0xBADFACE); + ASSERT (buf[1] == 0xBADFACE); } break; diff --git a/tests/test-sameacls.c b/tests/test-sameacls.c index 57c5ace403..5892769f98 100644 --- a/tests/test-sameacls.c +++ b/tests/test-sameacls.c @@ -110,7 +110,8 @@ main (int argc, char *argv[]) { fprintf (stderr, "files %s and %s have different access modes: %03o and %03o\n", file1, file2, - (unsigned int) statbuf1.st_mode, (unsigned int) statbuf2.st_mode); + (unsigned int) {statbuf1.st_mode}, + (unsigned int) {statbuf2.st_mode}); return 1; } } diff --git a/tests/test-snprintf-posix.h b/tests/test-snprintf-posix.h index f220572eed..074cd2595b 100644 --- a/tests/test-snprintf-posix.h +++ b/tests/test-snprintf-posix.h @@ -3110,7 +3110,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) ASSERT (retval == 6); } - static wint_t L_x = (wchar_t) 'x'; + static wint_t L_x = L'x'; { /* Width. */ int retval = @@ -3162,7 +3162,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) ASSERT (retval == 6); } - static wint_t L_invalid = (wchar_t) 0x76543210; + static wint_t L_invalid = 0x76543210; { /* Invalid wide character. The conversion may succeed or may fail, but it should not abort. */ @@ -3514,7 +3514,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%hhd %d", (signed char) -42, 33, 44, 55); + "%hhd %d", (signed char) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (retval == strlen (result)); } @@ -3522,7 +3522,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%hd %d", (short) -12345, 33, 44, 55); + "%hd %d", (short) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } @@ -3538,7 +3538,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%ld %d", (long int) -12345, 33, 44, 55); + "%ld %d", -12345L, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } @@ -3546,7 +3546,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%lld %d", (long long int) -12345, 33, 44, 55); + "%lld %d", -12345LL, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } @@ -3554,7 +3554,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w8d %d", (int8_t) -42, 33, 44, 55); + "%w8d %d", (int8_t) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (retval == strlen (result)); } @@ -3562,7 +3562,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w16d %d", (int16_t) -12345, 33, 44, 55); + "%w16d %d", (int16_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } @@ -3570,7 +3570,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w32d %d", (int32_t) -12345, 33, 44, 55); + "%w32d %d", (int32_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } @@ -3578,7 +3578,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w64d %d", (int64_t) -12345, 33, 44, 55); + "%w64d %d", (int64_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } @@ -3586,7 +3586,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf8d %d", (int_fast8_t) -42, 33, 44, 55); + "%wf8d %d", (int_fast8_t) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (retval == strlen (result)); } @@ -3594,7 +3594,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf16d %d", (int_fast16_t) -12345, 33, 44, 55); + "%wf16d %d", (int_fast16_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } @@ -3602,7 +3602,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf32d %d", (int_fast32_t) -12345, 33, 44, 55); + "%wf32d %d", (int_fast32_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } @@ -3621,7 +3621,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%hhu %d", (unsigned char) 42, 33, 44, 55); + "%hhu %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (retval == strlen (result)); } @@ -3629,7 +3629,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%hu %d", (unsigned short) 12345, 33, 44, 55); + "%hu %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } @@ -3637,7 +3637,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%u %d", (unsigned int) 12345, 33, 44, 55); + "%u %d", 12345U, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } @@ -3645,7 +3645,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%lu %d", (unsigned long int) 12345, 33, 44, 55); + "%lu %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } @@ -3653,7 +3653,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%llu %d", (unsigned long long int) 12345, 33, 44, 55); + "%llu %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } @@ -3661,7 +3661,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w8u %d", (uint8_t) 42, 33, 44, 55); + "%w8u %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (retval == strlen (result)); } @@ -3669,7 +3669,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w16u %d", (uint16_t) 12345, 33, 44, 55); + "%w16u %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } @@ -3677,7 +3677,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w32u %d", (uint32_t) 12345, 33, 44, 55); + "%w32u %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } @@ -3685,7 +3685,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w64u %d", (uint64_t) 12345, 33, 44, 55); + "%w64u %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } @@ -3693,7 +3693,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf8u %d", (uint_fast8_t) 42, 33, 44, 55); + "%wf8u %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (retval == strlen (result)); } @@ -3701,7 +3701,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf16u %d", (uint_fast16_t) 12345, 33, 44, 55); + "%wf16u %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } @@ -3709,7 +3709,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf32u %d", (uint_fast32_t) 12345, 33, 44, 55); + "%wf32u %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } @@ -3717,7 +3717,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf64u %d", (uint_fast64_t) 12345, 33, 44, 55); + "%wf64u %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } @@ -3728,7 +3728,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%hhb %d", (unsigned char) 42, 33, 44, 55); + "%hhb %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (retval == strlen (result)); } @@ -3736,7 +3736,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%hb %d", (unsigned short) 12345, 33, 44, 55); + "%hb %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } @@ -3744,7 +3744,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%b %d", (unsigned int) 12345, 33, 44, 55); + "%b %d", 12345U, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } @@ -3752,7 +3752,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%lb %d", (unsigned long int) 12345, 33, 44, 55); + "%lb %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } @@ -3760,7 +3760,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%llb %d", (unsigned long long int) 12345, 33, 44, 55); + "%llb %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } @@ -3768,7 +3768,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w8b %d", (uint8_t) 42, 33, 44, 55); + "%w8b %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (retval == strlen (result)); } @@ -3776,7 +3776,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w16b %d", (uint16_t) 12345, 33, 44, 55); + "%w16b %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } @@ -3784,7 +3784,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w32b %d", (uint32_t) 12345, 33, 44, 55); + "%w32b %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } @@ -3792,7 +3792,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w64b %d", (uint64_t) 12345, 33, 44, 55); + "%w64b %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } @@ -3800,7 +3800,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf8b %d", (uint_fast8_t) 42, 33, 44, 55); + "%wf8b %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (retval == strlen (result)); } @@ -3808,7 +3808,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf16b %d", (uint_fast16_t) 12345, 33, 44, 55); + "%wf16b %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } @@ -3816,7 +3816,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf32b %d", (uint_fast32_t) 12345, 33, 44, 55); + "%wf32b %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } @@ -3824,7 +3824,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf64b %d", (uint_fast64_t) 12345, 33, 44, 55); + "%wf64b %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } @@ -3835,7 +3835,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%hho %d", (unsigned char) 42, 33, 44, 55); + "%hho %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (retval == strlen (result)); } @@ -3843,7 +3843,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%ho %d", (unsigned short) 12345, 33, 44, 55); + "%ho %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } @@ -3851,7 +3851,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%o %d", (unsigned int) 12345, 33, 44, 55); + "%o %d", 12345U, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } @@ -3859,7 +3859,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%lo %d", (unsigned long int) 12345, 33, 44, 55); + "%lo %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } @@ -3867,7 +3867,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%llo %d", (unsigned long long int) 12345, 33, 44, 55); + "%llo %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } @@ -3875,7 +3875,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w8o %d", (uint8_t) 42, 33, 44, 55); + "%w8o %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (retval == strlen (result)); } @@ -3883,7 +3883,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w16o %d", (uint16_t) 12345, 33, 44, 55); + "%w16o %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } @@ -3891,7 +3891,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w32o %d", (uint32_t) 12345, 33, 44, 55); + "%w32o %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } @@ -3899,7 +3899,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w64o %d", (uint64_t) 12345, 33, 44, 55); + "%w64o %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } @@ -3907,7 +3907,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf8o %d", (uint_fast8_t) 42, 33, 44, 55); + "%wf8o %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (retval == strlen (result)); } @@ -3915,7 +3915,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf16o %d", (uint_fast16_t) 12345, 33, 44, 55); + "%wf16o %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } @@ -3923,7 +3923,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf32o %d", (uint_fast32_t) 12345, 33, 44, 55); + "%wf32o %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } @@ -3931,7 +3931,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf64o %d", (uint_fast64_t) 12345, 33, 44, 55); + "%wf64o %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } @@ -3942,7 +3942,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%hhX %d", (unsigned char) 42, 33, 44, 55); + "%hhX %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (retval == strlen (result)); } @@ -3950,7 +3950,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%hX %d", (unsigned short) 12345, 33, 44, 55); + "%hX %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } @@ -3958,7 +3958,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%X %d", (unsigned int) 12345, 33, 44, 55); + "%X %d", 12345U, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } @@ -3966,7 +3966,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%lX %d", (unsigned long int) 12345, 33, 44, 55); + "%lX %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } @@ -3974,7 +3974,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%llX %d", (unsigned long long int) 12345, 33, 44, 55); + "%llX %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } @@ -3982,7 +3982,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w8X %d", (uint8_t) 42, 33, 44, 55); + "%w8X %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (retval == strlen (result)); } @@ -3990,7 +3990,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w16X %d", (uint16_t) 12345, 33, 44, 55); + "%w16X %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } @@ -3998,7 +3998,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w32X %d", (uint32_t) 12345, 33, 44, 55); + "%w32X %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } @@ -4006,7 +4006,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%w64X %d", (uint64_t) 12345, 33, 44, 55); + "%w64X %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } @@ -4014,7 +4014,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf8X %d", (uint_fast8_t) 42, 33, 44, 55); + "%wf8X %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (retval == strlen (result)); } @@ -4022,7 +4022,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf16X %d", (uint_fast16_t) 12345, 33, 44, 55); + "%wf16X %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } @@ -4030,7 +4030,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf32X %d", (uint_fast32_t) 12345, 33, 44, 55); + "%wf32X %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } @@ -4038,7 +4038,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...)) { int retval = my_snprintf (result, sizeof (result), - "%wf64X %d", (uint_fast64_t) 12345, 33, 44, 55); + "%wf64X %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } diff --git a/tests/test-sprintf-posix.h b/tests/test-sprintf-posix.h index e7a0441796..d82c2892b9 100644 --- a/tests/test-sprintf-posix.h +++ b/tests/test-sprintf-posix.h @@ -3091,7 +3091,7 @@ test_function (int (*my_sprintf) (char *, const char *, ...)) ASSERT (retval == 6); } - static wint_t L_x = (wchar_t) 'x'; + static wint_t L_x = L'x'; { /* Width. */ int retval = @@ -3145,7 +3145,7 @@ test_function (int (*my_sprintf) (char *, const char *, ...)) ASSERT (retval == 6); } - static wint_t L_invalid = (wchar_t) 0x76543210; + static wint_t L_invalid = 0x76543210; { /* Invalid wide character. The conversion may succeed or may fail, but it should not abort. */ @@ -3494,14 +3494,14 @@ test_function (int (*my_sprintf) (char *, const char *, ...)) { int retval = - my_sprintf (result, "%hhd %d", (signed char) -42, 33, 44, 55); + my_sprintf (result, "%hhd %d", (signed char) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%hd %d", (short) -12345, 33, 44, 55); + my_sprintf (result, "%hd %d", (short) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } @@ -3515,63 +3515,63 @@ test_function (int (*my_sprintf) (char *, const char *, ...)) { int retval = - my_sprintf (result, "%ld %d", (long int) -12345, 33, 44, 55); + my_sprintf (result, "%ld %d", -12345L, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%lld %d", (long long int) -12345, 33, 44, 55); + my_sprintf (result, "%lld %d", -12345LL, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w8d %d", (int8_t) -42, 33, 44, 55); + my_sprintf (result, "%w8d %d", (int8_t) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w16d %d", (int16_t) -12345, 33, 44, 55); + my_sprintf (result, "%w16d %d", (int16_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w32d %d", (int32_t) -12345, 33, 44, 55); + my_sprintf (result, "%w32d %d", (int32_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w64d %d", (int64_t) -12345, 33, 44, 55); + my_sprintf (result, "%w64d %d", (int64_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf8d %d", (int_fast8_t) -42, 33, 44, 55); + my_sprintf (result, "%wf8d %d", (int_fast8_t) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf16d %d", (int_fast16_t) -12345, 33, 44, 55); + my_sprintf (result, "%wf16d %d", (int_fast16_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf32d %d", (int_fast32_t) -12345, 33, 44, 55); + my_sprintf (result, "%wf32d %d", (int_fast32_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); } @@ -3588,91 +3588,91 @@ test_function (int (*my_sprintf) (char *, const char *, ...)) { int retval = - my_sprintf (result, "%hhu %d", (unsigned char) 42, 33, 44, 55); + my_sprintf (result, "%hhu %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%hu %d", (unsigned short) 12345, 33, 44, 55); + my_sprintf (result, "%hu %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%u %d", (unsigned int) 12345, 33, 44, 55); + my_sprintf (result, "%u %d", 12345U, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%lu %d", (unsigned long int) 12345, 33, 44, 55); + my_sprintf (result, "%lu %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%llu %d", (unsigned long long int) 12345, 33, 44, 55); + my_sprintf (result, "%llu %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w8u %d", (uint8_t) 42, 33, 44, 55); + my_sprintf (result, "%w8u %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w16u %d", (uint16_t) 12345, 33, 44, 55); + my_sprintf (result, "%w16u %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w32u %d", (uint32_t) 12345, 33, 44, 55); + my_sprintf (result, "%w32u %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w64u %d", (uint64_t) 12345, 33, 44, 55); + my_sprintf (result, "%w64u %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf8u %d", (uint_fast8_t) 42, 33, 44, 55); + my_sprintf (result, "%wf8u %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf16u %d", (uint_fast16_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf16u %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf32u %d", (uint_fast32_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf32u %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf64u %d", (uint_fast64_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf64u %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); } @@ -3682,91 +3682,91 @@ test_function (int (*my_sprintf) (char *, const char *, ...)) { int retval = - my_sprintf (result, "%hhb %d", (unsigned char) 42, 33, 44, 55); + my_sprintf (result, "%hhb %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%hb %d", (unsigned short) 12345, 33, 44, 55); + my_sprintf (result, "%hb %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%b %d", (unsigned int) 12345, 33, 44, 55); + my_sprintf (result, "%b %d", 12345U, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%lb %d", (unsigned long int) 12345, 33, 44, 55); + my_sprintf (result, "%lb %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%llb %d", (unsigned long long int) 12345, 33, 44, 55); + my_sprintf (result, "%llb %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w8b %d", (uint8_t) 42, 33, 44, 55); + my_sprintf (result, "%w8b %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w16b %d", (uint16_t) 12345, 33, 44, 55); + my_sprintf (result, "%w16b %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w32b %d", (uint32_t) 12345, 33, 44, 55); + my_sprintf (result, "%w32b %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w64b %d", (uint64_t) 12345, 33, 44, 55); + my_sprintf (result, "%w64b %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf8b %d", (uint_fast8_t) 42, 33, 44, 55); + my_sprintf (result, "%wf8b %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf16b %d", (uint_fast16_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf16b %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf32b %d", (uint_fast32_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf32b %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf64b %d", (uint_fast64_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf64b %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); } @@ -3776,91 +3776,91 @@ test_function (int (*my_sprintf) (char *, const char *, ...)) { int retval = - my_sprintf (result, "%hho %d", (unsigned char) 42, 33, 44, 55); + my_sprintf (result, "%hho %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%ho %d", (unsigned short) 12345, 33, 44, 55); + my_sprintf (result, "%ho %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%o %d", (unsigned int) 12345, 33, 44, 55); + my_sprintf (result, "%o %d", 12345U, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%lo %d", (unsigned long int) 12345, 33, 44, 55); + my_sprintf (result, "%lo %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%llo %d", (unsigned long long int) 12345, 33, 44, 55); + my_sprintf (result, "%llo %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w8o %d", (uint8_t) 42, 33, 44, 55); + my_sprintf (result, "%w8o %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w16o %d", (uint16_t) 12345, 33, 44, 55); + my_sprintf (result, "%w16o %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w32o %d", (uint32_t) 12345, 33, 44, 55); + my_sprintf (result, "%w32o %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w64o %d", (uint64_t) 12345, 33, 44, 55); + my_sprintf (result, "%w64o %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf8o %d", (uint_fast8_t) 42, 33, 44, 55); + my_sprintf (result, "%wf8o %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf16o %d", (uint_fast16_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf16o %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf32o %d", (uint_fast32_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf32o %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf64o %d", (uint_fast64_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf64o %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); } @@ -3870,91 +3870,91 @@ test_function (int (*my_sprintf) (char *, const char *, ...)) { int retval = - my_sprintf (result, "%hhX %d", (unsigned char) 42, 33, 44, 55); + my_sprintf (result, "%hhX %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%hX %d", (unsigned short) 12345, 33, 44, 55); + my_sprintf (result, "%hX %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%X %d", (unsigned int) 12345, 33, 44, 55); + my_sprintf (result, "%X %d", 12345U, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%lX %d", (unsigned long int) 12345, 33, 44, 55); + my_sprintf (result, "%lX %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%llX %d", (unsigned long long int) 12345, 33, 44, 55); + my_sprintf (result, "%llX %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w8X %d", (uint8_t) 42, 33, 44, 55); + my_sprintf (result, "%w8X %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w16X %d", (uint16_t) 12345, 33, 44, 55); + my_sprintf (result, "%w16X %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w32X %d", (uint32_t) 12345, 33, 44, 55); + my_sprintf (result, "%w32X %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%w64X %d", (uint64_t) 12345, 33, 44, 55); + my_sprintf (result, "%w64X %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf8X %d", (uint_fast8_t) 42, 33, 44, 55); + my_sprintf (result, "%wf8X %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf16X %d", (uint_fast16_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf16X %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf32X %d", (uint_fast32_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf32X %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } { int retval = - my_sprintf (result, "%wf64X %d", (uint_fast64_t) 12345, 33, 44, 55); + my_sprintf (result, "%wf64X %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); } diff --git a/tests/test-stat-time.c b/tests/test-stat-time.c index 7c6e59553e..183125641b 100644 --- a/tests/test-stat-time.c +++ b/tests/test-stat-time.c @@ -48,7 +48,7 @@ static char filename_stamp3[50]; static void initialize_filenames (void) { - long t = (long) time (NULL); + long t = time (NULL); sprintf (filename_stamp1, "t-stt-%ld-stamp1", t); sprintf (filename_testfile, "t-stt-%ld-testfile", t); sprintf (filename_stamp2, "t-stt-%ld-stamp2", t); diff --git a/tests/test-towctrans.c b/tests/test-towctrans.c index 6836ab5512..d05f63f71f 100644 --- a/tests/test-towctrans.c +++ b/tests/test-towctrans.c @@ -42,7 +42,7 @@ main (int argc, char *argv[]) ASSERT (towctrans (L'1', desc) == '1'); ASSERT (towctrans (L'_', desc) == '_'); ASSERT (towctrans (L'_', desc) == '_'); - ASSERT (towctrans ((wchar_t) 0, desc) == 0); + ASSERT (towctrans (L'\0', desc) == 0); ASSERT (towctrans (WEOF, desc) == WEOF); desc = wctrans ("toupper"); @@ -53,7 +53,7 @@ main (int argc, char *argv[]) ASSERT (towctrans (L'z', desc) == 'Z'); ASSERT (towctrans (L'1', desc) == '1'); ASSERT (towctrans (L'_', desc) == '_'); - ASSERT (towctrans ((wchar_t) 0, desc) == 0); + ASSERT (towctrans (L'\0', desc) == 0); ASSERT (towctrans (WEOF, desc) == WEOF); return test_exit_status; diff --git a/tests/test-truncf2.c b/tests/test-truncf2.c index 6da305e2bd..af19527e3a 100644 --- a/tests/test-truncf2.c +++ b/tests/test-truncf2.c @@ -165,8 +165,8 @@ main () /* Combine highbits and lowbits into a floating-point number, sign-extending the lowbits to 32-NUM_HIGHBITS bits. */ union { float f; uint32_t i; } janus; - janus.i = ((uint32_t) highbits << (32 - NUM_HIGHBITS)) - | ((uint32_t) ((int32_t) ((uint32_t) lowbits << (32 - NUM_LOWBITS)) + janus.i = ((uint32_t) {highbits} << (32 - NUM_HIGHBITS)) + | ((uint32_t) ((int32_t) ((uint32_t) {lowbits} << (32 - NUM_LOWBITS)) >> (32 - NUM_LOWBITS - NUM_HIGHBITS)) >> NUM_HIGHBITS); error |= check (janus.f); diff --git a/tests/test-vasnprintf-posix.c b/tests/test-vasnprintf-posix.c index 663e6c64b2..5df21c38a6 100644 --- a/tests/test-vasnprintf-posix.c +++ b/tests/test-vasnprintf-posix.c @@ -3949,7 +3949,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) /* Test that converting an invalid wchar_t[] to char[] fails with EILSEQ. */ { - static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; + static const wchar_t input[] = { 1702057263, 114, 0 }; size_t length; char *result = my_asnprintf (NULL, &length, "%ls %d", input, 99); if (result == NULL) @@ -3958,7 +3958,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) free (result); } { - static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; + static const wchar_t input[] = { 1702057263, 114, 0 }; size_t length; char *result = my_asnprintf (NULL, &length, "%3ls %d", input, 99); if (result == NULL) @@ -3967,7 +3967,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) free (result); } { - static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; + static const wchar_t input[] = { 1702057263, 114, 0 }; size_t length; char *result = my_asnprintf (NULL, &length, "%.1ls %d", input, 99); if (result == NULL) @@ -3976,7 +3976,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) free (result); } { - static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; + static const wchar_t input[] = { 1702057263, 114, 0 }; size_t length; char *result = my_asnprintf (NULL, &length, "%3.1ls %d", input, 99); if (result == NULL) @@ -4051,7 +4051,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) free (result); } - static wint_t L_x = (wchar_t) 'x'; + static wint_t L_x = L'x'; { /* Width. */ size_t length; @@ -4117,7 +4117,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) free (result); } - static wint_t L_invalid = (wchar_t) 0x76543210; + static wint_t L_invalid = 0x76543210; { /* Invalid wide character. The conversion may succeed or may fail, but it should not abort. */ @@ -4598,7 +4598,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%hhd %d", (signed char) -42, 33, 44, 55); + my_asnprintf (NULL, &length, "%hhd %d", (signed char) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (length == strlen (result)); free (result); @@ -4607,7 +4607,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%hd %d", (short) -12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%hd %d", (short) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4625,7 +4625,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%ld %d", (long int) -12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%ld %d", -12345L, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4634,7 +4634,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%lld %d", (long long int) -12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%lld %d", -12345LL, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4643,7 +4643,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w8d %d", (int8_t) -42, 33, 44, 55); + my_asnprintf (NULL, &length, "%w8d %d", (int8_t) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (length == strlen (result)); free (result); @@ -4652,7 +4652,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w16d %d", (int16_t) -12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w16d %d", (int16_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4661,7 +4661,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w32d %d", (int32_t) -12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w32d %d", (int32_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4670,7 +4670,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w64d %d", (int64_t) -12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w64d %d", (int64_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4679,7 +4679,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf8d %d", (int_fast8_t) -42, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf8d %d", (int_fast8_t) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (length == strlen (result)); free (result); @@ -4688,7 +4688,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf16d %d", (int_fast16_t) -12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf16d %d", (int_fast16_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4697,7 +4697,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf32d %d", (int_fast32_t) -12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf32d %d", (int_fast32_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4706,7 +4706,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf64d %d", (int_fast64_t) -12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf64d %d", (int_fast64_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4718,7 +4718,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%hhu %d", (unsigned char) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%hhu %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (length == strlen (result)); free (result); @@ -4727,7 +4727,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%hu %d", (unsigned short) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%hu %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4736,7 +4736,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%u %d", (unsigned int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%u %d", 12345U, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4745,7 +4745,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%lu %d", (unsigned long int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%lu %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4754,7 +4754,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%llu %d", (unsigned long long int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%llu %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4763,7 +4763,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w8u %d", (uint8_t) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%w8u %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (length == strlen (result)); free (result); @@ -4772,7 +4772,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w16u %d", (uint16_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w16u %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4781,7 +4781,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w32u %d", (uint32_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w32u %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4790,7 +4790,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w64u %d", (uint64_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w64u %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4799,7 +4799,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf8u %d", (uint_fast8_t) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf8u %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (length == strlen (result)); free (result); @@ -4808,7 +4808,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf16u %d", (uint_fast16_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf16u %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4817,7 +4817,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf32u %d", (uint_fast32_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf32u %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4826,7 +4826,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf64u %d", (uint_fast64_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf64u %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (length == strlen (result)); free (result); @@ -4838,7 +4838,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%hhb %d", (unsigned char) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%hhb %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (length == strlen (result)); free (result); @@ -4847,7 +4847,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%hb %d", (unsigned short) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%hb %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (length == strlen (result)); free (result); @@ -4856,7 +4856,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%b %d", (unsigned int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%b %d", 12345U, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (length == strlen (result)); free (result); @@ -4865,7 +4865,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%lb %d", (unsigned long int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%lb %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (length == strlen (result)); free (result); @@ -4874,7 +4874,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%llb %d", (unsigned long long int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%llb %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (length == strlen (result)); free (result); @@ -4883,7 +4883,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w8b %d", (uint8_t) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%w8b %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (length == strlen (result)); free (result); @@ -4892,7 +4892,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w16b %d", (uint16_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w16b %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (length == strlen (result)); free (result); @@ -4901,7 +4901,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w32b %d", (uint32_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w32b %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (length == strlen (result)); free (result); @@ -4910,7 +4910,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w64b %d", (uint64_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w64b %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (length == strlen (result)); free (result); @@ -4919,7 +4919,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf8b %d", (uint_fast8_t) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf8b %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (length == strlen (result)); free (result); @@ -4928,7 +4928,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf16b %d", (uint_fast16_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf16b %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (length == strlen (result)); free (result); @@ -4937,7 +4937,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf32b %d", (uint_fast32_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf32b %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (length == strlen (result)); free (result); @@ -4946,7 +4946,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf64b %d", (uint_fast64_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf64b %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (length == strlen (result)); free (result); @@ -4958,7 +4958,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%hho %d", (unsigned char) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%hho %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (length == strlen (result)); free (result); @@ -4967,7 +4967,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%ho %d", (unsigned short) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%ho %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (length == strlen (result)); free (result); @@ -4976,7 +4976,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%o %d", (unsigned int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%o %d", 12345U, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (length == strlen (result)); free (result); @@ -4985,7 +4985,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%lo %d", (unsigned long int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%lo %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (length == strlen (result)); free (result); @@ -4994,7 +4994,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%llo %d", (unsigned long long int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%llo %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (length == strlen (result)); free (result); @@ -5003,7 +5003,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w8o %d", (uint8_t) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%w8o %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (length == strlen (result)); free (result); @@ -5012,7 +5012,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w16o %d", (uint16_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w16o %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (length == strlen (result)); free (result); @@ -5021,7 +5021,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w32o %d", (uint32_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w32o %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (length == strlen (result)); free (result); @@ -5030,7 +5030,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w64o %d", (uint64_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w64o %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (length == strlen (result)); free (result); @@ -5039,7 +5039,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf8o %d", (uint_fast8_t) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf8o %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (length == strlen (result)); free (result); @@ -5048,7 +5048,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf16o %d", (uint_fast16_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf16o %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (length == strlen (result)); free (result); @@ -5057,7 +5057,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf32o %d", (uint_fast32_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf32o %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (length == strlen (result)); free (result); @@ -5066,7 +5066,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf64o %d", (uint_fast64_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf64o %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (length == strlen (result)); free (result); @@ -5078,7 +5078,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%hhX %d", (unsigned char) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%hhX %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (length == strlen (result)); free (result); @@ -5087,7 +5087,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%hX %d", (unsigned short) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%hX %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (length == strlen (result)); free (result); @@ -5096,7 +5096,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%X %d", (unsigned int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%X %d", 12345U, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (length == strlen (result)); free (result); @@ -5105,7 +5105,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%lX %d", (unsigned long int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%lX %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (length == strlen (result)); free (result); @@ -5114,7 +5114,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%llX %d", (unsigned long long int) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%llX %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (length == strlen (result)); free (result); @@ -5123,7 +5123,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w8X %d", (uint8_t) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%w8X %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (length == strlen (result)); free (result); @@ -5132,7 +5132,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w16X %d", (uint16_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w16X %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (length == strlen (result)); free (result); @@ -5141,7 +5141,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w32X %d", (uint32_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w32X %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (length == strlen (result)); free (result); @@ -5150,7 +5150,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%w64X %d", (uint64_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%w64X %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (length == strlen (result)); free (result); @@ -5159,7 +5159,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf8X %d", (uint_fast8_t) 42, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf8X %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (length == strlen (result)); free (result); @@ -5168,7 +5168,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf16X %d", (uint_fast16_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf16X %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (length == strlen (result)); free (result); @@ -5177,7 +5177,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf32X %d", (uint_fast32_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf32X %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (length == strlen (result)); free (result); @@ -5186,7 +5186,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) { size_t length; char *result = - my_asnprintf (NULL, &length, "%wf64X %d", (uint_fast64_t) 12345, 33, 44, 55); + my_asnprintf (NULL, &length, "%wf64X %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (length == strlen (result)); free (result); diff --git a/tests/test-vasnwprintf-posix.c b/tests/test-vasnwprintf-posix.c index a9e1a780a3..fcd385b2c4 100644 --- a/tests/test-vasnwprintf-posix.c +++ b/tests/test-vasnwprintf-posix.c @@ -3982,7 +3982,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, /* Test that converting an invalid wchar_t[] to char[] fails with EILSEQ. */ { - static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; + static const wchar_t input[] = { 1702057263, 114, 0 }; size_t length; wchar_t *result = my_asnwprintf (NULL, &length, L"%ls %d", input, 99); if (result == NULL) @@ -3991,7 +3991,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, free (result); } { - static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; + static const wchar_t input[] = { 1702057263, 114, 0 }; size_t length; wchar_t *result = my_asnwprintf (NULL, &length, L"%3ls %d", input, 99); if (result == NULL) @@ -4000,7 +4000,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, free (result); } { - static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; + static const wchar_t input[] = { 1702057263, 114, 0 }; size_t length; wchar_t *result = my_asnwprintf (NULL, &length, L"%.1ls %d", input, 99); if (result == NULL) @@ -4009,7 +4009,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, free (result); } { - static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; + static const wchar_t input[] = { 1702057263, 114, 0 }; size_t length; wchar_t *result = my_asnwprintf (NULL, &length, L"%3.1ls %d", input, 99); if (result == NULL) @@ -4102,7 +4102,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, } #endif - static wint_t L_x = (wchar_t) 'x'; + static wint_t L_x = L'x'; { /* Width. */ size_t length; @@ -4162,7 +4162,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, free (result); } - static wint_t L_invalid = (wchar_t) 0x76543210; + static wint_t L_invalid = 0x76543210; { /* Invalid wide character. */ size_t length; @@ -4171,7 +4171,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, /* No failure is allowed: ISO C says "the wint_t argument is converted to wchar_t and written." */ ASSERT (result != NULL); - ASSERT (result[0] == (wchar_t) 0x76543210); + ASSERT (result[0] == 0x76543210); ASSERT (wmemcmp (result + 1, L" 33\0", 3 + 1) == 0); ASSERT (length == 4); free (result); @@ -4185,7 +4185,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, to wchar_t and written." */ ASSERT (result != NULL); ASSERT (wmemcmp (result, L" ", 9) == 0); - ASSERT (result[9] == (wchar_t) 0x76543210); + ASSERT (result[9] == 0x76543210); ASSERT (wmemcmp (result + 10, L" 33\0", 3 + 1) == 0); ASSERT (length == 13); free (result); @@ -4654,7 +4654,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%hhd %d", (signed char) -42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%hhd %d", (signed char) {-42}, 33, 44, 55); ASSERT (wcscmp (result, L"-42 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4663,7 +4663,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%hd %d", (short) -12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%hd %d", (short) {-12345}, 33, 44, 55); ASSERT (wcscmp (result, L"-12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4681,7 +4681,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%ld %d", (long int) -12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%ld %d", -12345L, 33, 44, 55); ASSERT (wcscmp (result, L"-12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4690,7 +4690,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%lld %d", (long long int) -12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%lld %d", -12345LL, 33, 44, 55); ASSERT (wcscmp (result, L"-12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4699,7 +4699,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w8d %d", (int8_t) -42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w8d %d", (int8_t) {-42}, 33, 44, 55); ASSERT (wcscmp (result, L"-42 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4708,7 +4708,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w16d %d", (int16_t) -12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w16d %d", (int16_t) {-12345}, 33, 44, 55); ASSERT (wcscmp (result, L"-12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4717,7 +4717,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w32d %d", (int32_t) -12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w32d %d", (int32_t) {-12345}, 33, 44, 55); ASSERT (wcscmp (result, L"-12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4726,7 +4726,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w64d %d", (int64_t) -12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w64d %d", (int64_t) {-12345}, 33, 44, 55); ASSERT (wcscmp (result, L"-12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4735,7 +4735,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf8d %d", (int_fast8_t) -42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf8d %d", (int_fast8_t) {-42}, 33, 44, 55); ASSERT (wcscmp (result, L"-42 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4744,7 +4744,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf16d %d", (int_fast16_t) -12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf16d %d", (int_fast16_t) {-12345}, 33, 44, 55); ASSERT (wcscmp (result, L"-12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4753,7 +4753,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf32d %d", (int_fast32_t) -12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf32d %d", (int_fast32_t) {-12345}, 33, 44, 55); ASSERT (wcscmp (result, L"-12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4762,7 +4762,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf64d %d", (int_fast64_t) -12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf64d %d", (int_fast64_t) {-12345}, 33, 44, 55); ASSERT (wcscmp (result, L"-12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4774,7 +4774,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%hhu %d", (unsigned char) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%hhu %d", (unsigned char) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"42 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4783,7 +4783,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%hu %d", (unsigned short) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%hu %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4792,7 +4792,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%u %d", (unsigned int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%u %d", 12345U, 33, 44, 55); ASSERT (wcscmp (result, L"12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4801,7 +4801,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%lu %d", (unsigned long int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%lu %d", 12345UL, 33, 44, 55); ASSERT (wcscmp (result, L"12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4810,7 +4810,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%llu %d", (unsigned long long int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%llu %d", 12345ULL, 33, 44, 55); ASSERT (wcscmp (result, L"12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4819,7 +4819,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w8u %d", (uint8_t) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w8u %d", (uint8_t) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"42 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4828,7 +4828,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w16u %d", (uint16_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w16u %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4837,7 +4837,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w32u %d", (uint32_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w32u %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4846,7 +4846,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w64u %d", (uint64_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w64u %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4855,7 +4855,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf8u %d", (uint_fast8_t) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf8u %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"42 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4864,7 +4864,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf16u %d", (uint_fast16_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf16u %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4873,7 +4873,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf32u %d", (uint_fast32_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf32u %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4882,7 +4882,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf64u %d", (uint_fast64_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf64u %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"12345 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4894,7 +4894,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%hhb %d", (unsigned char) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%hhb %d", (unsigned char) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"101010 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4903,7 +4903,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%hb %d", (unsigned short) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%hb %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"11000000111001 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4912,7 +4912,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%b %d", (unsigned int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%b %d", 12345U, 33, 44, 55); ASSERT (wcscmp (result, L"11000000111001 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4921,7 +4921,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%lb %d", (unsigned long int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%lb %d", 12345UL, 33, 44, 55); ASSERT (wcscmp (result, L"11000000111001 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4930,7 +4930,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%llb %d", (unsigned long long int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%llb %d", 12345ULL, 33, 44, 55); ASSERT (wcscmp (result, L"11000000111001 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4939,7 +4939,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w8b %d", (uint8_t) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w8b %d", (uint8_t) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"101010 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4948,7 +4948,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w16b %d", (uint16_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w16b %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"11000000111001 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4957,7 +4957,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w32b %d", (uint32_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w32b %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"11000000111001 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4966,7 +4966,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w64b %d", (uint64_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w64b %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"11000000111001 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4975,7 +4975,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf8b %d", (uint_fast8_t) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf8b %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"101010 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4984,7 +4984,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf16b %d", (uint_fast16_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf16b %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"11000000111001 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -4993,7 +4993,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf32b %d", (uint_fast32_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf32b %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"11000000111001 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5002,7 +5002,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf64b %d", (uint_fast64_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf64b %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"11000000111001 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5014,7 +5014,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%hho %d", (unsigned char) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%hho %d", (unsigned char) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"52 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5023,7 +5023,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%ho %d", (unsigned short) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%ho %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"30071 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5032,7 +5032,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%o %d", (unsigned int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%o %d", 12345U, 33, 44, 55); ASSERT (wcscmp (result, L"30071 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5041,7 +5041,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%lo %d", (unsigned long int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%lo %d", 12345UL, 33, 44, 55); ASSERT (wcscmp (result, L"30071 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5050,7 +5050,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%llo %d", (unsigned long long int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%llo %d", 12345ULL, 33, 44, 55); ASSERT (wcscmp (result, L"30071 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5059,7 +5059,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w8o %d", (uint8_t) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w8o %d", (uint8_t) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"52 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5068,7 +5068,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w16o %d", (uint16_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w16o %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"30071 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5077,7 +5077,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w32o %d", (uint32_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w32o %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"30071 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5086,7 +5086,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w64o %d", (uint64_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w64o %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"30071 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5095,7 +5095,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf8o %d", (uint_fast8_t) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf8o %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"52 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5104,7 +5104,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf16o %d", (uint_fast16_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf16o %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"30071 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5113,7 +5113,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf32o %d", (uint_fast32_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf32o %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"30071 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5122,7 +5122,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf64o %d", (uint_fast64_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf64o %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"30071 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5134,7 +5134,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%hhX %d", (unsigned char) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%hhX %d", (unsigned char) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"2A 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5143,7 +5143,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%hX %d", (unsigned short) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%hX %d", (unsigned short) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"3039 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5152,7 +5152,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%X %d", (unsigned int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%X %d", 12345U, 33, 44, 55); ASSERT (wcscmp (result, L"3039 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5161,7 +5161,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%lX %d", (unsigned long int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%lX %d", 12345UL, 33, 44, 55); ASSERT (wcscmp (result, L"3039 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5170,7 +5170,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%llX %d", (unsigned long long int) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%llX %d", 12345ULL, 33, 44, 55); ASSERT (wcscmp (result, L"3039 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5179,7 +5179,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w8X %d", (uint8_t) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w8X %d", (uint8_t) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"2A 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5188,7 +5188,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w16X %d", (uint16_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w16X %d", (uint16_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"3039 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5197,7 +5197,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w32X %d", (uint32_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w32X %d", (uint32_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"3039 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5206,7 +5206,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%w64X %d", (uint64_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%w64X %d", (uint64_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"3039 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5215,7 +5215,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf8X %d", (uint_fast8_t) 42, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf8X %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (wcscmp (result, L"2A 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5224,7 +5224,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf16X %d", (uint_fast16_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf16X %d", (uint_fast16_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"3039 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5233,7 +5233,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf32X %d", (uint_fast32_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf32X %d", (uint_fast32_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"3039 33") == 0); ASSERT (length == wcslen (result)); free (result); @@ -5242,7 +5242,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *, { size_t length; wchar_t *result = - my_asnwprintf (NULL, &length, L"%wf64X %d", (uint_fast64_t) 12345, 33, 44, 55); + my_asnwprintf (NULL, &length, L"%wf64X %d", (uint_fast64_t) {12345}, 33, 44, 55); ASSERT (wcscmp (result, L"3039 33") == 0); ASSERT (length == wcslen (result)); free (result); diff --git a/tests/test-vasprintf-posix.c b/tests/test-vasprintf-posix.c index 8bea0ecaef..4ca2654167 100644 --- a/tests/test-vasprintf-posix.c +++ b/tests/test-vasprintf-posix.c @@ -3991,7 +3991,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) free (result); } - static wint_t L_x = (wchar_t) 'x'; + static wint_t L_x = L'x'; { /* Width. */ char *result; @@ -4057,7 +4057,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) free (result); } - static wint_t L_invalid = (wchar_t) 0x76543210; + static wint_t L_invalid = 0x76543210; { /* Invalid wide character. The conversion may succeed or may fail, but it should not abort. */ @@ -4540,7 +4540,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%hhd %d", (signed char) -42, 33, 44, 55); + my_asprintf (&result, "%hhd %d", (signed char) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (retval == strlen (result)); free (result); @@ -4549,7 +4549,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%hd %d", (short) -12345, 33, 44, 55); + my_asprintf (&result, "%hd %d", (short) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4567,7 +4567,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%ld %d", (long int) -12345, 33, 44, 55); + my_asprintf (&result, "%ld %d", -12345L, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4576,7 +4576,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%lld %d", (long long int) -12345, 33, 44, 55); + my_asprintf (&result, "%lld %d", -12345LL, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4585,7 +4585,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%w8d %d", (int8_t) -42, 33, 44, 55); + my_asprintf (&result, "%w8d %d", (int8_t) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (retval == strlen (result)); free (result); @@ -4594,7 +4594,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%w16d %d", (int16_t) -12345, 33, 44, 55); + my_asprintf (&result, "%w16d %d", (int16_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4603,7 +4603,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%w32d %d", (int32_t) -12345, 33, 44, 55); + my_asprintf (&result, "%w32d %d", (int32_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4612,7 +4612,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%w64d %d", (int64_t) -12345, 33, 44, 55); + my_asprintf (&result, "%w64d %d", (int64_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4621,7 +4621,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%wf8d %d", (int_fast8_t) -42, 33, 44, 55); + my_asprintf (&result, "%wf8d %d", (int_fast8_t) {-42}, 33, 44, 55); ASSERT (streq (result, "-42 33")); ASSERT (retval == strlen (result)); free (result); @@ -4630,7 +4630,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%wf16d %d", (int_fast16_t) -12345, 33, 44, 55); + my_asprintf (&result, "%wf16d %d", (int_fast16_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4639,7 +4639,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%wf32d %d", (int_fast32_t) -12345, 33, 44, 55); + my_asprintf (&result, "%wf32d %d", (int_fast32_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4648,7 +4648,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%wf64d %d", (int_fast64_t) -12345, 33, 44, 55); + my_asprintf (&result, "%wf64d %d", (int_fast64_t) {-12345}, 33, 44, 55); ASSERT (streq (result, "-12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4660,7 +4660,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%hhu %d", (unsigned char) 42, 33, 44, 55); + my_asprintf (&result, "%hhu %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (retval == strlen (result)); free (result); @@ -4678,7 +4678,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%u %d", (unsigned int) 12345, 33, 44, 55); + my_asprintf (&result, "%u %d", 12345U, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4687,7 +4687,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%lu %d", (unsigned long int) 12345, 33, 44, 55); + my_asprintf (&result, "%lu %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4696,7 +4696,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%llu %d", (unsigned long long int) 12345, 33, 44, 55); + my_asprintf (&result, "%llu %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "12345 33")); ASSERT (retval == strlen (result)); free (result); @@ -4705,7 +4705,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%w8u %d", (uint8_t) 42, 33, 44, 55); + my_asprintf (&result, "%w8u %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (retval == strlen (result)); free (result); @@ -4741,7 +4741,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%wf8u %d", (uint_fast8_t) 42, 33, 44, 55); + my_asprintf (&result, "%wf8u %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "42 33")); ASSERT (retval == strlen (result)); free (result); @@ -4780,7 +4780,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%hhb %d", (unsigned char) 42, 33, 44, 55); + my_asprintf (&result, "%hhb %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (retval == strlen (result)); free (result); @@ -4798,7 +4798,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%b %d", (unsigned int) 12345, 33, 44, 55); + my_asprintf (&result, "%b %d", 12345U, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); free (result); @@ -4807,7 +4807,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%lb %d", (unsigned long int) 12345, 33, 44, 55); + my_asprintf (&result, "%lb %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); free (result); @@ -4816,7 +4816,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%llb %d", (unsigned long long int) 12345, 33, 44, 55); + my_asprintf (&result, "%llb %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "11000000111001 33")); ASSERT (retval == strlen (result)); free (result); @@ -4825,7 +4825,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%w8b %d", (uint8_t) 42, 33, 44, 55); + my_asprintf (&result, "%w8b %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (retval == strlen (result)); free (result); @@ -4861,7 +4861,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%wf8b %d", (uint_fast8_t) 42, 33, 44, 55); + my_asprintf (&result, "%wf8b %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "101010 33")); ASSERT (retval == strlen (result)); free (result); @@ -4900,7 +4900,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%hho %d", (unsigned char) 42, 33, 44, 55); + my_asprintf (&result, "%hho %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (retval == strlen (result)); free (result); @@ -4918,7 +4918,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%o %d", (unsigned int) 12345, 33, 44, 55); + my_asprintf (&result, "%o %d", 12345U, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); free (result); @@ -4927,7 +4927,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%lo %d", (unsigned long int) 12345, 33, 44, 55); + my_asprintf (&result, "%lo %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); free (result); @@ -4936,7 +4936,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%llo %d", (unsigned long long int) 12345, 33, 44, 55); + my_asprintf (&result, "%llo %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "30071 33")); ASSERT (retval == strlen (result)); free (result); @@ -4945,7 +4945,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%w8o %d", (uint8_t) 42, 33, 44, 55); + my_asprintf (&result, "%w8o %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (retval == strlen (result)); free (result); @@ -4981,7 +4981,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%wf8o %d", (uint_fast8_t) 42, 33, 44, 55); + my_asprintf (&result, "%wf8o %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "52 33")); ASSERT (retval == strlen (result)); free (result); @@ -5020,7 +5020,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%hhX %d", (unsigned char) 42, 33, 44, 55); + my_asprintf (&result, "%hhX %d", (unsigned char) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (retval == strlen (result)); free (result); @@ -5038,7 +5038,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%X %d", (unsigned int) 12345, 33, 44, 55); + my_asprintf (&result, "%X %d", 12345U, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); free (result); @@ -5047,7 +5047,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%lX %d", (unsigned long int) 12345, 33, 44, 55); + my_asprintf (&result, "%lX %d", 12345UL, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); free (result); @@ -5056,7 +5056,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%llX %d", (unsigned long long int) 12345, 33, 44, 55); + my_asprintf (&result, "%llX %d", 12345ULL, 33, 44, 55); ASSERT (streq (result, "3039 33")); ASSERT (retval == strlen (result)); free (result); @@ -5065,7 +5065,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%w8X %d", (uint8_t) 42, 33, 44, 55); + my_asprintf (&result, "%w8X %d", (uint8_t) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (retval == strlen (result)); free (result); @@ -5101,7 +5101,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...)) { char *result; int retval = - my_asprintf (&result, "%wf8X %d", (uint_fast8_t) 42, 33, 44, 55); + my_asprintf (&result, "%wf8X %d", (uint_fast8_t) {42}, 33, 44, 55); ASSERT (streq (result, "2A 33")); ASSERT (retval == strlen (result)); free (result); diff --git a/tests/test-wcrtomb.c b/tests/test-wcrtomb.c index 977e00975e..ff347b9f1f 100644 --- a/tests/test-wcrtomb.c +++ b/tests/test-wcrtomb.c @@ -38,7 +38,7 @@ check_character (const char *s, size_t n) int iret; size_t ret; - wc = (wchar_t) 0xBADFACE; + wc = 0xBADFACE; iret = mbtowc (&wc, s, n); ASSERT (iret == n); diff --git a/tests/test-wcscmp.c b/tests/test-wcscmp.c index 84989ae8af..3512b14662 100644 --- a/tests/test-wcscmp.c +++ b/tests/test-wcscmp.c @@ -70,9 +70,9 @@ main (int argc, char *argv[]) subclause order two wide characters the same way as two integers of the underlying integer type designated by wchar_t." */ { - static const wchar_t input1[] = { (wchar_t) 0x76547654, 0 }; - static const wchar_t input2[] = { (wchar_t) 0x9abc9abc, 0 }; - if ((wchar_t)-1 < 0) + static const wchar_t input1[] = { 0x76547654, 0 }; + static const wchar_t input2[] = { 0x9abc9abc, 0 }; + if ((wchar_t) {-1} < 0) { /* wchar_t is signed. */ ASSERT (wcscmp (input1, input2) > 0); @@ -102,9 +102,9 @@ main (int argc, char *argv[]) This means that the comparison extends up to and *including* the first null wchar_t. */ { - static const wchar_t input1[] = { (wchar_t) 'x', 0 }; - static const wchar_t input2[] = { (wchar_t) 'x', (wchar_t) 0x9abc9abc, 0 }; - if ((wchar_t)-1 < 0) + static const wchar_t input1[] = { L'x', 0 }; + static const wchar_t input2[] = { L'x', 0x9abc9abc, 0 }; + if ((wchar_t) {-1} < 0) { /* wchar_t is signed. */ ASSERT (wcscmp (input1, input2) > 0); diff --git a/tests/test-wcsncmp.c b/tests/test-wcsncmp.c index 9a6af6dba1..cc41aed8c2 100644 --- a/tests/test-wcsncmp.c +++ b/tests/test-wcsncmp.c @@ -118,10 +118,10 @@ main (int argc, char *argv[]) subclause order two wide characters the same way as two integers of the underlying integer type designated by wchar_t." */ { - static const wchar_t input1[] = { (wchar_t) 0x76547654, 0 }; - static const wchar_t input2[] = { (wchar_t) 0x9abc9abc, 0 }; + static const wchar_t input1[] = { 0x76547654, 0 }; + static const wchar_t input2[] = { 0x9abc9abc, 0 }; ASSERT (wcsncmp (input1, input2, 0) == 0); - if ((wchar_t)-1 < 0) + if ((wchar_t) {-1} < 0) { /* wchar_t is signed. */ ASSERT (wcsncmp (input1, input2, 1) > 0); @@ -164,11 +164,11 @@ main (int argc, char *argv[]) This means that the comparison extends up to and *including* the first null wchar_t. */ { - static const wchar_t input1[] = { (wchar_t) 'x', 0 }; - static const wchar_t input2[] = { (wchar_t) 'x', (wchar_t) 0x9abc9abc, 0 }; + static const wchar_t input1[] = { L'x', 0 }; + static const wchar_t input2[] = { L'x', 0x9abc9abc, 0 }; ASSERT (wcsncmp (input1, input2, 0) == 0); ASSERT (wcsncmp (input1, input2, 1) == 0); - if ((wchar_t)-1 < 0) + if ((wchar_t) {-1} < 0) { /* wchar_t is signed. */ ASSERT (wcsncmp (input1, input2, 2) > 0); diff --git a/tests/test-wmemcmp.c b/tests/test-wmemcmp.c index 3428230ffc..5c969ef1ac 100644 --- a/tests/test-wmemcmp.c +++ b/tests/test-wmemcmp.c @@ -80,9 +80,9 @@ main (int argc, char *argv[]) subclause order two wide characters the same way as two integers of the underlying integer type designated by wchar_t." */ { - static const wchar_t input1[] = { (wchar_t) 0x76547654 }; - static const wchar_t input2[] = { (wchar_t) 0x9abc9abc }; - if ((wchar_t)-1 < 0) + static const wchar_t input1[] = { 0x76547654 }; + static const wchar_t input2[] = { 0x9abc9abc }; + if ((wchar_t) {-1} < 0) { /* wchar_t is signed. */ ASSERT (wmemcmp (input1, input2, 1) > 0); diff --git a/tests/uniwidth/test-uc_width2.c b/tests/uniwidth/test-uc_width2.c index ef2fd88a22..7117ca2dd9 100644 --- a/tests/uniwidth/test-uc_width2.c +++ b/tests/uniwidth/test-uc_width2.c @@ -36,10 +36,10 @@ finish_interval (void) if (current_width != 0) { if (current_start == current_end) - printf ("%04X\t\t%c\n", (unsigned) current_start, current_width); + printf ("%04X\t\t%c\n", (unsigned) {current_start}, current_width); else - printf ("%04X..%04X\t%c\n", (unsigned) current_start, - (unsigned) current_end, current_width); + printf ("%04X..%04X\t%c\n", (unsigned) {current_start}, + (unsigned) {current_end}, current_width); current_width = 0; } }