Fix many test failures on Windows and 32-bit AIX (regr. 2026-05-08).

* tests/test-iswdigit.c (for_character): Restore cast of constants to
wchar_t, but in the form of a compound initializer.
* tests/test-iswpunct.c (for_character): Likewise.
* tests/test-iswxdigit.c (for_character): Likewise.
* tests/test-mbrtowc.c (main): Likewise.
* tests/test-mbrtowc-w32.c (test_one_locale): Likewise.
* tests/test-mbrtowc-w32utf8.c (main): Likewise.
* tests/test-mbsnrtowcs.c (main): Likewise.
* tests/test-mbsrtowcs.c (main): Likewise.
* tests/test-mbstowcs.c (main): Likewise.
* tests/test-snprintf-posix.h (test_function): Likewise.
* tests/test-sprintf-posix.h (test_function): Likewise.
* tests/test-towctrans.c (main): Likewise.
* tests/test-vasnprintf-posix.c (test_function): Likewise.
* tests/test-vasnwprintf-posix.c (test_function): Likewise.
* tests/test-vasprintf-posix.c (test_function): Likewise.
* tests/test-wcrtomb.c (check_character): Likewise.
* tests/test-wcscmp.c (main): Likewise.
* tests/test-wcsncmp.c (main): Likewise.
* tests/test-wmemcmp.c (main): Likewise.
* m4/c32rtomb.m4 (gl_C32RTOMB_SANITYCHECK): Likewise.
* m4/iswdigit.m4 (gl_FUNC_ISWDIGIT): Likewise.
* m4/iswxdigit.m4 (gl_FUNC_ISWXDIGIT): Likewise.
* m4/mbrtoc32.m4 (gl_MBRTOC32_SANITYCHECK): Likewise.
* m4/mbrtowc.m4 (gl_MBRTOWC_NULL_ARG1, gl_MBRTOWC_STORES_INCOMPLETE):
Likewise.
* m4/mbsnrtowcs.m4 (gl_MBSNRTOWCS_WORKS_IN_TRADITIONAL_LOCALE):
Likewise.
* m4/wcrtomb.m4 (gl_FUNC_WCRTOMB): Likewise.

diff --git a/ChangeLog b/ChangeLog
index 6f1587bf9e1a1e7a424b5dfde157b06ccc34f7d8..d0f2d1af5f76331d573de1d524876083e95a1f1e 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,36 @@
+2026-05-10  Bruno Haible  <bruno@clisp.org>
+
+       Fix many test failures on Windows and 32-bit AIX (regr. 2026-05-08).
+       * tests/test-iswdigit.c (for_character): Restore cast of constants to
+       wchar_t, but in the form of a compound initializer.
+       * tests/test-iswpunct.c (for_character): Likewise.
+       * tests/test-iswxdigit.c (for_character): Likewise.
+       * tests/test-mbrtowc.c (main): Likewise.
+       * tests/test-mbrtowc-w32.c (test_one_locale): Likewise.
+       * tests/test-mbrtowc-w32utf8.c (main): Likewise.
+       * tests/test-mbsnrtowcs.c (main): Likewise.
+       * tests/test-mbsrtowcs.c (main): Likewise.
+       * tests/test-mbstowcs.c (main): Likewise.
+       * tests/test-snprintf-posix.h (test_function): Likewise.
+       * tests/test-sprintf-posix.h (test_function): Likewise.
+       * tests/test-towctrans.c (main): Likewise.
+       * tests/test-vasnprintf-posix.c (test_function): Likewise.
+       * tests/test-vasnwprintf-posix.c (test_function): Likewise.
+       * tests/test-vasprintf-posix.c (test_function): Likewise.
+       * tests/test-wcrtomb.c (check_character): Likewise.
+       * tests/test-wcscmp.c (main): Likewise.
+       * tests/test-wcsncmp.c (main): Likewise.
+       * tests/test-wmemcmp.c (main): Likewise.
+       * m4/c32rtomb.m4 (gl_C32RTOMB_SANITYCHECK): Likewise.
+       * m4/iswdigit.m4 (gl_FUNC_ISWDIGIT): Likewise.
+       * m4/iswxdigit.m4 (gl_FUNC_ISWXDIGIT): Likewise.
+       * m4/mbrtoc32.m4 (gl_MBRTOC32_SANITYCHECK): Likewise.
+       * m4/mbrtowc.m4 (gl_MBRTOWC_NULL_ARG1, gl_MBRTOWC_STORES_INCOMPLETE):
+       Likewise.
+       * m4/mbsnrtowcs.m4 (gl_MBSNRTOWCS_WORKS_IN_TRADITIONAL_LOCALE):
+       Likewise.
+       * m4/wcrtomb.m4 (gl_FUNC_WCRTOMB): Likewise.
+
 2026-05-10  Bruno Haible  <bruno@clisp.org>
 
        strings-h: Revert last change, now unnecessary.

diff --git a/m4/c32rtomb.m4 b/m4/c32rtomb.m4
index 6f562a2e48d2ce03e3e945416dd9698d5d75d313..8382e834cad045b08c2f6272db28e7ec47e4a34e 100644 (file)
--- a/m4/c32rtomb.m4
+++ b/m4/c32rtomb.m4
@@ -1,5 +1,5 @@
 # c32rtomb.m4
-# serial 9
+# serial 10
 dnl Copyright (C) 2020-2026 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -153,14 +153,14 @@ int main ()
       && setlocale (LC_ALL, "$LOCALE_ZH_CN") != NULL)
     {
       mbstate_t state;
-      wchar_t wc = 0xBADFACE;
+      wchar_t wc = (wchar_t) {0xBADFACE};
       char buf[16];
       memset (&state, '\0', sizeof (mbstate_t));
       if (mbrtowc (&wc, "\201\060\211\070", 4, &state) == 4
           && wcrtomb (buf, wc, NULL) == 4
           && memcmp (buf, "\201\060\211\070", 4) == 0)
         {
-          char32_t c32 = 0xBADFACE;
+          char32_t c32 = (wchar_t) {0xBADFACE};
           memset (&state, '\0', sizeof (mbstate_t));
           if (mbrtoc32 (&c32, "\201\060\211\070", 4, &state) == 4
               && c32rtomb (buf, c32, NULL) != 4)

diff --git a/m4/iswdigit.m4 b/m4/iswdigit.m4
index 988e12a5e007592f0c54737705a9ed832323ef48..a8793068c8a08deecbdef544c262d9ca840636a0 100644 (file)
--- a/m4/iswdigit.m4
+++ b/m4/iswdigit.m4
@@ -1,5 +1,5 @@
 # iswdigit.m4
-# serial 10
+# serial 11
 dnl Copyright (C) 2020-2026 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -52,7 +52,7 @@ for_character (const char *s, size_t n)
   size_t ret;
 
   memset (&state, '\0', sizeof (mbstate_t));
-  wc = 0xBADFACE;
+  wc = (wchar_t) {0xBADFACE};
   ret = mbrtowc (&wc, s, n, &state);
   if (ret != n)
     abort ();

diff --git a/m4/iswxdigit.m4 b/m4/iswxdigit.m4
index af050bf9fdd08e844dc122d87b36a7a67f58ecbe..ca382a3c12fd176461d53a9ee286766f95952cc8 100644 (file)
--- a/m4/iswxdigit.m4
+++ b/m4/iswxdigit.m4
@@ -1,5 +1,5 @@
 # iswxdigit.m4
-# serial 10
+# serial 11
 dnl Copyright (C) 2020-2026 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -51,7 +51,7 @@ for_character (const char *s, size_t n)
   size_t ret;
 
   memset (&state, '\0', sizeof (mbstate_t));
-  wc = 0xBADFACE;
+  wc = (wchar_t) {0xBADFACE};
   ret = mbrtowc (&wc, s, n, &state);
   if (ret != n)
     abort ();

diff --git a/m4/mbrtoc32.m4 b/m4/mbrtoc32.m4
index 1ebcbb1fc66aa1d192c8db763faf92aad8052421..3eaa49ff41218245e7c4ca31cae5c66f6dc9e009 100644 (file)
--- a/m4/mbrtoc32.m4
+++ b/m4/mbrtoc32.m4
@@ -1,5 +1,5 @@
 # mbrtoc32.m4
-# serial 23
+# serial 24
 dnl Copyright (C) 2014-2026 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -303,11 +303,11 @@ int main ()
       && setlocale (LC_ALL, "$LOCALE_FR") != NULL)
     {
       mbstate_t state;
-      wchar_t wc = 0xBADFACE;
+      wchar_t wc = (wchar_t) {0xBADFACE};
       memset (&state, '\0', sizeof (mbstate_t));
       if (mbrtowc (&wc, "\374", 1, &state) == 1)
         {
-          char32_t c32 = 0xBADFACE;
+          char32_t c32 = (wchar_t) {0xBADFACE};
           memset (&state, '\0', sizeof (mbstate_t));
           if (mbrtoc32 (&c32, "\374", 1, &state) != 1)
             result |= 1;
@@ -320,11 +320,11 @@ int main ()
       && setlocale (LC_ALL, "$LOCALE_ZH_CN") != NULL)
     {
       mbstate_t state;
-      wchar_t wc = 0xBADFACE;
+      wchar_t wc = (wchar_t) {0xBADFACE};
       memset (&state, '\0', sizeof (mbstate_t));
       if (mbrtowc (&wc, "\224\071\375\067", 4, &state) == 4)
         {
-          char32_t c32 = 0xBADFACE;
+          char32_t c32 = (wchar_t) {0xBADFACE};
           memset (&state, '\0', sizeof (mbstate_t));
           if (mbrtoc32 (&c32, "\224\071\375\067", 4, &state) != 4)
             result |= 2;

diff --git a/m4/mbrtowc.m4 b/m4/mbrtowc.m4
index e88a66850f8a7e66e58de85bf2aaef3459e3504d..381b22dd21261782dc7ddbef4c42ee49e8e0266f 100644 (file)
--- a/m4/mbrtowc.m4
+++ b/m4/mbrtowc.m4
@@ -1,5 +1,5 @@
 # mbrtowc.m4
-# serial 48
+# serial 49
 dnl Copyright (C) 2001-2002, 2004-2005, 2008-2026 Free Software Foundation,
 dnl Inc.
 dnl This file is free software; the Free Software Foundation
@@ -315,7 +315,7 @@ int main ()
       size_t ret;
 
       memset (&state, '\0', sizeof (mbstate_t));
-      wc = 0xBADFACE;
+      wc = (wchar_t) {0xBADFACE};
       ret = mbrtowc (&wc, input, 5, &state);
       if (ret != 2)
         result |= 1;
@@ -546,42 +546,42 @@ int main ()
   int result = 0;
   if (setlocale (LC_ALL, "French_France.65001") != NULL)
     {
-      wchar_t wc = 0xBADFACE;
+      wchar_t wc = (wchar_t) {0xBADFACE};
       mbstate_t state;
 
       memset (&state, '\0', sizeof (mbstate_t));
       if (mbrtowc (&wc, "\303", 1, &state) == (size_t)(-2)
-          && wc != 0xBADFACE)
+          && wc != (wchar_t) {0xBADFACE})
         result |= 1;
     }
   if (setlocale (LC_ALL, "Japanese_Japan.932") != NULL)
     {
-      wchar_t wc = 0xBADFACE;
+      wchar_t wc = (wchar_t) {0xBADFACE};
       mbstate_t state;
 
       memset (&state, '\0', sizeof (mbstate_t));
       if (mbrtowc (&wc, "\226", 1, &state) == (size_t)(-2)
-          && wc != 0xBADFACE)
+          && wc != (wchar_t) {0xBADFACE})
         result |= 2;
     }
   if (setlocale (LC_ALL, "Chinese_Taiwan.950") != NULL)
     {
-      wchar_t wc = 0xBADFACE;
+      wchar_t wc = (wchar_t) {0xBADFACE};
       mbstate_t state;
 
       memset (&state, '\0', sizeof (mbstate_t));
       if (mbrtowc (&wc, "\245", 1, &state) == (size_t)(-2)
-          && wc != 0xBADFACE)
+          && wc != (wchar_t) {0xBADFACE})
         result |= 4;
     }
   if (setlocale (LC_ALL, "Chinese_China.936") != NULL)
     {
-      wchar_t wc = 0xBADFACE;
+      wchar_t wc = (wchar_t) {0xBADFACE};
       mbstate_t state;
 
       memset (&state, '\0', sizeof (mbstate_t));
       if (mbrtowc (&wc, "\261", 1, &state) == (size_t)(-2)
-          && wc != 0xBADFACE)
+          && wc != (wchar_t) {0xBADFACE})
         result |= 8;
     }
   return result;
@@ -602,12 +602,12 @@ int main ()
 {
   if (setlocale (LC_ALL, "$LOCALE_EN_UTF8") != NULL)
     {
-      wchar_t wc = 0xBADFACE;
+      wchar_t wc = (wchar_t) {0xBADFACE};
       mbstate_t state;
 
       memset (&state, '\0', sizeof (mbstate_t));
       if (mbrtowc (&wc, "\303", 1, &state) == (size_t)(-2)
-          && wc != 0xBADFACE)
+          && wc != (wchar_t) {0xBADFACE})
         return 1;
     }
   return 0;

diff --git a/m4/mbsnrtowcs.m4 b/m4/mbsnrtowcs.m4
index 1d62a7e2bda5b8ac9406c0d1d1dbbf6e76e5b10c..500964f8e492005f231a4fb376ea2d2a0c91854b 100644 (file)
--- a/m4/mbsnrtowcs.m4
+++ b/m4/mbsnrtowcs.m4
@@ -1,5 +1,5 @@
 # mbsnrtowcs.m4
-# serial 10
+# serial 11
 dnl Copyright (C) 2008, 2010-2026 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -94,18 +94,18 @@ int main ()
       {
         size_t i;
         for (i = 0; i < BUFSIZE; i++)
-          buf[i] = 0xBADFACE;
+          buf[i] = (wchar_t) {0xBADFACE};
       }
 
       memset (&state, '\0', sizeof (mbstate_t));
 
-      wc = 0xBADFACE;
+      wc = (wchar_t) {0xBADFACE};
       ret = mbrtowc (&wc, input, 1, &state);
       if (!(ret == 1 && wc == 'B' && mbsinit (&state)))
         return 1;
       input[0] = '\0';
 
-      wc = 0xBADFACE;
+      wc = (wchar_t) {0xBADFACE};
       ret = mbrtowc (&wc, input + 1, 1, &state);
       if (!(ret == 1 && wctob (wc) == (unsigned char) '\374' && mbsinit (&state)))
         return 2;

diff --git a/m4/wcrtomb.m4 b/m4/wcrtomb.m4
index 84620571f4fcd57df42936c92db7981b160f7076..47f89bf3078825ca6abf211b0af7127339a0f98a 100644 (file)
--- a/m4/wcrtomb.m4
+++ b/m4/wcrtomb.m4
@@ -1,5 +1,5 @@
 # wcrtomb.m4
-# serial 23
+# serial 24
 dnl Copyright (C) 2008-2026 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -113,7 +113,7 @@ int main ()
       if (wcrtomb (NULL, 0, NULL) != 1)
         result |= 2;
       {
-        wchar_t wc = 0xBADFACE;
+        wchar_t wc = (wchar_t) {0xBADFACE};
         if (mbtowc (&wc, "\303\274", 2) == 2)
           if (wcrtomb (NULL, wc, NULL) != 1)
             result |= 2;

diff --git a/tests/test-iswdigit.c b/tests/test-iswdigit.c
index df81839fd949547ce1997aab21f0d3d223c4274d..500b0d2f5da4e374982b78054495187e03c6b8bd 100644 (file)
--- 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 = 0xBADFACE;
+  wc = (wchar_t) {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 cc497794734d44d5b23e91eb839be1f43a283234..124664191c797020246da5c56b73119039c39553 100644 (file)
--- 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 = 0xBADFACE;
+  wc = (wchar_t) {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 85dcae7c9d4db82401af85c3e40a6e7fc1958632..7e2a0cb64d83a1b4971a81cca4f9113d7305a6c6 100644 (file)
--- 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 = 0xBADFACE;
+  wc = (wchar_t) {0xBADFACE};
   ret = mbrtowc (&wc, s, n, &state);
   if (ret == n)
     return iswxdigit (wc);

diff --git a/tests/test-mbrtowc-w32.c b/tests/test-mbrtowc-w32.c
index 776e1937b79541f1c119156350ba395dd318608f..f3d5d228421a7d95874639b55f19f6488903cac6 100644 (file)
--- 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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {0xBADFACE};
     ret = mbrtowc (&wc, NULL, 5, &state);
     ASSERT (ret == 0);
-    ASSERT (wc == 0xBADFACE);
+    ASSERT (wc == (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input, 1, &state);
         ASSERT (ret == 1);
         ASSERT (wc == 'B');
         ASSERT (mbsinit (&state));
         input[0] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input + 3, 2, &state);
         ASSERT (ret == 1);
         ASSERT (wc == 'e');
         ASSERT (mbsinit (&state));
         input[3] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input, 1, &state);
         ASSERT (ret == 1);
         ASSERT (wc == 'x');
         ASSERT (mbsinit (&state));
         input[0] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input, 1, &state);
         ASSERT (ret == 1);
         ASSERT (wc == 'B');
         ASSERT (mbsinit (&state));
         input[0] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input + 1, 1, &state);
         ASSERT (ret == (size_t)(-2));
-        ASSERT (wc == 0xBADFACE);
+        ASSERT (wc == (wchar_t) {0xBADFACE});
         ASSERT (!mbsinit (&state));
         input[1] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input + 5, 2, &state);
         ASSERT (ret == 1);
         ASSERT (wc == 'e');
         ASSERT (mbsinit (&state));
         input[5] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
         ASSERT (ret == (size_t)-1);
         ASSERT (errno == EILSEQ);
 
         memset (&state, '\0', sizeof (mbstate_t));
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input, 1, &state);
         ASSERT (ret == 1);
         ASSERT (wc == '<');
         ASSERT (mbsinit (&state));
         input[0] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input + 3, 1, &state);
         ASSERT (ret == (size_t)(-2));
-        ASSERT (wc == 0xBADFACE);
+        ASSERT (wc == (wchar_t) {0xBADFACE});
         ASSERT (!mbsinit (&state));
         input[3] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input, 1, &state);
         ASSERT (ret == 1);
         ASSERT (wc == '<');
         ASSERT (mbsinit (&state));
         input[0] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input + 3, 1, &state);
         ASSERT (ret == (size_t)(-2));
-        ASSERT (wc == 0xBADFACE);
+        ASSERT (wc == (wchar_t) {0xBADFACE});
         ASSERT (!mbsinit (&state));
         input[3] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input, 1, &state);
         ASSERT (ret == 1);
         ASSERT (wc == '<');
         ASSERT (mbsinit (&state));
         input[0] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input + 3, 1, &state);
         ASSERT (ret == (size_t)(-2));
-        ASSERT (wc == 0xBADFACE);
+        ASSERT (wc == (wchar_t) {0xBADFACE});
         ASSERT (!mbsinit (&state));
         input[3] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input, 1, &state);
         ASSERT (ret == 1);
         ASSERT (wc == 'B');
         ASSERT (mbsinit (&state));
         input[0] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input + 1, 1, &state);
         ASSERT (ret == (size_t)(-2));
-        ASSERT (wc == 0xBADFACE);
+        ASSERT (wc == (wchar_t) {0xBADFACE});
         ASSERT (!mbsinit (&state));
         input[1] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, input + 7, 2, &state);
         ASSERT (ret == 1);
         ASSERT (wc == 'e');
         ASSERT (mbsinit (&state));
         input[7] = '\0';
 
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {0xBADFACE};
         ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
         ASSERT (ret == (size_t)-1);
         ASSERT (errno == EILSEQ);
 
         memset (&state, '\0', sizeof (mbstate_t));
-        wc = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 = 0xBADFACE;
+        wc = (wchar_t) {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 d68bfa6512e3e021a045505d9918e32cce72166d..6f970aa0a42f7cb561b825702a649903e90eadf9 100644 (file)
--- 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 = 0xBADFACE;
+    wc = (wchar_t) {0xBADFACE};
     ret = mbrtowc (&wc, input, 1, &state);
     ASSERT (ret == 1);
     ASSERT (wc == 'B');
     ASSERT (mbsinit (&state));
     input[0] = '\0';
 
-    wc = 0xBADFACE;
+    wc = (wchar_t) {0xBADFACE};
     ret = mbrtowc (&wc, input + 1, 1, &state);
     ASSERT (ret == (size_t)(-2));
-    ASSERT (wc == 0xBADFACE);
+    ASSERT (wc == (wchar_t) {0xBADFACE});
     ASSERT (!mbsinit (&state));
     input[1] = '\0';
 
-    wc = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {0xBADFACE};
     ret = mbrtowc (&wc, input + 5, 2, &state);
     ASSERT (ret == 1);
     ASSERT (wc == 'e');
     ASSERT (mbsinit (&state));
     input[5] = '\0';
 
-    wc = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {0xBADFACE};
     ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
     ASSERT (ret == (size_t)-1);
     ASSERT (errno == EILSEQ);
 
     memset (&state, '\0', sizeof (mbstate_t));
-    wc = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {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 0851efbbba58903620563530df66f202450c981f..3b10e9daede96be828239090e6dc4ce58cd35088 100644 (file)
--- 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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+    wc = (wchar_t) {0xBADFACE};
     ret = mbrtowc (&wc, NULL, 5, &state);
     ASSERT (ret == 0);
-    ASSERT (wc == 0xBADFACE);
+    ASSERT (wc == (wchar_t) {0xBADFACE});
     ASSERT (mbsinit (&state));
   }
 
@@ -148,7 +148,7 @@ main (int argc, char *argv[])
                 /* We are testing all nonnull bytes.  */
                 buf[0] = c;
 
-                wc = 0xBADFACE;
+                wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {0xBADFACE};
           ret = mbrtowc (&wc, input, 1, &state);
           ASSERT (ret == 1);
           ASSERT (wc == 'B');
           ASSERT (mbsinit (&state));
           input[0] = '\0';
 
-          wc = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {0xBADFACE};
           ret = mbrtowc (&wc, input + 2, 3, &state);
           ASSERT (ret == 1);
           ASSERT (wctob (wc) == (unsigned char) '\337');
           ASSERT (mbsinit (&state));
           input[2] = '\0';
 
-          wc = 0xBADFACE;
+          wc = (wchar_t) {0xBADFACE};
           ret = mbrtowc (&wc, input + 3, 2, &state);
           ASSERT (ret == 1);
           ASSERT (wc == 'e');
           ASSERT (mbsinit (&state));
           input[3] = '\0';
 
-          wc = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {0xBADFACE};
           ret = mbrtowc (&wc, input, 1, &state);
           ASSERT (ret == 1);
           ASSERT (wc == 'B');
           ASSERT (mbsinit (&state));
           input[0] = '\0';
 
-          wc = 0xBADFACE;
+          wc = (wchar_t) {0xBADFACE};
           ret = mbrtowc (&wc, input + 1, 1, &state);
           ASSERT (ret == (size_t)(-2));
-          ASSERT (wc == 0xBADFACE);
+          ASSERT (wc == (wchar_t) {0xBADFACE});
           ASSERT (!mbsinit (&state));
           input[1] = '\0';
 
-          wc = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {0xBADFACE};
           ret = mbrtowc (&wc, input + 5, 2, &state);
           ASSERT (ret == 1);
           ASSERT (wc == 'e');
           ASSERT (mbsinit (&state));
           input[5] = '\0';
 
-          wc = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+            wc = (wchar_t) {0xBADFACE};
             ret = mbrtowc (&wc, "\360", 1, &state);
             ASSERT (ret == (size_t)(-2));
-            ASSERT (wc == 0xBADFACE);
+            ASSERT (wc == (wchar_t) {0xBADFACE});
             ASSERT (!mbsinit (&state));
 
-            wc = 0xBADFACE;
+            wc = (wchar_t) {0xBADFACE};
             ret = mbrtowc (&wc, "\237", 1, &state);
             ASSERT (ret == (size_t)(-2));
-            ASSERT (wc == 0xBADFACE);
+            ASSERT (wc == (wchar_t) {0xBADFACE});
             ASSERT (!mbsinit (&state));
 
-            wc = 0xBADFACE;
+            wc = (wchar_t) {0xBADFACE};
             ret = mbrtowc (&wc, "\220", 1, &state);
             ASSERT (ret == (size_t)(-2));
-            ASSERT (wc == 0xBADFACE);
+            ASSERT (wc == (wchar_t) {0xBADFACE});
             ASSERT (!mbsinit (&state));
 
-            wc = 0xBADFACE;
+            wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {0xBADFACE};
           ret = mbrtowc (&wc, input, 1, &state);
           ASSERT (ret == 1);
           ASSERT (wc == '<');
           ASSERT (mbsinit (&state));
           input[0] = '\0';
 
-          wc = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {0xBADFACE};
           ret = mbrtowc (&wc, input + 3, 1, &state);
           ASSERT (ret == (size_t)(-2));
-          ASSERT (wc == 0xBADFACE);
+          ASSERT (wc == (wchar_t) {0xBADFACE});
           ASSERT (!mbsinit (&state));
           input[3] = '\0';
 
-          wc = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {0xBADFACE};
           ret = mbrtowc (&wc, input, 1, &state);
           ASSERT (ret == 1);
           ASSERT (wc == 'B');
           ASSERT (mbsinit (&state));
           input[0] = '\0';
 
-          wc = 0xBADFACE;
+          wc = (wchar_t) {0xBADFACE};
           ret = mbrtowc (&wc, input + 1, 1, &state);
           ASSERT (ret == (size_t)(-2));
-          ASSERT (wc == 0xBADFACE);
+          ASSERT (wc == (wchar_t) {0xBADFACE});
           ASSERT (!mbsinit (&state));
           input[1] = '\0';
 
-          wc = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+          wc = (wchar_t) {0xBADFACE};
           ret = mbrtowc (&wc, input + 7, 2, &state);
           ASSERT (ret == 1);
           ASSERT (wc == 'e');
           ASSERT (mbsinit (&state));
           input[7] = '\0';
 
-          wc = 0xBADFACE;
+          wc = (wchar_t) {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 = 0xBADFACE;
+            wc = (wchar_t) {0xBADFACE};
             ret = mbrtowc (&wc, "\224", 1, &state);
             ASSERT (ret == (size_t)(-2));
-            ASSERT (wc == 0xBADFACE);
+            ASSERT (wc == (wchar_t) {0xBADFACE});
             ASSERT (!mbsinit (&state));
 
-            wc = 0xBADFACE;
+            wc = (wchar_t) {0xBADFACE};
             ret = mbrtowc (&wc, "\071", 1, &state);
             ASSERT (ret == (size_t)(-2));
-            ASSERT (wc == 0xBADFACE);
+            ASSERT (wc == (wchar_t) {0xBADFACE});
             ASSERT (!mbsinit (&state));
 
-            wc = 0xBADFACE;
+            wc = (wchar_t) {0xBADFACE};
             ret = mbrtowc (&wc, "\311", 1, &state);
             ASSERT (ret == (size_t)(-2));
-            ASSERT (wc == 0xBADFACE);
+            ASSERT (wc == (wchar_t) {0xBADFACE});
             ASSERT (!mbsinit (&state));
 
-            wc = 0xBADFACE;
+            wc = (wchar_t) {0xBADFACE};
             ret = mbrtowc (&wc, "\067", 1, &state);
             ASSERT (ret == 1);
             ASSERT (wctob (wc) == EOF);

diff --git a/tests/test-mbsnrtowcs.c b/tests/test-mbsnrtowcs.c
index a2a5262549afda98e705b77b9abc6acb4c449fe6..13974530cc297a2fd3aa2556f6eda28aee853911 100644 (file)
--- 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 = 0xBADFACE;
+    wc = (wchar_t) {0xBADFACE};
     src = "";
     ret = mbsnrtowcs (&wc, &src, 1, 0, &state);
     ASSERT (ret == 0);
-    ASSERT (wc == 0xBADFACE);
+    ASSERT (wc == (wchar_t) {0xBADFACE});
     ASSERT (mbsinit (&state));
 
-    wc = 0xBADFACE;
+    wc = (wchar_t) {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] = 0xBADFACE;
+            buf[i] = (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[4] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[1] == 0xBADFACE);
+                  ASSERT (buf[1] == (wchar_t) {0xBADFACE});
                 ASSERT (mbsinit (&state));
               }
               {
@@ -141,7 +141,7 @@ main (int argc, char *argv[])
                       ASSERT (src == input);
                       ASSERT (mbsinit (&state));
 
-                      buf[0] = buf[1] = 0xBADFACE;
+                      buf[0] = buf[1] = (wchar_t) {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 = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input, 1, &state);
                 ASSERT (ret == 1);
                 ASSERT (wc == 'B');
                 ASSERT (mbsinit (&state));
                 input[0] = '\0';
 
-                wc = 0xBADFACE;
+                wc = (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[4] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[1] == 0xBADFACE);
+                  ASSERT (buf[1] == (wchar_t) {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 = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input, 1, &state);
                 ASSERT (ret == 1);
                 ASSERT (wc == 'B');
                 ASSERT (mbsinit (&state));
                 input[0] = '\0';
 
-                wc = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input + 1, 1, &state);
                 ASSERT (ret == (size_t)(-2));
-                ASSERT (wc == 0xBADFACE);
+                ASSERT (wc == (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[5] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[2] == 0xBADFACE);
+                  ASSERT (buf[2] == (wchar_t) {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 = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input, 1, &state);
                 ASSERT (ret == 1);
                 ASSERT (wc == '<');
                 ASSERT (mbsinit (&state));
                 input[0] = '\0';
 
-                wc = 0xBADFACE;
+                wc = (wchar_t) {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 = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input + 3, 1, &state);
                 ASSERT (ret == (size_t)(-2));
-                ASSERT (wc == 0xBADFACE);
+                ASSERT (wc == (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[4] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[2] == 0xBADFACE);
+                  ASSERT (buf[2] == (wchar_t) {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 = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input, 1, &state);
                 ASSERT (ret == 1);
                 ASSERT (wc == 'B');
                 ASSERT (mbsinit (&state));
                 input[0] = '\0';
 
-                wc = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input + 1, 1, &state);
                 ASSERT (ret == (size_t)(-2));
-                ASSERT (wc == 0xBADFACE);
+                ASSERT (wc == (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[5] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[2] == 0xBADFACE);
+                  ASSERT (buf[2] == (wchar_t) {0xBADFACE});
                 ASSERT (mbsinit (&state));
               }
               break;

diff --git a/tests/test-mbsrtowcs.c b/tests/test-mbsrtowcs.c
index 84bf72ed434329c33995bca697f236ffa174e4ed..13aa7969a06dd4e7ec3edc80733b1c751ff8ca83 100644 (file)
--- 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 = 0xBADFACE;
+    wc = (wchar_t) {0xBADFACE};
     src = "";
     ret = mbsrtowcs (&wc, &src, 0, &state);
     ASSERT (ret == 0);
-    ASSERT (wc == 0xBADFACE);
+    ASSERT (wc == (wchar_t) {0xBADFACE});
     ASSERT (mbsinit (&state));
 
-    wc = 0xBADFACE;
+    wc = (wchar_t) {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] = 0xBADFACE;
+            buf[i] = (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[4] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[1] == 0xBADFACE);
+                  ASSERT (buf[1] == (wchar_t) {0xBADFACE});
                 ASSERT (mbsinit (&state));
               }
               {
@@ -141,7 +141,7 @@ main (int argc, char *argv[])
                       ASSERT (src == input);
                       ASSERT (mbsinit (&state));
 
-                      buf[0] = buf[1] = 0xBADFACE;
+                      buf[0] = buf[1] = (wchar_t) {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 = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input, 1, &state);
                 ASSERT (ret == 1);
                 ASSERT (wc == 'B');
                 ASSERT (mbsinit (&state));
                 input[0] = '\0';
 
-                wc = 0xBADFACE;
+                wc = (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[4] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[1] == 0xBADFACE);
+                  ASSERT (buf[1] == (wchar_t) {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 = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input, 1, &state);
                 ASSERT (ret == 1);
                 ASSERT (wc == 'B');
                 ASSERT (mbsinit (&state));
                 input[0] = '\0';
 
-                wc = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input + 1, 1, &state);
                 ASSERT (ret == (size_t)(-2));
-                ASSERT (wc == 0xBADFACE);
+                ASSERT (wc == (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[5] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[2] == 0xBADFACE);
+                  ASSERT (buf[2] == (wchar_t) {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 = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input, 1, &state);
                 ASSERT (ret == 1);
                 ASSERT (wc == '<');
                 ASSERT (mbsinit (&state));
                 input[0] = '\0';
 
-                wc = 0xBADFACE;
+                wc = (wchar_t) {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 = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input + 3, 1, &state);
                 ASSERT (ret == (size_t)(-2));
-                ASSERT (wc == 0xBADFACE);
+                ASSERT (wc == (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[4] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[2] == 0xBADFACE);
+                  ASSERT (buf[2] == (wchar_t) {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 = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input, 1, &state);
                 ASSERT (ret == 1);
                 ASSERT (wc == 'B');
                 ASSERT (mbsinit (&state));
                 input[0] = '\0';
 
-                wc = 0xBADFACE;
+                wc = (wchar_t) {0xBADFACE};
                 ret = mbrtowc (&wc, input + 1, 1, &state);
                 ASSERT (ret == (size_t)(-2));
-                ASSERT (wc == 0xBADFACE);
+                ASSERT (wc == (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[5] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[2] == 0xBADFACE);
+                  ASSERT (buf[2] == (wchar_t) {0xBADFACE});
                 ASSERT (mbsinit (&state));
               }
               break;

diff --git a/tests/test-mbstowcs.c b/tests/test-mbstowcs.c
index 21fbc51bea4addf9a6158897f47b283d11eaab4a..e6c2db48c834ec166e5ca997371744f3df381ed2 100644 (file)
--- 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 = 0xBADFACE;
+    wc = (wchar_t) {0xBADFACE};
     src = "";
     ret = mbstowcs (&wc, src, 0);
     ASSERT (ret == 0);
-    ASSERT (wc == 0xBADFACE);
+    ASSERT (wc == (wchar_t) {0xBADFACE});
 
-    wc = 0xBADFACE;
+    wc = (wchar_t) {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] = 0xBADFACE;
+            buf[i] = (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[4] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[1] == 0xBADFACE);
+                  ASSERT (buf[1] == (wchar_t) {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] = 0xBADFACE;
+                      buf[0] = buf[1] = (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[5] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[1] == 0xBADFACE);
+                  ASSERT (buf[1] == (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[5] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[2] == 0xBADFACE);
+                  ASSERT (buf[2] == (wchar_t) {0xBADFACE});
               }
               break;
 
@@ -212,10 +212,10 @@ main (int argc, char *argv[])
                   {
                     ASSERT (buf[3] == '>');
                     ASSERT (buf[4] == 0);
-                    ASSERT (buf[5] == 0xBADFACE);
+                    ASSERT (buf[5] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[3] == 0xBADFACE);
+                  ASSERT (buf[3] == (wchar_t) {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] == 0xBADFACE);
+                    ASSERT (buf[5] == (wchar_t) {0xBADFACE});
                   }
                 else
-                  ASSERT (buf[1] == 0xBADFACE);
+                  ASSERT (buf[1] == (wchar_t) {0xBADFACE});
               }
               break;
 

diff --git a/tests/test-snprintf-posix.h b/tests/test-snprintf-posix.h
index 074cd2595b793a3d7c61c61c420b4bed43e05c84..d7a3b4eda275fd2b31a2e3c0af0a51f71b5c100f 100644 (file)
--- a/tests/test-snprintf-posix.h
+++ b/tests/test-snprintf-posix.h
@@ -3162,7 +3162,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
     ASSERT (retval == 6);
   }
 
-  static wint_t L_invalid = 0x76543210;
+  const wint_t L_invalid = (wchar_t) {0x76543210};
 
   { /* Invalid wide character.
        The conversion may succeed or may fail, but it should not abort.  */

diff --git a/tests/test-sprintf-posix.h b/tests/test-sprintf-posix.h
index d82c2892b9df89138aa3d21d66fd6f9ce1b29be5..40d4be65c6dceb08decafd6cf0f489f05a5d47c7 100644 (file)
--- a/tests/test-sprintf-posix.h
+++ b/tests/test-sprintf-posix.h
@@ -3145,7 +3145,7 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     ASSERT (retval == 6);
   }
 
-  static wint_t L_invalid = 0x76543210;
+  const wint_t L_invalid = (wchar_t) {0x76543210};
 
   { /* Invalid wide character.
        The conversion may succeed or may fail, but it should not abort.  */

diff --git a/tests/test-towctrans.c b/tests/test-towctrans.c
index d05f63f71f1d06d460f9c1e55adad0f518c303f7..e36f74e293f820684ab94dcf3e114a41b4140508 100644 (file)
--- 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 (L'\0', desc) == 0);
+  ASSERT (towctrans ((wchar_t) {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 (L'\0', desc) == 0);
+  ASSERT (towctrans ((wchar_t) {0}, desc) == 0);
   ASSERT (towctrans (WEOF, desc) == WEOF);
 
   return test_exit_status;

diff --git a/tests/test-vasnprintf-posix.c b/tests/test-vasnprintf-posix.c
index 5df21c38a68037bd49f2c5233919290b49420ab0..fe0a59d647af95579affe92ed5cd6990bda6165b 100644 (file)
--- 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[] = { 1702057263, 114, 0 };
+    const wchar_t input[] = { (wchar_t) {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[] = { 1702057263, 114, 0 };
+    const wchar_t input[] = { (wchar_t) {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[] = { 1702057263, 114, 0 };
+    const wchar_t input[] = { (wchar_t) {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[] = { 1702057263, 114, 0 };
+    const wchar_t input[] = { (wchar_t) {1702057263}, 114, 0 };
     size_t length;
     char *result = my_asnprintf (NULL, &length, "%3.1ls %d", input, 99);
     if (result == NULL)
@@ -4117,7 +4117,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
     free (result);
   }
 
-  static wint_t L_invalid = 0x76543210;
+  const wint_t L_invalid = (wchar_t) {0x76543210};
 
   { /* Invalid wide character.
        The conversion may succeed or may fail, but it should not abort.  */

diff --git a/tests/test-vasnwprintf-posix.c b/tests/test-vasnwprintf-posix.c
index fcd385b2c475ee59362596515dddb8b931022e86..d1b3d6e0bbcddd784476692760a879ab7dbc0e9a 100644 (file)
--- 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[] = { 1702057263, 114, 0 };
+    const wchar_t input[] = { (wchar_t) {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[] = { 1702057263, 114, 0 };
+    const wchar_t input[] = { (wchar_t) {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[] = { 1702057263, 114, 0 };
+    const wchar_t input[] = { (wchar_t) {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[] = { 1702057263, 114, 0 };
+    const wchar_t input[] = { (wchar_t) {1702057263}, 114, 0 };
     size_t length;
     wchar_t *result = my_asnwprintf (NULL, &length, L"%3.1ls %d", input, 99);
     if (result == NULL)
@@ -4162,7 +4162,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
     free (result);
   }
 
-  static wint_t L_invalid = 0x76543210;
+  const wint_t L_invalid = (wchar_t) {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] == 0x76543210);
+    ASSERT (result[0] == (wchar_t) {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] == 0x76543210);
+    ASSERT (result[9] == (wchar_t) {0x76543210});
     ASSERT (wmemcmp (result + 10, L" 33\0", 3 + 1) == 0);
     ASSERT (length == 13);
     free (result);

diff --git a/tests/test-vasprintf-posix.c b/tests/test-vasprintf-posix.c
index 4ca2654167aba163cd95abac47696331e911aa70..6d62468ccee8155e64ddb5f3b0f5f393956ae8ae 100644 (file)
--- a/tests/test-vasprintf-posix.c
+++ b/tests/test-vasprintf-posix.c
@@ -4057,7 +4057,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
     free (result);
   }
 
-  static wint_t L_invalid = 0x76543210;
+  const wint_t L_invalid = (wchar_t) {0x76543210};
 
   { /* Invalid wide character.
        The conversion may succeed or may fail, but it should not abort.  */

diff --git a/tests/test-wcrtomb.c b/tests/test-wcrtomb.c
index ff347b9f1fa3f14c0cd7e9da8754d732a277a1df..7fea9cb914a26aff16776bfcbfebc6def3a09514 100644 (file)
--- 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 = 0xBADFACE;
+  wc = (wchar_t) {0xBADFACE};
   iret = mbtowc (&wc, s, n);
   ASSERT (iret == n);
 

diff --git a/tests/test-wcscmp.c b/tests/test-wcscmp.c
index 3512b1466221b2ab5a7ae360498de20b31185701..a40821614ab037a6370bb726cf547f27c2979a48 100644 (file)
--- a/tests/test-wcscmp.c
+++ b/tests/test-wcscmp.c
@@ -70,8 +70,8 @@ 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[] = { 0x76547654, 0 };
-    static const wchar_t input2[] = { 0x9abc9abc, 0 };
+    const wchar_t input1[] = { (wchar_t) {0x76547654}, 0 };
+    const wchar_t input2[] = { (wchar_t) {0x9abc9abc}, 0 };
     if ((wchar_t) {-1} < 0)
       {
         /* wchar_t is signed.  */
@@ -86,8 +86,8 @@ main (int argc, char *argv[])
       }
   }
   {
-    static const wchar_t input1[] = { (wchar_t) 0x9abc9abc, 0 };
-    static const wchar_t input2[] = { (wchar_t) 0x9bdf9bdf, 0 };
+    const wchar_t input1[] = { (wchar_t) {0x9abc9abc}, 0 };
+    const wchar_t input2[] = { (wchar_t) {0x9bdf9bdf}, 0 };
     ASSERT (wcscmp (input1, input2) < 0);
     ASSERT (wcscmp (input2, input1) > 0);
   }
@@ -102,8 +102,8 @@ 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[] = { L'x', 0 };
-    static const wchar_t input2[] = { L'x', 0x9abc9abc, 0 };
+    const wchar_t input1[] = { (wchar_t) {'x'}, 0 };
+    const wchar_t input2[] = { (wchar_t) {'x'}, (wchar_t) {0x9abc9abc}, 0 };
     if ((wchar_t) {-1} < 0)
       {
         /* wchar_t is signed.  */

diff --git a/tests/test-wcsncmp.c b/tests/test-wcsncmp.c
index cc41aed8c25ed0f629fcdc08d8306ee90167375c..c43ce8273cf5d8aefa26478e083a96ffb1bd3324 100644 (file)
--- a/tests/test-wcsncmp.c
+++ b/tests/test-wcsncmp.c
@@ -118,8 +118,8 @@ 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[] = { 0x76547654, 0 };
-    static const wchar_t input2[] = { 0x9abc9abc, 0 };
+    const wchar_t input1[] = { (wchar_t) {0x76547654}, 0 };
+    const wchar_t input2[] = { (wchar_t) {0x9abc9abc}, 0 };
     ASSERT (wcsncmp (input1, input2, 0) == 0);
     if ((wchar_t) {-1} < 0)
       {
@@ -143,8 +143,8 @@ main (int argc, char *argv[])
       }
   }
   {
-    static const wchar_t input1[] = { (wchar_t) 0x9abc9abc, 0 };
-    static const wchar_t input2[] = { (wchar_t) 0x9bdf9bdf, 0 };
+    const wchar_t input1[] = { (wchar_t) {0x9abc9abc}, 0 };
+    const wchar_t input2[] = { (wchar_t) {0x9bdf9bdf}, 0 };
     ASSERT (wcsncmp (input1, input2, 0) == 0);
     ASSERT (wcsncmp (input1, input2, 1) < 0);
     ASSERT (wcsncmp (input2, input1, 1) > 0);
@@ -164,8 +164,8 @@ 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[] = { L'x', 0 };
-    static const wchar_t input2[] = { L'x', 0x9abc9abc, 0 };
+    const wchar_t input1[] = { (wchar_t) {'x'}, 0 };
+    const wchar_t input2[] = { (wchar_t) {'x'}, (wchar_t) {0x9abc9abc}, 0 };
     ASSERT (wcsncmp (input1, input2, 0) == 0);
     ASSERT (wcsncmp (input1, input2, 1) == 0);
     if ((wchar_t) {-1} < 0)

diff --git a/tests/test-wmemcmp.c b/tests/test-wmemcmp.c
index 5c969ef1ac6da91c764e423ccc8b8c742fcfc5f6..6b7564659d544d8c01c047163097311d6bf4f224 100644 (file)
--- a/tests/test-wmemcmp.c
+++ b/tests/test-wmemcmp.c
@@ -80,8 +80,8 @@ 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[] = { 0x76547654 };
-    static const wchar_t input2[] = { 0x9abc9abc };
+    const wchar_t input1[] = { (wchar_t) {0x76547654} };
+    const wchar_t input2[] = { (wchar_t) {0x9abc9abc} };
     if ((wchar_t) {-1} < 0)
       {
         /* wchar_t is signed.  */
@@ -96,8 +96,8 @@ main (int argc, char *argv[])
       }
   }
   {
-    static const wchar_t input1[] = { (wchar_t) 0x9abc9abc };
-    static const wchar_t input2[] = { (wchar_t) 0x9bdf9bdf };
+    const wchar_t input1[] = { (wchar_t) {0x9abc9abc} };
+    const wchar_t input2[] = { (wchar_t) {0x9bdf9bdf} };
     ASSERT (wmemcmp (input1, input2, 1) < 0);
     ASSERT (wmemcmp (input2, input1, 1) > 0);
   }