upstream-mirrors/gnulib
1
0
Fork 0
mirror of https://https.git.savannah.gnu.org/git/gnulib.git synced 2026-05-13 15:13:36 +00:00
Code Activity

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

Browse Source 
* 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.
This commit is contained in:
Bruno Haible
2026-05-10 23:13:57 +02:00
parent b4a2984be9
commit 8ee4c7ca41
27 changed files with 304 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
ChangeLog
View File

@@ -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.

6
m4/c32rtomb.m4
View File

@@ -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)

4
m4/iswdigit.m4
View File

@@ -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 ();

4
m4/iswxdigit.m4
View File

@@ -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 ();

10
m4/mbrtoc32.m4
View File

@@ -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;

24
m4/mbrtowc.m4
View File

@@ -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;

8
m4/mbsnrtowcs.m4
View File

@@ -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;

4
m4/wcrtomb.m4
View File

@@ -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;

2
tests/test-iswdigit.c
View File

@@ -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);

2
tests/test-iswpunct.c
View File

@@ -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);

2
tests/test-iswxdigit.c
View File

@@ -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);

144
tests/test-mbrtowc-w32.c
View File

@@ -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);

34
tests/test-mbrtowc-w32utf8.c
View File

@@ -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);

92
tests/test-mbrtowc.c
View File

@@ -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);

54
tests/test-mbsnrtowcs.c
View File

@@ -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;

54
tests/test-mbsrtowcs.c
View File

@@ -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;

30
tests/test-mbstowcs.c
View File

@@ -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;

2
tests/test-snprintf-posix.h
View File

@@ -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. */

2
tests/test-sprintf-posix.h
View File

@@ -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. */

4
tests/test-towctrans.c
View File

@@ -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;

10
tests/test-vasnprintf-posix.c
View File

@@ -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. */

14
tests/test-vasnwprintf-posix.c
View File

@@ -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);

2
tests/test-vasprintf-posix.c
View File

@@ -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. */

2
tests/test-wcrtomb.c
View File

@@ -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);

12
tests/test-wcscmp.c
View File

@@ -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. */

12
tests/test-wcsncmp.c
View File

@@ -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)

8
tests/test-wmemcmp.c
View File

@@ -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);
}