lib/gnulib
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/gnulib.git synced 2026-10-24 00:48:56 +03:00
Code Activity

Pacify -Wuseless-cast via compound literals in tests

Browse Source 
* tests/from-glibc/tst-stdbit.h (TEST_STDBIT_T):
* tests/jit/test-cache.c, tests/test-boot-time.c:
* tests/test-ceilf2.c, tests/test-fflush.c, tests/test-floorf2.c:
* tests/test-mbrtoc32-regular.c, tests/test-mbrtoc32.c:
* tests/test-mbrtowc-w32utf8.c, tests/test-mbrtowc.c:
* tests/test-mbsnrtoc32s.c, tests/test-mbsnrtowcs.c:
* tests/test-mbsrtoc32s.c, tests/test-mbsrtowcs.c:
* tests/test-mbstoc32s.c, tests/test-mbstowcs.c:
* tests/test-sameacls.c, tests/test-towctrans.c:
* tests/test-truncf2.c, tests/test-wcscmp.c, tests/test-wcsncmp.c:
* tests/test-wmemcmp.c:
(main)
* tests/test-c32isalnum.c, tests/test-c32isalpha.c:
* tests/test-c32isblank.c, tests/test-c32iscntrl.c:
* tests/test-c32isdigit.c, tests/test-c32isgraph.c:
* tests/test-c32islower.c, tests/test-c32isprint.c:
* tests/test-c32ispunct.c, tests/test-c32isspace.c:
* tests/test-c32isupper.c, tests/test-c32isxdigit.c:
* tests/test-c32tolower.c, tests/test-c32toupper.c:
* tests/test-iswdigit.c, tests/test-iswpunct.c, tests/test-iswxdigit.c:
(for_character):
* tests/test-c32rtomb.c, tests/test-wcrtomb.c:
(check_character):
* tests/test-mbrtoc32-w32.c, tests/test-mbrtowc-w32.c:
(test_one_locale):
* tests/test-snprintf-posix.h, tests/test-sprintf-posix.h:
* tests/test-vasnprintf-posix.c, tests/test-vasnwprintf-posix.c:
* tests/test-vasprintf-posix.c:
(test_function):
* tests/test-stat-time.c (initialize_filenames):
* tests/uniwidth/test-uc_width2.c (finish_interval):
Use compound literal when it is safer than a cast and it pacifies
-Wuseless-cast.  Also, omit unnecessary casts to a type when the
context is already that type and omitting pacifies -Wuseless-cast.
This commit is contained in:
Paul Eggert
2026-05-08 12:48:04 -07:00
parent 7e6f301b8e
commit 33cc6fca55
51 changed files with 821 additions and 783 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
ChangeLog
View File

@@ -1,5 +1,41 @@
2026-05-08 Paul Eggert <eggert@cs.ucla.edu>
Pacify -Wuseless-cast via compound literals in tests
* tests/from-glibc/tst-stdbit.h (TEST_STDBIT_T):
* tests/jit/test-cache.c, tests/test-boot-time.c:
* tests/test-ceilf2.c, tests/test-fflush.c, tests/test-floorf2.c:
* tests/test-mbrtoc32-regular.c, tests/test-mbrtoc32.c:
* tests/test-mbrtowc-w32utf8.c, tests/test-mbrtowc.c:
* tests/test-mbsnrtoc32s.c, tests/test-mbsnrtowcs.c:
* tests/test-mbsrtoc32s.c, tests/test-mbsrtowcs.c:
* tests/test-mbstoc32s.c, tests/test-mbstowcs.c:
* tests/test-sameacls.c, tests/test-towctrans.c:
* tests/test-truncf2.c, tests/test-wcscmp.c, tests/test-wcsncmp.c:
* tests/test-wmemcmp.c:
(main)
* tests/test-c32isalnum.c, tests/test-c32isalpha.c:
* tests/test-c32isblank.c, tests/test-c32iscntrl.c:
* tests/test-c32isdigit.c, tests/test-c32isgraph.c:
* tests/test-c32islower.c, tests/test-c32isprint.c:
* tests/test-c32ispunct.c, tests/test-c32isspace.c:
* tests/test-c32isupper.c, tests/test-c32isxdigit.c:
* tests/test-c32tolower.c, tests/test-c32toupper.c:
* tests/test-iswdigit.c, tests/test-iswpunct.c, tests/test-iswxdigit.c:
(for_character):
* tests/test-c32rtomb.c, tests/test-wcrtomb.c:
(check_character):
* tests/test-mbrtoc32-w32.c, tests/test-mbrtowc-w32.c:
(test_one_locale):
* tests/test-snprintf-posix.h, tests/test-sprintf-posix.h:
* tests/test-vasnprintf-posix.c, tests/test-vasnwprintf-posix.c:
* tests/test-vasprintf-posix.c:
(test_function):
* tests/test-stat-time.c (initialize_filenames):
* tests/uniwidth/test-uc_width2.c (finish_interval):
Use compound literal when it is safer than a cast and it pacifies
-Wuseless-cast. Also, omit unnecessary casts to a type when the
context is already that type and omitting pacifies -Wuseless-cast.
Pacify -Wuseless-cast via compound literals in lib
* lib/bitset.c (bitset_print):
* lib/bitset/list.c (LBITSET_ELT_BITS, debug_lbitset):

40
tests/from-glibc/tst-stdbit.h
View File

@@ -85,36 +85,36 @@ struct stdbit_test
TEST_TYPE (FUNC ## SUFFIX (X), TTYPE); \
TEST_COMPARE ((FUNC ## SUFFIX) (X), (RES)); \
TEST_TYPE ((FUNC ## SUFFIX) (X), TTYPE); \
TEST_COMPARE (FUNC ## SUFFIX ((TYPE) (X)), (RES)); \
TEST_TYPE (FUNC ## SUFFIX ((TYPE) (X)), TTYPE); \
TEST_COMPARE ((FUNC ## SUFFIX) ((TYPE) (X)), (RES)); \
TEST_TYPE ((FUNC ## SUFFIX) ((TYPE) (X)), TTYPE); \
TEST_COMPARE (FUNC ((TYPE) (X)), (RES)); \
TEST_TYPE (FUNC ((TYPE) (X)), TTYPE); \
TEST_COMPARE (FUNC ## SUFFIX ((TYPE) {(X)}), (RES)); \
TEST_TYPE (FUNC ## SUFFIX ((TYPE) {(X)}), TTYPE); \
TEST_COMPARE ((FUNC ## SUFFIX) ((TYPE) {(X)}), (RES)); \
TEST_TYPE ((FUNC ## SUFFIX) ((TYPE) {(X)}), TTYPE); \
TEST_COMPARE (FUNC ((TYPE) {(X)}), (RES)); \
TEST_TYPE (FUNC ((TYPE) {(X)}), TTYPE); \
if (sizeof (TYPE) <= 2) \
{ \
TEST_COMPARE (FUNC ## SUFFIX ((float) (TYPE) (X)), (RES)); \
TEST_TYPE (FUNC ## SUFFIX ((float) (TYPE) (X)), TTYPE); \
TEST_COMPARE ((FUNC ## SUFFIX) ((float) (TYPE) (X)), (RES)); \
TEST_TYPE ((FUNC ## SUFFIX) ((float) (TYPE) (X)), TTYPE); \
TEST_COMPARE (FUNC ## SUFFIX ((float) (TYPE) {(X)}), (RES)); \
TEST_TYPE (FUNC ## SUFFIX ((float) (TYPE) {(X)}), TTYPE); \
TEST_COMPARE ((FUNC ## SUFFIX) ((float) (TYPE) {(X)}), (RES)); \
TEST_TYPE ((FUNC ## SUFFIX) ((float) (TYPE) {(X)}), TTYPE); \
} \
if (sizeof (TYPE) <= 4) \
{ \
TEST_COMPARE (FUNC ## SUFFIX ((double) (TYPE) (X)), (RES)); \
TEST_TYPE (FUNC ## SUFFIX ((double) (TYPE) (X)), TTYPE); \
TEST_COMPARE ((FUNC ## SUFFIX) ((double) (TYPE) (X)), (RES)); \
TEST_TYPE ((FUNC ## SUFFIX) ((double) (TYPE) (X)), TTYPE); \
TEST_COMPARE (FUNC ## SUFFIX ((long double) (TYPE) (X)), (RES)); \
TEST_TYPE (FUNC ## SUFFIX ((long double) (TYPE) (X)), TTYPE); \
TEST_COMPARE ((FUNC ## SUFFIX) ((long double) (TYPE) (X)), (RES)); \
TEST_TYPE ((FUNC ## SUFFIX) ((long double) (TYPE) (X)), TTYPE); \
TEST_COMPARE (FUNC ## SUFFIX ((double) (TYPE) {(X)}), (RES)); \
TEST_TYPE (FUNC ## SUFFIX ((double) (TYPE) {(X)}), TTYPE); \
TEST_COMPARE ((FUNC ## SUFFIX) ((double) (TYPE) {(X)}), (RES)); \
TEST_TYPE ((FUNC ## SUFFIX) ((double) (TYPE) {(X)}), TTYPE); \
TEST_COMPARE (FUNC ## SUFFIX ((long double) (TYPE) {(X)}), (RES)); \
TEST_TYPE (FUNC ## SUFFIX ((long double) (TYPE) {(X)}), TTYPE); \
TEST_COMPARE ((FUNC ## SUFFIX) ((long double) (TYPE) {(X)}), (RES));\
TEST_TYPE ((FUNC ## SUFFIX) ((long double) (TYPE) {(X)}), TTYPE); \
} \
TYPE xt = (X); \
TEST_COMPARE (FUNC ## SUFFIX (xt++), (RES)); \
TEST_COMPARE (xt, (TYPE) ((X) + 1)); \
TEST_COMPARE (xt, (TYPE) {(X) + 1}); \
xt = (X); \
TEST_COMPARE (FUNC (xt++), (RES)); \
TEST_COMPARE (xt, (TYPE) ((X) + 1)); \
TEST_COMPARE (xt, (TYPE) {(X) + 1}); \
} \
while (0)

3
tests/jit/test-cache.c
View File

@@ -318,7 +318,8 @@ main ()
char filename[100];
sprintf (filename,
"%s/gnulib-test-cache-%u-%d-%ld",
"/tmp", (unsigned int) getuid (), (int) getpid (), random ());
"/tmp", (unsigned int) {getuid ()}, (int) {getpid ()},
random ());
# ifdef KEEP_TEMP_FILE_VISIBLE
if (register_temporary_file (filename) < 0)
return 2;

2
tests/test-boot-time.c
View File

@@ -39,7 +39,7 @@ main (int argc, char *argv[])
char timbuf[100];
ASSERT (strftime (timbuf, sizeof (timbuf), "%Y-%m-%d %H:%M:%S", gmt) > 0);
printf ("Boot time (UTC): %s.%09ld\n", timbuf, (long) boot_time.tv_nsec);
printf ("Boot time (UTC): %s.%09ld\n", timbuf, (long) {boot_time.tv_nsec});
/* If the boot time is more than 5 years in the past or more than a week
in the future, the value must be wrong.

2
tests/test-c32isalnum.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32isalpha.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32isblank.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32iscntrl.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32isdigit.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32isgraph.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32islower.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32isprint.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32ispunct.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32isspace.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32isupper.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32isxdigit.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 = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32rtomb.c
View File

@@ -40,7 +40,7 @@ check_character (const char *s, size_t n)
size_t ret;
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
iret = mbrtoc32 (&wc, s, n, &state);
ASSERT (iret == n);

2
tests/test-c32tolower.c
View File

@@ -47,7 +47,7 @@ for_character (const char *s, size_t n)
struct multibyte result;
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

2
tests/test-c32toupper.c
View File

@@ -47,7 +47,7 @@ for_character (const char *s, size_t n)
struct multibyte result;
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);

4
tests/test-ceilf2.c
View File

@@ -160,8 +160,8 @@ main ()
/* Combine highbits and lowbits into a floating-point number,
sign-extending the lowbits to 32-NUM_HIGHBITS bits. */
union { float f; uint32_t i; } janus;
janus.i = ((uint32_t) highbits << (32 - NUM_HIGHBITS))
| ((uint32_t) ((int32_t) ((uint32_t) lowbits << (32 - NUM_LOWBITS))
janus.i = ((uint32_t) {highbits} << (32 - NUM_HIGHBITS))
| ((uint32_t) ((int32_t) ((uint32_t) {lowbits} << (32 - NUM_LOWBITS))
>> (32 - NUM_LOWBITS - NUM_HIGHBITS))
>> NUM_HIGHBITS);
error |= check (janus.f);

8
tests/test-fflush.c
View File

@@ -82,7 +82,7 @@ main (void)
if (lseek (fd, 0, SEEK_CUR) != 5)
{
fprintf (stderr, "File offset is wrong after fseek: %ld.\n",
(long) lseek (fd, 0, SEEK_CUR));
(long) {lseek (fd, 0, SEEK_CUR)});
fclose (f);
unlink ("test-fflush.txt");
return 1;
@@ -90,7 +90,7 @@ main (void)
if (ftell (f) != 5)
{
fprintf (stderr, "ftell result is wrong after fseek: %ld.\n",
(long) ftell (f));
ftell (f));
fclose (f);
unlink ("test-fflush.txt");
return 1;
@@ -123,7 +123,7 @@ main (void)
if (lseek (fd, 0, SEEK_CUR) != 6)
{
fprintf (stderr, "File offset is wrong after fseeko: %ld.\n",
(long) lseek (fd, 0, SEEK_CUR));
(long) {lseek (fd, 0, SEEK_CUR)});
fclose (f);
unlink ("test-fflush.txt");
return 1;
@@ -131,7 +131,7 @@ main (void)
if (ftell (f) != 6)
{
fprintf (stderr, "ftell result is wrong after fseeko: %ld.\n",
(long) ftell (f));
ftell (f));
fclose (f);
unlink ("test-fflush.txt");
return 1;

4
tests/test-floorf2.c
View File

@@ -156,8 +156,8 @@ main ()
/* Combine highbits and lowbits into a floating-point number,
sign-extending the lowbits to 32-NUM_HIGHBITS bits. */
union { float f; uint32_t i; } janus;
janus.i = ((uint32_t) highbits << (32 - NUM_HIGHBITS))
| ((uint32_t) ((int32_t) ((uint32_t) lowbits << (32 - NUM_LOWBITS))
janus.i = ((uint32_t) {highbits} << (32 - NUM_HIGHBITS))
| ((uint32_t) ((int32_t) ((uint32_t) {lowbits} << (32 - NUM_LOWBITS))
>> (32 - NUM_LOWBITS - NUM_HIGHBITS))
>> NUM_HIGHBITS);
error |= check (janus.f);

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 = (wchar_t) 0xBADFACE;
wc = 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 = (wchar_t) 0xBADFACE;
wc = 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 = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, s, n, &state);
if (ret == n)
return iswxdigit (wc);

2
tests/test-mbrtoc32-regular.c
View File

@@ -56,7 +56,7 @@ main (int argc, char *argv[])
See <https://sourceware.org/PR30611>. */
mbstate_t state;
memset (&state, '\0', sizeof (mbstate_t));
char32_t c32 = (char32_t) 0xBADFACE;
char32_t c32 = 0xBADFACE;
size_t ret = mbrtoc32 (&c32, "\210\142", 2, &state);
/* It is OK if this conversion fails. */
if (ret != (size_t)(-1))

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

@@ -89,7 +89,7 @@ test_one_locale (const char *name, int codepage)
/* Test zero-length input. */
{
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "x", 0, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (mbsinit (&state));
@@ -98,7 +98,7 @@ test_one_locale (const char *name, int codepage)
/* Test NUL byte input. */
{
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "", 1, &state);
ASSERT (ret == 0);
ASSERT (wc == 0);
@@ -139,7 +139,7 @@ test_one_locale (const char *name, int codepage)
case 'z': case '{': case '|': case '}': case '~':
/* c is in the ISO C "basic character set". */
buf[0] = c;
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, buf, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == c);
@@ -154,10 +154,10 @@ test_one_locale (const char *name, int codepage)
/* Test special calling convention, passing a NULL pointer. */
{
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, NULL, 5, &state);
ASSERT (ret == 0);
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (mbsinit (&state));
}
@@ -169,14 +169,14 @@ test_one_locale (const char *name, int codepage)
char input[] = "B\374\337er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == (unsigned char) '\374');
@@ -189,7 +189,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 1);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 2, 3, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == (unsigned char) '\337');
@@ -197,14 +197,14 @@ test_one_locale (const char *name, int codepage)
ASSERT (mbsinit (&state));
input[2] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 2, &state);
ASSERT (ret == 1);
ASSERT (wc == 'e');
ASSERT (mbsinit (&state));
input[3] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 4, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'r');
@@ -218,14 +218,14 @@ test_one_locale (const char *name, int codepage)
char input[] = "x\302\341\346y"; /* "xآلوy" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'x');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == (unsigned char) '\302');
@@ -238,7 +238,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 1);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 2, 3, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == (unsigned char) '\341');
@@ -246,7 +246,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (mbsinit (&state));
input[2] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 2, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == (unsigned char) '\346');
@@ -254,7 +254,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (mbsinit (&state));
input[3] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 4, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'y');
@@ -270,21 +270,21 @@ test_one_locale (const char *name, int codepage)
char input[] = "s\303\274\303\237\360\237\230\213!"; /* "süß😋!" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 's');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 2, 7, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == EOF);
@@ -297,7 +297,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 6, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -311,7 +311,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 4);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 5, 4, &state);
ASSERT (ret == 4);
ASSERT (c32tob (wc) == EOF);
@@ -322,7 +322,7 @@ test_one_locale (const char *name, int codepage)
input[7] = '\0';
input[8] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 9, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '!');
@@ -330,61 +330,61 @@ test_one_locale (const char *name, int codepage)
/* Test some invalid input. */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\377", 1, &state); /* 0xFF */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\303\300", 2, &state); /* 0xC3 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\343\300", 2, &state); /* 0xE3 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\343\300\200", 3, &state); /* 0xE3 0xC0 0x80 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\343\200\300", 3, &state); /* 0xE3 0x80 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\363\300", 2, &state); /* 0xF3 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\363\300\200\200", 4, &state); /* 0xF3 0xC0 0x80 0x80 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\363\200\300", 3, &state); /* 0xF3 0x80 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\363\200\300\200", 4, &state); /* 0xF3 0x80 0xC0 0x80 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\363\200\200\300", 4, &state); /* 0xF3 0x80 0x80 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
@@ -397,14 +397,14 @@ test_one_locale (const char *name, int codepage)
char input[] = "<\223\372\226\173\214\352>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -413,14 +413,14 @@ test_one_locale (const char *name, int codepage)
input[1] = '\0';
input[2] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 4, 4, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == EOF);
@@ -433,7 +433,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 5, 3, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -442,7 +442,7 @@ test_one_locale (const char *name, int codepage)
input[5] = '\0';
input[6] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
@@ -450,12 +450,12 @@ test_one_locale (const char *name, int codepage)
/* Test some invalid input. */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\377", 1, &state); /* 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == 0x30FB));
}
@@ -467,14 +467,14 @@ test_one_locale (const char *name, int codepage)
char input[] = "<\244\351\245\273\273\171>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -483,14 +483,14 @@ test_one_locale (const char *name, int codepage)
input[1] = '\0';
input[2] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 4, 4, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == EOF);
@@ -503,7 +503,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 5, 3, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -512,7 +512,7 @@ test_one_locale (const char *name, int codepage)
input[5] = '\0';
input[6] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
@@ -520,12 +520,12 @@ test_one_locale (const char *name, int codepage)
/* Test some invalid input. */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\377", 1, &state); /* 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == '?'));
}
@@ -537,14 +537,14 @@ test_one_locale (const char *name, int codepage)
char input[] = "<\310\325\261\276\325\132>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -553,14 +553,14 @@ test_one_locale (const char *name, int codepage)
input[1] = '\0';
input[2] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 4, 4, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == EOF);
@@ -573,7 +573,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 5, 3, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -582,7 +582,7 @@ test_one_locale (const char *name, int codepage)
input[5] = '\0';
input[6] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
@@ -590,12 +590,12 @@ test_one_locale (const char *name, int codepage)
/* Test some invalid input. */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\377", 1, &state); /* 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == '?'));
}
@@ -609,21 +609,21 @@ test_one_locale (const char *name, int codepage)
char input[] = "s\250\271\201\060\211\070\224\071\375\067!"; /* "süß😋!" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 's');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 2, 9, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == EOF);
@@ -636,7 +636,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 4);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 8, &state);
ASSERT (ret == 4);
ASSERT (c32tob (wc) == EOF);
@@ -652,7 +652,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 4);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 7, 4, &state);
ASSERT (ret == 4);
ASSERT (c32tob (wc) == EOF);
@@ -663,7 +663,7 @@ test_one_locale (const char *name, int codepage)
input[9] = '\0';
input[10] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 11, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '!');
@@ -671,37 +671,37 @@ test_one_locale (const char *name, int codepage)
/* Test some invalid input. */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\377", 1, &state); /* 0xFF */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\201\045", 2, &state); /* 0x81 0x25 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\201\060\377", 3, &state); /* 0x81 0x30 0xFF */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\201\060\377\064", 4, &state); /* 0x81 0x30 0xFF 0x34 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\201\060\211\072", 4, &state); /* 0x81 0x30 0x89 0x3A */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);

92
tests/test-mbrtoc32.c
View File

@@ -46,7 +46,7 @@ main (int argc, char *argv[])
/* Test zero-length input. */
{
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "x", 0, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (mbsinit (&state));
@@ -55,7 +55,7 @@ main (int argc, char *argv[])
/* Test NUL byte input. */
{
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "", 1, &state);
ASSERT (ret == 0);
ASSERT (wc == 0);
@@ -99,7 +99,7 @@ main (int argc, char *argv[])
/* c is an ASCII character. */
buf[0] = c;
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, buf, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == c);
@@ -118,10 +118,10 @@ main (int argc, char *argv[])
/* Test special calling convention, passing a NULL pointer. */
{
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, NULL, 5, &state);
ASSERT (ret == 0);
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (mbsinit (&state));
}
@@ -149,7 +149,7 @@ main (int argc, char *argv[])
/* We are testing all nonnull bytes. */
buf[0] = c;
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, buf, 1, &state);
/* POSIX:2018 says regarding mbrtowc: "In the POSIX locale an
[EILSEQ] error cannot occur since all byte values are valid
@@ -178,14 +178,14 @@ main (int argc, char *argv[])
char input[] = "B\374\337er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == (unsigned char) '\374');
@@ -200,7 +200,7 @@ main (int argc, char *argv[])
ASSERT (ret == 1);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 2, 3, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == (unsigned char) '\337');
@@ -210,14 +210,14 @@ main (int argc, char *argv[])
ASSERT (mbsinit (&state));
input[2] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 2, &state);
ASSERT (ret == 1);
ASSERT (wc == 'e');
ASSERT (mbsinit (&state));
input[3] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 4, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'r');
@@ -231,21 +231,21 @@ main (int argc, char *argv[])
char input[] = "s\303\274\303\237\360\237\230\213!"; /* "süß😋!" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 's');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 2, 7, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == EOF);
@@ -258,7 +258,7 @@ main (int argc, char *argv[])
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 6, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -272,7 +272,7 @@ main (int argc, char *argv[])
ASSERT (ret == 4);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 5, 4, &state);
ASSERT (ret == 4);
ASSERT (c32tob (wc) == EOF);
@@ -283,7 +283,7 @@ main (int argc, char *argv[])
input[7] = '\0';
input[8] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 9, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '!');
@@ -292,25 +292,25 @@ main (int argc, char *argv[])
{ /* \360\237\220\203 = U+0001F403 */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\360", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\237", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\220", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\203", 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 0x1F403); /* expect Unicode encoding */
@@ -324,14 +324,14 @@ main (int argc, char *argv[])
char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -342,14 +342,14 @@ main (int argc, char *argv[])
input[1] = '\0';
input[2] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 4, 4, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == EOF);
@@ -364,7 +364,7 @@ main (int argc, char *argv[])
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 5, 3, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -375,7 +375,7 @@ main (int argc, char *argv[])
input[5] = '\0';
input[6] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
@@ -395,21 +395,21 @@ main (int argc, char *argv[])
char input[] = "s\250\271\201\060\211\070\224\071\375\067!"; /* "süß😋!" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 's');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 2, 9, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == EOF);
@@ -424,7 +424,7 @@ main (int argc, char *argv[])
ASSERT (ret == 4);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 8, &state);
ASSERT (ret == 4);
ASSERT (c32tob (wc) == EOF);
@@ -442,7 +442,7 @@ main (int argc, char *argv[])
ASSERT (ret == 4);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 7, 4, &state);
ASSERT (ret == 4);
ASSERT (c32tob (wc) == EOF);
@@ -455,7 +455,7 @@ main (int argc, char *argv[])
input[9] = '\0';
input[10] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 11, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '!');
@@ -464,25 +464,25 @@ main (int argc, char *argv[])
{ /* \224\071\311\067 = U+0001F403 */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\224", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\071", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\311", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, "\067", 1, &state);
ASSERT (ret == 1);
#if GL_CHAR32_T_IS_UNICODE

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 = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "x", 0, &state);
/* gnulib's implementation returns (size_t)(-2).
The AIX 5.1 implementation returns (size_t)(-1).
@@ -100,7 +100,7 @@ test_one_locale (const char *name, int codepage)
/* Test NUL byte input. */
{
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "", 1, &state);
ASSERT (ret == 0);
ASSERT (wc == 0);
@@ -141,7 +141,7 @@ test_one_locale (const char *name, int codepage)
case 'z': case '{': case '|': case '}': case '~':
/* c is in the ISO C "basic character set". */
buf[0] = c;
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, buf, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == c);
@@ -156,10 +156,10 @@ test_one_locale (const char *name, int codepage)
/* Test special calling convention, passing a NULL pointer. */
{
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, NULL, 5, &state);
ASSERT (ret == 0);
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (mbsinit (&state));
}
@@ -171,14 +171,14 @@ test_one_locale (const char *name, int codepage)
char input[] = "B\374\337er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == (unsigned char) '\374');
@@ -191,7 +191,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 1);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 2, 3, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == (unsigned char) '\337');
@@ -199,14 +199,14 @@ test_one_locale (const char *name, int codepage)
ASSERT (mbsinit (&state));
input[2] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 2, &state);
ASSERT (ret == 1);
ASSERT (wc == 'e');
ASSERT (mbsinit (&state));
input[3] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 4, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'r');
@@ -220,14 +220,14 @@ test_one_locale (const char *name, int codepage)
char input[] = "x\302\341\346y"; /* "xآلوy" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'x');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == (unsigned char) '\302');
@@ -240,7 +240,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 1);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 2, 3, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == (unsigned char) '\341');
@@ -248,7 +248,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (mbsinit (&state));
input[2] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 2, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == (unsigned char) '\346');
@@ -256,7 +256,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (mbsinit (&state));
input[3] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 4, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'y');
@@ -272,21 +272,21 @@ test_one_locale (const char *name, int codepage)
char input[] = "B\303\274\303\237er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 2, 5, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == EOF);
@@ -299,7 +299,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 4, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -308,14 +308,14 @@ test_one_locale (const char *name, int codepage)
input[3] = '\0';
input[4] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 5, 2, &state);
ASSERT (ret == 1);
ASSERT (wc == 'e');
ASSERT (mbsinit (&state));
input[5] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 6, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'r');
@@ -323,61 +323,61 @@ test_one_locale (const char *name, int codepage)
/* Test some invalid input. */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\303\300", 2, &state); /* 0xC3 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\343\300", 2, &state); /* 0xE3 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\343\300\200", 3, &state); /* 0xE3 0xC0 0x80 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\343\200\300", 3, &state); /* 0xE3 0x80 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\363\300", 2, &state); /* 0xF3 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\363\300\200\200", 4, &state); /* 0xF3 0xC0 0x80 0x80 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\363\200\300", 3, &state); /* 0xF3 0x80 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\363\200\300\200", 4, &state); /* 0xF3 0x80 0xC0 0x80 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\363\200\200\300", 4, &state); /* 0xF3 0x80 0x80 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
@@ -390,14 +390,14 @@ test_one_locale (const char *name, int codepage)
char input[] = "<\223\372\226\173\214\352>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -406,14 +406,14 @@ test_one_locale (const char *name, int codepage)
input[1] = '\0';
input[2] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 4, 4, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == EOF);
@@ -426,7 +426,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 5, 3, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -435,7 +435,7 @@ test_one_locale (const char *name, int codepage)
input[5] = '\0';
input[6] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
@@ -443,12 +443,12 @@ test_one_locale (const char *name, int codepage)
/* Test some invalid input. */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == 0x30FB));
}
@@ -460,14 +460,14 @@ test_one_locale (const char *name, int codepage)
char input[] = "<\244\351\245\273\273\171>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -476,14 +476,14 @@ test_one_locale (const char *name, int codepage)
input[1] = '\0';
input[2] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 4, 4, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == EOF);
@@ -496,7 +496,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 5, 3, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -505,7 +505,7 @@ test_one_locale (const char *name, int codepage)
input[5] = '\0';
input[6] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
@@ -513,12 +513,12 @@ test_one_locale (const char *name, int codepage)
/* Test some invalid input. */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == '?'));
}
@@ -530,14 +530,14 @@ test_one_locale (const char *name, int codepage)
char input[] = "<\310\325\261\276\325\132>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -546,14 +546,14 @@ test_one_locale (const char *name, int codepage)
input[1] = '\0';
input[2] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 4, 4, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == EOF);
@@ -566,7 +566,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 5, 3, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -575,7 +575,7 @@ test_one_locale (const char *name, int codepage)
input[5] = '\0';
input[6] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
@@ -583,12 +583,12 @@ test_one_locale (const char *name, int codepage)
/* Test some invalid input. */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || ret == (size_t)-2);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
ASSERT ((ret == (size_t)-1 && errno == EILSEQ) || (ret == 2 && wc == '?'));
}
@@ -602,21 +602,21 @@ test_one_locale (const char *name, int codepage)
char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 2, 7, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == EOF);
@@ -629,7 +629,7 @@ test_one_locale (const char *name, int codepage)
ASSERT (ret == 4);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 6, &state);
ASSERT (ret == 4);
ASSERT (wctob (wc) == EOF);
@@ -640,14 +640,14 @@ test_one_locale (const char *name, int codepage)
input[5] = '\0';
input[6] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 7, 2, &state);
ASSERT (ret == 1);
ASSERT (wc == 'e');
ASSERT (mbsinit (&state));
input[7] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 8, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'r');
@@ -655,37 +655,37 @@ test_one_locale (const char *name, int codepage)
/* Test some invalid input. */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\225\377", 2, &state); /* 0x95 0xFF */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\201\045", 2, &state); /* 0x81 0x25 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\201\060\377", 3, &state); /* 0x81 0x30 0xFF */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\201\060\377\064", 4, &state); /* 0x81 0x30 0xFF 0x34 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\201\060\211\072", 4, &state); /* 0x81 0x30 0x89 0x3A */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);

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 = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 2, 5, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == EOF);
@@ -74,7 +74,7 @@ main (void)
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 4, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -83,14 +83,14 @@ main (void)
input[3] = '\0';
input[4] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 5, 2, &state);
ASSERT (ret == 1);
ASSERT (wc == 'e');
ASSERT (mbsinit (&state));
input[5] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 6, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'r');
@@ -98,61 +98,61 @@ main (void)
/* Test some invalid input. */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\377", 1, &state); /* 0xFF */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\303\300", 2, &state); /* 0xC3 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\343\300", 2, &state); /* 0xE3 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\343\300\200", 3, &state); /* 0xE3 0xC0 0x80 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\343\200\300", 3, &state); /* 0xE3 0x80 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\363\300", 2, &state); /* 0xF3 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\363\300\200\200", 4, &state); /* 0xF3 0xC0 0x80 0x80 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\363\200\300", 3, &state); /* 0xF3 0x80 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\363\200\300\200", 4, &state); /* 0xF3 0x80 0xC0 0x80 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\363\200\200\300", 4, &state); /* 0xF3 0x80 0x80 0xC0 */
ASSERT (ret == (size_t)-1);
ASSERT (errno == EILSEQ);

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 = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "x", 0, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (mbsinit (&state));
@@ -54,7 +54,7 @@ main (int argc, char *argv[])
/* Test NUL byte input. */
{
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "", 1, &state);
ASSERT (ret == 0);
ASSERT (wc == 0);
@@ -98,7 +98,7 @@ main (int argc, char *argv[])
/* c is an ASCII character. */
buf[0] = c;
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, buf, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == c);
@@ -117,10 +117,10 @@ main (int argc, char *argv[])
/* Test special calling convention, passing a NULL pointer. */
{
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, NULL, 5, &state);
ASSERT (ret == 0);
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (mbsinit (&state));
}
@@ -148,7 +148,7 @@ main (int argc, char *argv[])
/* We are testing all nonnull bytes. */
buf[0] = c;
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, buf, 1, &state);
/* POSIX:2018 says: "In the POSIX locale an [EILSEQ] error
cannot occur since all byte values are valid characters." */
@@ -175,14 +175,14 @@ main (int argc, char *argv[])
char input[] = "B\374\337er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == (unsigned char) '\374');
@@ -194,21 +194,21 @@ main (int argc, char *argv[])
ASSERT (ret == 1);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 2, 3, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == (unsigned char) '\337');
ASSERT (mbsinit (&state));
input[2] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 2, &state);
ASSERT (ret == 1);
ASSERT (wc == 'e');
ASSERT (mbsinit (&state));
input[3] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 4, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'r');
@@ -222,21 +222,21 @@ main (int argc, char *argv[])
char input[] = "B\303\274\303\237er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 2, 5, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == EOF);
@@ -248,7 +248,7 @@ main (int argc, char *argv[])
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 4, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -256,14 +256,14 @@ main (int argc, char *argv[])
input[3] = '\0';
input[4] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 5, 2, &state);
ASSERT (ret == 1);
ASSERT (wc == 'e');
ASSERT (mbsinit (&state));
input[5] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 6, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'r');
@@ -273,25 +273,25 @@ main (int argc, char *argv[])
{ /* \360\237\220\203 = U+0001F403 */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\360", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\237", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\220", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\203", 1, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == EOF);
@@ -305,14 +305,14 @@ main (int argc, char *argv[])
char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -320,14 +320,14 @@ main (int argc, char *argv[])
input[1] = '\0';
input[2] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 4, 4, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == EOF);
@@ -339,7 +339,7 @@ main (int argc, char *argv[])
ASSERT (ret == 2);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 5, 3, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -347,7 +347,7 @@ main (int argc, char *argv[])
input[5] = '\0';
input[6] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
@@ -361,21 +361,21 @@ main (int argc, char *argv[])
char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 2, 7, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == EOF);
@@ -387,7 +387,7 @@ main (int argc, char *argv[])
ASSERT (ret == 4);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 6, &state);
ASSERT (ret == 4);
ASSERT (wctob (wc) == EOF);
@@ -397,14 +397,14 @@ main (int argc, char *argv[])
input[5] = '\0';
input[6] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 7, 2, &state);
ASSERT (ret == 1);
ASSERT (wc == 'e');
ASSERT (mbsinit (&state));
input[7] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 8, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'r');
@@ -414,25 +414,25 @@ main (int argc, char *argv[])
{ /* \224\071\311\067 = U+0001F403 */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\224", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\071", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\311", 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, "\067", 1, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == EOF);

54
tests/test-mbsnrtoc32s.c
View File

@@ -58,14 +58,14 @@ main (int argc, char *argv[])
ASSERT (ret == 0);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbsnrtoc32s (&wc, &src, 1, 0, &state);
ASSERT (ret == 0);
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbsnrtoc32s (&wc, &src, 1, 1, &state);
ASSERT (ret == 0);
@@ -92,7 +92,7 @@ main (int argc, char *argv[])
mbstate_t temp_state;
for (size_t i = 0; i < BUFSIZE; i++)
buf[i] = (char32_t) 0xBADFACE;
buf[i] = 0xBADFACE;
switch (argv[1][0])
{
@@ -119,10 +119,10 @@ main (int argc, char *argv[])
ASSERT (buf[1] == '/');
ASSERT (buf[2] == 'a');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (char32_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[1] == (char32_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
{
@@ -142,7 +142,7 @@ main (int argc, char *argv[])
ASSERT (src == input);
ASSERT (mbsinit (&state));
buf[0] = buf[1] = (char32_t) 0xBADFACE;
buf[0] = buf[1] = 0xBADFACE;
src = input;
ret = mbsnrtoc32s (buf, &src, 2, unlimited ? BUFSIZE : 1, &state);
/* POSIX:2018 says regarding mbsnrtowcs: "In the POSIX locale an
@@ -169,14 +169,14 @@ main (int argc, char *argv[])
char input[] = "B\374\337er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == (unsigned char) '\374');
@@ -200,10 +200,10 @@ main (int argc, char *argv[])
ASSERT (buf[1] == 'e');
ASSERT (buf[2] == 'r');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (char32_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[1] == (char32_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -214,17 +214,17 @@ main (int argc, char *argv[])
char input[] = "s\303\274\303\237\360\237\230\213!"; /* "süß😋!" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 's');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
@@ -246,10 +246,10 @@ main (int argc, char *argv[])
ASSERT (buf[2] == 0x1F60B); /* expect Unicode encoding */
ASSERT (buf[3] == '!');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (char32_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[2] == (char32_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -260,14 +260,14 @@ main (int argc, char *argv[])
char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -275,10 +275,10 @@ main (int argc, char *argv[])
input[1] = '\0';
input[2] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
@@ -299,10 +299,10 @@ main (int argc, char *argv[])
{
ASSERT (buf[2] == '>');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (char32_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[2] == (char32_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -319,17 +319,17 @@ main (int argc, char *argv[])
char input[] = "s\250\271\201\060\211\070\224\071\375\067!"; /* "süß😋!" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 's');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
@@ -351,10 +351,10 @@ main (int argc, char *argv[])
ASSERT (c32tob (buf[2]) == EOF);
ASSERT (buf[3] == '!');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (char32_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[2] == (char32_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;

54
tests/test-mbsnrtowcs.c
View File

@@ -57,14 +57,14 @@ main (int argc, char *argv[])
ASSERT (ret == 0);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbsnrtowcs (&wc, &src, 1, 0, &state);
ASSERT (ret == 0);
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbsnrtowcs (&wc, &src, 1, 1, &state);
ASSERT (ret == 0);
@@ -91,7 +91,7 @@ main (int argc, char *argv[])
mbstate_t temp_state;
for (size_t i = 0; i < BUFSIZE; i++)
buf[i] = (wchar_t) 0xBADFACE;
buf[i] = 0xBADFACE;
switch (argv[1][0])
{
@@ -118,10 +118,10 @@ main (int argc, char *argv[])
ASSERT (buf[1] == '/');
ASSERT (buf[2] == 'a');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (wchar_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[1] == (wchar_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
{
@@ -141,7 +141,7 @@ main (int argc, char *argv[])
ASSERT (src == input);
ASSERT (mbsinit (&state));
buf[0] = buf[1] = (wchar_t) 0xBADFACE;
buf[0] = buf[1] = 0xBADFACE;
src = input;
ret = mbsnrtowcs (buf, &src, 2, unlimited ? BUFSIZE : 1, &state);
/* POSIX:2018 says: "In the POSIX locale an [EILSEQ] error
@@ -166,14 +166,14 @@ main (int argc, char *argv[])
char input[] = "B\374\337er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == (unsigned char) '\374');
@@ -197,10 +197,10 @@ main (int argc, char *argv[])
ASSERT (buf[1] == 'e');
ASSERT (buf[2] == 'r');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (wchar_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[1] == (wchar_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -211,17 +211,17 @@ main (int argc, char *argv[])
char input[] = "B\303\274\303\237er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
@@ -243,10 +243,10 @@ main (int argc, char *argv[])
ASSERT (buf[2] == 'e');
ASSERT (buf[3] == 'r');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (wchar_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[2] == (wchar_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -257,14 +257,14 @@ main (int argc, char *argv[])
char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -272,10 +272,10 @@ main (int argc, char *argv[])
input[1] = '\0';
input[2] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
@@ -296,10 +296,10 @@ main (int argc, char *argv[])
{
ASSERT (buf[2] == '>');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (wchar_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[2] == (wchar_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -310,17 +310,17 @@ main (int argc, char *argv[])
char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
@@ -342,10 +342,10 @@ main (int argc, char *argv[])
ASSERT (buf[2] == 'e');
ASSERT (buf[3] == 'r');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (wchar_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[2] == (wchar_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;

54
tests/test-mbsrtoc32s.c
View File

@@ -58,14 +58,14 @@ main (int argc, char *argv[])
ASSERT (ret == 0);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbsrtoc32s (&wc, &src, 0, &state);
ASSERT (ret == 0);
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (mbsinit (&state));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbsrtoc32s (&wc, &src, 1, &state);
ASSERT (ret == 0);
@@ -92,7 +92,7 @@ main (int argc, char *argv[])
mbstate_t temp_state;
for (size_t i = 0; i < BUFSIZE; i++)
buf[i] = (char32_t) 0xBADFACE;
buf[i] = 0xBADFACE;
switch (argv[1][0])
{
@@ -119,10 +119,10 @@ main (int argc, char *argv[])
ASSERT (buf[1] == '/');
ASSERT (buf[2] == 'a');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (char32_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[1] == (char32_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
{
@@ -142,7 +142,7 @@ main (int argc, char *argv[])
ASSERT (src == input);
ASSERT (mbsinit (&state));
buf[0] = buf[1] = (char32_t) 0xBADFACE;
buf[0] = buf[1] = 0xBADFACE;
src = input;
ret = mbsrtoc32s (buf, &src, unlimited ? BUFSIZE : 1, &state);
/* POSIX:2018 says regarding mbsrtowcs: "In the POSIX locale an
@@ -169,14 +169,14 @@ main (int argc, char *argv[])
char input[] = "B\374\337er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == (unsigned char) '\374');
@@ -200,10 +200,10 @@ main (int argc, char *argv[])
ASSERT (buf[1] == 'e');
ASSERT (buf[2] == 'r');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (char32_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[1] == (char32_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -214,17 +214,17 @@ main (int argc, char *argv[])
char input[] = "s\303\274\303\237\360\237\230\213!"; /* "süß😋!" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 's');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
@@ -246,10 +246,10 @@ main (int argc, char *argv[])
ASSERT (buf[2] == 0x1F60B); /* expect Unicode encoding */
ASSERT (buf[3] == '!');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (char32_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[2] == (char32_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -260,14 +260,14 @@ main (int argc, char *argv[])
char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (c32tob (wc) == EOF);
@@ -275,10 +275,10 @@ main (int argc, char *argv[])
input[1] = '\0';
input[2] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
@@ -299,10 +299,10 @@ main (int argc, char *argv[])
{
ASSERT (buf[2] == '>');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (char32_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[2] == (char32_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -319,17 +319,17 @@ main (int argc, char *argv[])
char input[] = "s\250\271\201\060\211\070\224\071\375\067!"; /* "süß😋!" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 's');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
@@ -351,10 +351,10 @@ main (int argc, char *argv[])
ASSERT (c32tob (buf[2]) == EOF);
ASSERT (buf[3] == '!');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (char32_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[2] == (char32_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;

54
tests/test-mbsrtowcs.c
View File

@@ -57,14 +57,14 @@ main (int argc, char *argv[])
ASSERT (ret == 0);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbsrtowcs (&wc, &src, 0, &state);
ASSERT (ret == 0);
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (mbsinit (&state));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbsrtowcs (&wc, &src, 1, &state);
ASSERT (ret == 0);
@@ -91,7 +91,7 @@ main (int argc, char *argv[])
mbstate_t temp_state;
for (size_t i = 0; i < BUFSIZE; i++)
buf[i] = (wchar_t) 0xBADFACE;
buf[i] = 0xBADFACE;
switch (argv[1][0])
{
@@ -118,10 +118,10 @@ main (int argc, char *argv[])
ASSERT (buf[1] == '/');
ASSERT (buf[2] == 'a');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (wchar_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[1] == (wchar_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
{
@@ -141,7 +141,7 @@ main (int argc, char *argv[])
ASSERT (src == input);
ASSERT (mbsinit (&state));
buf[0] = buf[1] = (wchar_t) 0xBADFACE;
buf[0] = buf[1] = 0xBADFACE;
src = input;
ret = mbsrtowcs (buf, &src, unlimited ? BUFSIZE : 1, &state);
/* POSIX:2018 says: "In the POSIX locale an [EILSEQ] error
@@ -166,14 +166,14 @@ main (int argc, char *argv[])
char input[] = "B\374\337er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == 1);
ASSERT (wctob (wc) == (unsigned char) '\374');
@@ -197,10 +197,10 @@ main (int argc, char *argv[])
ASSERT (buf[1] == 'e');
ASSERT (buf[2] == 'r');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (wchar_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[1] == (wchar_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -211,17 +211,17 @@ main (int argc, char *argv[])
char input[] = "B\303\274\303\237er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
@@ -243,10 +243,10 @@ main (int argc, char *argv[])
ASSERT (buf[2] == 'e');
ASSERT (buf[3] == 'r');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (wchar_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[2] == (wchar_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -257,14 +257,14 @@ main (int argc, char *argv[])
char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '<');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 2, &state);
ASSERT (ret == 2);
ASSERT (wctob (wc) == EOF);
@@ -272,10 +272,10 @@ main (int argc, char *argv[])
input[1] = '\0';
input[2] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 3, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[3] = '\0';
@@ -296,10 +296,10 @@ main (int argc, char *argv[])
{
ASSERT (buf[2] == '>');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (wchar_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[2] == (wchar_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;
@@ -310,17 +310,17 @@ main (int argc, char *argv[])
char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */
memset (&state, '\0', sizeof (mbstate_t));
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == 'B');
ASSERT (mbsinit (&state));
input[0] = '\0';
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 1, 1, &state);
ASSERT (ret == (size_t)(-2));
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
ASSERT (!mbsinit (&state));
input[1] = '\0';
@@ -342,10 +342,10 @@ main (int argc, char *argv[])
ASSERT (buf[2] == 'e');
ASSERT (buf[3] == 'r');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (wchar_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[2] == (wchar_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
ASSERT (mbsinit (&state));
}
break;

46
tests/test-mbstoc32s.c
View File

@@ -51,13 +51,13 @@ main (int argc, char *argv[])
ret = mbstoc32s (NULL, src, 1);
ASSERT (ret == 0);
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbstoc32s (&wc, src, 0);
ASSERT (ret == 0);
ASSERT (wc == (char32_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbstoc32s (&wc, src, 1);
ASSERT (ret == 0);
@@ -82,7 +82,7 @@ main (int argc, char *argv[])
const char *src;
for (size_t i = 0; i < BUFSIZE; i++)
buf[i] = (char32_t) 0xBADFACE;
buf[i] = 0xBADFACE;
switch (argv[1][0])
{
@@ -104,10 +104,10 @@ main (int argc, char *argv[])
ASSERT (buf[1] == '/');
ASSERT (buf[2] == 'a');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (char32_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[1] == (char32_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
}
{
char input[2];
@@ -123,7 +123,7 @@ main (int argc, char *argv[])
ret = mbstoc32s (NULL, src, unlimited ? BUFSIZE : 1);
ASSERT (ret == 1);
buf[0] = buf[1] = (char32_t) 0xBADFACE;
buf[0] = buf[1] = 0xBADFACE;
src = input;
ret = mbstoc32s (buf, src, unlimited ? BUFSIZE : 1);
/* POSIX:2018 says regarding mbstowcs: "In the POSIX locale an
@@ -147,13 +147,13 @@ main (int argc, char *argv[])
{
char input[] = "B\374\337er"; /* "Büßer" */
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbstoc32s (&wc, input, 1);
ASSERT (ret == 1);
ASSERT (wc == 'B');
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbstoc32s (&wc, input + 1, 1);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == (unsigned char) '\374');
@@ -172,10 +172,10 @@ main (int argc, char *argv[])
ASSERT (buf[1] == 'e');
ASSERT (buf[2] == 'r');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (char32_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[1] == (char32_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
}
break;
@@ -184,13 +184,13 @@ main (int argc, char *argv[])
{
char input[] = "s\303\274\303\237\360\237\230\213!"; /* "süß😋!" */
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbstoc32s (&wc, input, 1);
ASSERT (ret == 1);
ASSERT (wc == 's');
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbstoc32s (&wc, input + 1, 1);
ASSERT (ret == 1);
ASSERT (wc == 0x00FC); /* expect Unicode encoding */
@@ -210,10 +210,10 @@ main (int argc, char *argv[])
{
ASSERT (buf[2] == '!');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (char32_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[2] == (char32_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
}
break;
@@ -222,13 +222,13 @@ main (int argc, char *argv[])
{
char input[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbstoc32s (&wc, input, 1);
ASSERT (ret == 1);
ASSERT (wc == '<');
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbstoc32s (&wc, input + 1, 1);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == EOF);
@@ -248,10 +248,10 @@ main (int argc, char *argv[])
{
ASSERT (buf[2] == '>');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (char32_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[2] == (char32_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
}
break;
@@ -266,13 +266,13 @@ main (int argc, char *argv[])
{
char input[] = "s\250\271\201\060\211\070\224\071\375\067!"; /* "süß😋!" */
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbstoc32s (&wc, input, 1);
ASSERT (ret == 1);
ASSERT (wc == 's');
input[0] = '\0';
wc = (char32_t) 0xBADFACE;
wc = 0xBADFACE;
ret = mbstoc32s (&wc, input + 1, 1);
ASSERT (ret == 1);
ASSERT (c32tob (wc) == EOF);
@@ -291,10 +291,10 @@ main (int argc, char *argv[])
{
ASSERT (buf[2] == '!');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (char32_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[2] == (char32_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
}
break;

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 = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbstowcs (&wc, src, 0);
ASSERT (ret == 0);
ASSERT (wc == (wchar_t) 0xBADFACE);
ASSERT (wc == 0xBADFACE);
wc = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
src = "";
ret = mbstowcs (&wc, src, 1);
ASSERT (ret == 0);
@@ -83,7 +83,7 @@ main (int argc, char *argv[])
const char *src;
for (size_t i = 0; i < BUFSIZE; i++)
buf[i] = (wchar_t) 0xBADFACE;
buf[i] = 0xBADFACE;
switch (argv[1][0])
{
@@ -105,10 +105,10 @@ main (int argc, char *argv[])
ASSERT (buf[1] == '/');
ASSERT (buf[2] == 'a');
ASSERT (buf[3] == 0);
ASSERT (buf[4] == (wchar_t) 0xBADFACE);
ASSERT (buf[4] == 0xBADFACE);
}
else
ASSERT (buf[1] == (wchar_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
}
{
char input[2];
@@ -124,7 +124,7 @@ main (int argc, char *argv[])
ret = mbstowcs (NULL, src, unlimited ? BUFSIZE : 1);
ASSERT (ret == 1);
buf[0] = buf[1] = (wchar_t) 0xBADFACE;
buf[0] = buf[1] = 0xBADFACE;
src = input;
ret = mbstowcs (buf, src, unlimited ? BUFSIZE : 1);
/* POSIX:2018 says: "In the POSIX locale an [EILSEQ] error
@@ -160,10 +160,10 @@ main (int argc, char *argv[])
ASSERT (buf[2] == 'e');
ASSERT (buf[3] == 'r');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (wchar_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[1] == (wchar_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
}
break;
@@ -186,10 +186,10 @@ main (int argc, char *argv[])
ASSERT (buf[2] == 'e');
ASSERT (buf[3] == 'r');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (wchar_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[2] == (wchar_t) 0xBADFACE);
ASSERT (buf[2] == 0xBADFACE);
}
break;
@@ -212,10 +212,10 @@ main (int argc, char *argv[])
{
ASSERT (buf[3] == '>');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (wchar_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[3] == (wchar_t) 0xBADFACE);
ASSERT (buf[3] == 0xBADFACE);
}
break;
@@ -238,10 +238,10 @@ main (int argc, char *argv[])
ASSERT (buf[2] == 'e');
ASSERT (buf[3] == 'r');
ASSERT (buf[4] == 0);
ASSERT (buf[5] == (wchar_t) 0xBADFACE);
ASSERT (buf[5] == 0xBADFACE);
}
else
ASSERT (buf[1] == (wchar_t) 0xBADFACE);
ASSERT (buf[1] == 0xBADFACE);
}
break;

3
tests/test-sameacls.c
View File

@@ -110,7 +110,8 @@ main (int argc, char *argv[])
{
fprintf (stderr, "files %s and %s have different access modes: %03o and %03o\n",
file1, file2,
(unsigned int) statbuf1.st_mode, (unsigned int) statbuf2.st_mode);
(unsigned int) {statbuf1.st_mode},
(unsigned int) {statbuf2.st_mode});
return 1;
}
}

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

@@ -3110,7 +3110,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
ASSERT (retval == 6);
}
static wint_t L_x = (wchar_t) 'x';
static wint_t L_x = L'x';
{ /* Width. */
int retval =
@@ -3162,7 +3162,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
ASSERT (retval == 6);
}
static wint_t L_invalid = (wchar_t) 0x76543210;
static wint_t L_invalid = 0x76543210;
{ /* Invalid wide character.
The conversion may succeed or may fail, but it should not abort. */
@@ -3514,7 +3514,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%hhd %d", (signed char) -42, 33, 44, 55);
"%hhd %d", (signed char) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (retval == strlen (result));
}
@@ -3522,7 +3522,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%hd %d", (short) -12345, 33, 44, 55);
"%hd %d", (short) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3538,7 +3538,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%ld %d", (long int) -12345, 33, 44, 55);
"%ld %d", -12345L, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3546,7 +3546,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%lld %d", (long long int) -12345, 33, 44, 55);
"%lld %d", -12345LL, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3554,7 +3554,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w8d %d", (int8_t) -42, 33, 44, 55);
"%w8d %d", (int8_t) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (retval == strlen (result));
}
@@ -3562,7 +3562,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w16d %d", (int16_t) -12345, 33, 44, 55);
"%w16d %d", (int16_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3570,7 +3570,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w32d %d", (int32_t) -12345, 33, 44, 55);
"%w32d %d", (int32_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3578,7 +3578,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w64d %d", (int64_t) -12345, 33, 44, 55);
"%w64d %d", (int64_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3586,7 +3586,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf8d %d", (int_fast8_t) -42, 33, 44, 55);
"%wf8d %d", (int_fast8_t) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (retval == strlen (result));
}
@@ -3594,7 +3594,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf16d %d", (int_fast16_t) -12345, 33, 44, 55);
"%wf16d %d", (int_fast16_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3602,7 +3602,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf32d %d", (int_fast32_t) -12345, 33, 44, 55);
"%wf32d %d", (int_fast32_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3621,7 +3621,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%hhu %d", (unsigned char) 42, 33, 44, 55);
"%hhu %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (retval == strlen (result));
}
@@ -3629,7 +3629,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%hu %d", (unsigned short) 12345, 33, 44, 55);
"%hu %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3637,7 +3637,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%u %d", (unsigned int) 12345, 33, 44, 55);
"%u %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3645,7 +3645,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%lu %d", (unsigned long int) 12345, 33, 44, 55);
"%lu %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3653,7 +3653,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%llu %d", (unsigned long long int) 12345, 33, 44, 55);
"%llu %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3661,7 +3661,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w8u %d", (uint8_t) 42, 33, 44, 55);
"%w8u %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (retval == strlen (result));
}
@@ -3669,7 +3669,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w16u %d", (uint16_t) 12345, 33, 44, 55);
"%w16u %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3677,7 +3677,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w32u %d", (uint32_t) 12345, 33, 44, 55);
"%w32u %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3685,7 +3685,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w64u %d", (uint64_t) 12345, 33, 44, 55);
"%w64u %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3693,7 +3693,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf8u %d", (uint_fast8_t) 42, 33, 44, 55);
"%wf8u %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (retval == strlen (result));
}
@@ -3701,7 +3701,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf16u %d", (uint_fast16_t) 12345, 33, 44, 55);
"%wf16u %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3709,7 +3709,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf32u %d", (uint_fast32_t) 12345, 33, 44, 55);
"%wf32u %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3717,7 +3717,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf64u %d", (uint_fast64_t) 12345, 33, 44, 55);
"%wf64u %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3728,7 +3728,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%hhb %d", (unsigned char) 42, 33, 44, 55);
"%hhb %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (retval == strlen (result));
}
@@ -3736,7 +3736,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%hb %d", (unsigned short) 12345, 33, 44, 55);
"%hb %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
@@ -3744,7 +3744,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%b %d", (unsigned int) 12345, 33, 44, 55);
"%b %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
@@ -3752,7 +3752,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%lb %d", (unsigned long int) 12345, 33, 44, 55);
"%lb %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
@@ -3760,7 +3760,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%llb %d", (unsigned long long int) 12345, 33, 44, 55);
"%llb %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
@@ -3768,7 +3768,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w8b %d", (uint8_t) 42, 33, 44, 55);
"%w8b %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (retval == strlen (result));
}
@@ -3776,7 +3776,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w16b %d", (uint16_t) 12345, 33, 44, 55);
"%w16b %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
@@ -3784,7 +3784,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w32b %d", (uint32_t) 12345, 33, 44, 55);
"%w32b %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
@@ -3792,7 +3792,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w64b %d", (uint64_t) 12345, 33, 44, 55);
"%w64b %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
@@ -3800,7 +3800,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf8b %d", (uint_fast8_t) 42, 33, 44, 55);
"%wf8b %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (retval == strlen (result));
}
@@ -3808,7 +3808,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf16b %d", (uint_fast16_t) 12345, 33, 44, 55);
"%wf16b %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
@@ -3816,7 +3816,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf32b %d", (uint_fast32_t) 12345, 33, 44, 55);
"%wf32b %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
@@ -3824,7 +3824,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf64b %d", (uint_fast64_t) 12345, 33, 44, 55);
"%wf64b %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
@@ -3835,7 +3835,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%hho %d", (unsigned char) 42, 33, 44, 55);
"%hho %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (retval == strlen (result));
}
@@ -3843,7 +3843,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%ho %d", (unsigned short) 12345, 33, 44, 55);
"%ho %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
@@ -3851,7 +3851,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%o %d", (unsigned int) 12345, 33, 44, 55);
"%o %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
@@ -3859,7 +3859,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%lo %d", (unsigned long int) 12345, 33, 44, 55);
"%lo %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
@@ -3867,7 +3867,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%llo %d", (unsigned long long int) 12345, 33, 44, 55);
"%llo %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
@@ -3875,7 +3875,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w8o %d", (uint8_t) 42, 33, 44, 55);
"%w8o %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (retval == strlen (result));
}
@@ -3883,7 +3883,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w16o %d", (uint16_t) 12345, 33, 44, 55);
"%w16o %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
@@ -3891,7 +3891,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w32o %d", (uint32_t) 12345, 33, 44, 55);
"%w32o %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
@@ -3899,7 +3899,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w64o %d", (uint64_t) 12345, 33, 44, 55);
"%w64o %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
@@ -3907,7 +3907,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf8o %d", (uint_fast8_t) 42, 33, 44, 55);
"%wf8o %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (retval == strlen (result));
}
@@ -3915,7 +3915,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf16o %d", (uint_fast16_t) 12345, 33, 44, 55);
"%wf16o %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
@@ -3923,7 +3923,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf32o %d", (uint_fast32_t) 12345, 33, 44, 55);
"%wf32o %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
@@ -3931,7 +3931,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf64o %d", (uint_fast64_t) 12345, 33, 44, 55);
"%wf64o %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
@@ -3942,7 +3942,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%hhX %d", (unsigned char) 42, 33, 44, 55);
"%hhX %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (retval == strlen (result));
}
@@ -3950,7 +3950,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%hX %d", (unsigned short) 12345, 33, 44, 55);
"%hX %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
@@ -3958,7 +3958,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%X %d", (unsigned int) 12345, 33, 44, 55);
"%X %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
@@ -3966,7 +3966,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%lX %d", (unsigned long int) 12345, 33, 44, 55);
"%lX %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
@@ -3974,7 +3974,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%llX %d", (unsigned long long int) 12345, 33, 44, 55);
"%llX %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
@@ -3982,7 +3982,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w8X %d", (uint8_t) 42, 33, 44, 55);
"%w8X %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (retval == strlen (result));
}
@@ -3990,7 +3990,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w16X %d", (uint16_t) 12345, 33, 44, 55);
"%w16X %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
@@ -3998,7 +3998,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w32X %d", (uint32_t) 12345, 33, 44, 55);
"%w32X %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
@@ -4006,7 +4006,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%w64X %d", (uint64_t) 12345, 33, 44, 55);
"%w64X %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
@@ -4014,7 +4014,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf8X %d", (uint_fast8_t) 42, 33, 44, 55);
"%wf8X %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (retval == strlen (result));
}
@@ -4022,7 +4022,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf16X %d", (uint_fast16_t) 12345, 33, 44, 55);
"%wf16X %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
@@ -4030,7 +4030,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf32X %d", (uint_fast32_t) 12345, 33, 44, 55);
"%wf32X %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
@@ -4038,7 +4038,7 @@ test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
{
int retval =
my_snprintf (result, sizeof (result),
"%wf64X %d", (uint_fast64_t) 12345, 33, 44, 55);
"%wf64X %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}

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

@@ -3091,7 +3091,7 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
ASSERT (retval == 6);
}
static wint_t L_x = (wchar_t) 'x';
static wint_t L_x = L'x';
{ /* Width. */
int retval =
@@ -3145,7 +3145,7 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
ASSERT (retval == 6);
}
static wint_t L_invalid = (wchar_t) 0x76543210;
static wint_t L_invalid = 0x76543210;
{ /* Invalid wide character.
The conversion may succeed or may fail, but it should not abort. */
@@ -3494,14 +3494,14 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
{
int retval =
my_sprintf (result, "%hhd %d", (signed char) -42, 33, 44, 55);
my_sprintf (result, "%hhd %d", (signed char) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%hd %d", (short) -12345, 33, 44, 55);
my_sprintf (result, "%hd %d", (short) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3515,63 +3515,63 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
{
int retval =
my_sprintf (result, "%ld %d", (long int) -12345, 33, 44, 55);
my_sprintf (result, "%ld %d", -12345L, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%lld %d", (long long int) -12345, 33, 44, 55);
my_sprintf (result, "%lld %d", -12345LL, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w8d %d", (int8_t) -42, 33, 44, 55);
my_sprintf (result, "%w8d %d", (int8_t) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w16d %d", (int16_t) -12345, 33, 44, 55);
my_sprintf (result, "%w16d %d", (int16_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w32d %d", (int32_t) -12345, 33, 44, 55);
my_sprintf (result, "%w32d %d", (int32_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w64d %d", (int64_t) -12345, 33, 44, 55);
my_sprintf (result, "%w64d %d", (int64_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf8d %d", (int_fast8_t) -42, 33, 44, 55);
my_sprintf (result, "%wf8d %d", (int_fast8_t) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf16d %d", (int_fast16_t) -12345, 33, 44, 55);
my_sprintf (result, "%wf16d %d", (int_fast16_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf32d %d", (int_fast32_t) -12345, 33, 44, 55);
my_sprintf (result, "%wf32d %d", (int_fast32_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3588,91 +3588,91 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
{
int retval =
my_sprintf (result, "%hhu %d", (unsigned char) 42, 33, 44, 55);
my_sprintf (result, "%hhu %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%hu %d", (unsigned short) 12345, 33, 44, 55);
my_sprintf (result, "%hu %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%u %d", (unsigned int) 12345, 33, 44, 55);
my_sprintf (result, "%u %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%lu %d", (unsigned long int) 12345, 33, 44, 55);
my_sprintf (result, "%lu %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%llu %d", (unsigned long long int) 12345, 33, 44, 55);
my_sprintf (result, "%llu %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w8u %d", (uint8_t) 42, 33, 44, 55);
my_sprintf (result, "%w8u %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w16u %d", (uint16_t) 12345, 33, 44, 55);
my_sprintf (result, "%w16u %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w32u %d", (uint32_t) 12345, 33, 44, 55);
my_sprintf (result, "%w32u %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w64u %d", (uint64_t) 12345, 33, 44, 55);
my_sprintf (result, "%w64u %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf8u %d", (uint_fast8_t) 42, 33, 44, 55);
my_sprintf (result, "%wf8u %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf16u %d", (uint_fast16_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf16u %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf32u %d", (uint_fast32_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf32u %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf64u %d", (uint_fast64_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf64u %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
}
@@ -3682,91 +3682,91 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
{
int retval =
my_sprintf (result, "%hhb %d", (unsigned char) 42, 33, 44, 55);
my_sprintf (result, "%hhb %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%hb %d", (unsigned short) 12345, 33, 44, 55);
my_sprintf (result, "%hb %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%b %d", (unsigned int) 12345, 33, 44, 55);
my_sprintf (result, "%b %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%lb %d", (unsigned long int) 12345, 33, 44, 55);
my_sprintf (result, "%lb %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%llb %d", (unsigned long long int) 12345, 33, 44, 55);
my_sprintf (result, "%llb %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w8b %d", (uint8_t) 42, 33, 44, 55);
my_sprintf (result, "%w8b %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w16b %d", (uint16_t) 12345, 33, 44, 55);
my_sprintf (result, "%w16b %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w32b %d", (uint32_t) 12345, 33, 44, 55);
my_sprintf (result, "%w32b %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w64b %d", (uint64_t) 12345, 33, 44, 55);
my_sprintf (result, "%w64b %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf8b %d", (uint_fast8_t) 42, 33, 44, 55);
my_sprintf (result, "%wf8b %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf16b %d", (uint_fast16_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf16b %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf32b %d", (uint_fast32_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf32b %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf64b %d", (uint_fast64_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf64b %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
}
@@ -3776,91 +3776,91 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
{
int retval =
my_sprintf (result, "%hho %d", (unsigned char) 42, 33, 44, 55);
my_sprintf (result, "%hho %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%ho %d", (unsigned short) 12345, 33, 44, 55);
my_sprintf (result, "%ho %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%o %d", (unsigned int) 12345, 33, 44, 55);
my_sprintf (result, "%o %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%lo %d", (unsigned long int) 12345, 33, 44, 55);
my_sprintf (result, "%lo %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%llo %d", (unsigned long long int) 12345, 33, 44, 55);
my_sprintf (result, "%llo %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w8o %d", (uint8_t) 42, 33, 44, 55);
my_sprintf (result, "%w8o %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w16o %d", (uint16_t) 12345, 33, 44, 55);
my_sprintf (result, "%w16o %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w32o %d", (uint32_t) 12345, 33, 44, 55);
my_sprintf (result, "%w32o %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w64o %d", (uint64_t) 12345, 33, 44, 55);
my_sprintf (result, "%w64o %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf8o %d", (uint_fast8_t) 42, 33, 44, 55);
my_sprintf (result, "%wf8o %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf16o %d", (uint_fast16_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf16o %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf32o %d", (uint_fast32_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf32o %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf64o %d", (uint_fast64_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf64o %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
}
@@ -3870,91 +3870,91 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
{
int retval =
my_sprintf (result, "%hhX %d", (unsigned char) 42, 33, 44, 55);
my_sprintf (result, "%hhX %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%hX %d", (unsigned short) 12345, 33, 44, 55);
my_sprintf (result, "%hX %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%X %d", (unsigned int) 12345, 33, 44, 55);
my_sprintf (result, "%X %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%lX %d", (unsigned long int) 12345, 33, 44, 55);
my_sprintf (result, "%lX %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%llX %d", (unsigned long long int) 12345, 33, 44, 55);
my_sprintf (result, "%llX %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w8X %d", (uint8_t) 42, 33, 44, 55);
my_sprintf (result, "%w8X %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w16X %d", (uint16_t) 12345, 33, 44, 55);
my_sprintf (result, "%w16X %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w32X %d", (uint32_t) 12345, 33, 44, 55);
my_sprintf (result, "%w32X %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%w64X %d", (uint64_t) 12345, 33, 44, 55);
my_sprintf (result, "%w64X %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf8X %d", (uint_fast8_t) 42, 33, 44, 55);
my_sprintf (result, "%wf8X %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf16X %d", (uint_fast16_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf16X %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf32X %d", (uint_fast32_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf32X %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}
{
int retval =
my_sprintf (result, "%wf64X %d", (uint_fast64_t) 12345, 33, 44, 55);
my_sprintf (result, "%wf64X %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
}

2
tests/test-stat-time.c
View File

@@ -48,7 +48,7 @@ static char filename_stamp3[50];
static void
initialize_filenames (void)
{
long t = (long) time (NULL);
long t = time (NULL);
sprintf (filename_stamp1, "t-stt-%ld-stamp1", t);
sprintf (filename_testfile, "t-stt-%ld-testfile", t);
sprintf (filename_stamp2, "t-stt-%ld-stamp2", t);

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 ((wchar_t) 0, desc) == 0);
ASSERT (towctrans (L'\0', desc) == 0);
ASSERT (towctrans (WEOF, desc) == WEOF);
desc = wctrans ("toupper");
@@ -53,7 +53,7 @@ main (int argc, char *argv[])
ASSERT (towctrans (L'z', desc) == 'Z');
ASSERT (towctrans (L'1', desc) == '1');
ASSERT (towctrans (L'_', desc) == '_');
ASSERT (towctrans ((wchar_t) 0, desc) == 0);
ASSERT (towctrans (L'\0', desc) == 0);
ASSERT (towctrans (WEOF, desc) == WEOF);
return test_exit_status;

4
tests/test-truncf2.c
View File

@@ -165,8 +165,8 @@ main ()
/* Combine highbits and lowbits into a floating-point number,
sign-extending the lowbits to 32-NUM_HIGHBITS bits. */
union { float f; uint32_t i; } janus;
janus.i = ((uint32_t) highbits << (32 - NUM_HIGHBITS))
| ((uint32_t) ((int32_t) ((uint32_t) lowbits << (32 - NUM_LOWBITS))
janus.i = ((uint32_t) {highbits} << (32 - NUM_HIGHBITS))
| ((uint32_t) ((int32_t) ((uint32_t) {lowbits} << (32 - NUM_LOWBITS))
>> (32 - NUM_LOWBITS - NUM_HIGHBITS))
>> NUM_HIGHBITS);
error |= check (janus.f);

140
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[] = { (wchar_t) 1702057263, 114, 0 };
static const wchar_t input[] = { 1702057263, 114, 0 };
size_t length;
char *result = my_asnprintf (NULL, &length, "%ls %d", input, 99);
if (result == NULL)
@@ -3958,7 +3958,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
free (result);
}
{
static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 };
static const wchar_t input[] = { 1702057263, 114, 0 };
size_t length;
char *result = my_asnprintf (NULL, &length, "%3ls %d", input, 99);
if (result == NULL)
@@ -3967,7 +3967,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
free (result);
}
{
static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 };
static const wchar_t input[] = { 1702057263, 114, 0 };
size_t length;
char *result = my_asnprintf (NULL, &length, "%.1ls %d", input, 99);
if (result == NULL)
@@ -3976,7 +3976,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
free (result);
}
{
static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 };
static const wchar_t input[] = { 1702057263, 114, 0 };
size_t length;
char *result = my_asnprintf (NULL, &length, "%3.1ls %d", input, 99);
if (result == NULL)
@@ -4051,7 +4051,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
free (result);
}
static wint_t L_x = (wchar_t) 'x';
static wint_t L_x = L'x';
{ /* Width. */
size_t length;
@@ -4117,7 +4117,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
free (result);
}
static wint_t L_invalid = (wchar_t) 0x76543210;
static wint_t L_invalid = 0x76543210;
{ /* Invalid wide character.
The conversion may succeed or may fail, but it should not abort. */
@@ -4598,7 +4598,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%hhd %d", (signed char) -42, 33, 44, 55);
my_asnprintf (NULL, &length, "%hhd %d", (signed char) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4607,7 +4607,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%hd %d", (short) -12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%hd %d", (short) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4625,7 +4625,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%ld %d", (long int) -12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%ld %d", -12345L, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4634,7 +4634,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%lld %d", (long long int) -12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%lld %d", -12345LL, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4643,7 +4643,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w8d %d", (int8_t) -42, 33, 44, 55);
my_asnprintf (NULL, &length, "%w8d %d", (int8_t) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4652,7 +4652,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w16d %d", (int16_t) -12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w16d %d", (int16_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4661,7 +4661,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w32d %d", (int32_t) -12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w32d %d", (int32_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4670,7 +4670,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w64d %d", (int64_t) -12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w64d %d", (int64_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4679,7 +4679,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf8d %d", (int_fast8_t) -42, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf8d %d", (int_fast8_t) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4688,7 +4688,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf16d %d", (int_fast16_t) -12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf16d %d", (int_fast16_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4697,7 +4697,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf32d %d", (int_fast32_t) -12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf32d %d", (int_fast32_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4706,7 +4706,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf64d %d", (int_fast64_t) -12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf64d %d", (int_fast64_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4718,7 +4718,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%hhu %d", (unsigned char) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%hhu %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4727,7 +4727,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%hu %d", (unsigned short) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%hu %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4736,7 +4736,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%u %d", (unsigned int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%u %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4745,7 +4745,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%lu %d", (unsigned long int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%lu %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4754,7 +4754,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%llu %d", (unsigned long long int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%llu %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4763,7 +4763,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w8u %d", (uint8_t) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%w8u %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4772,7 +4772,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w16u %d", (uint16_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w16u %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4781,7 +4781,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w32u %d", (uint32_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w32u %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4790,7 +4790,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w64u %d", (uint64_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w64u %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4799,7 +4799,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf8u %d", (uint_fast8_t) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf8u %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4808,7 +4808,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf16u %d", (uint_fast16_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf16u %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4817,7 +4817,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf32u %d", (uint_fast32_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf32u %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4826,7 +4826,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf64u %d", (uint_fast64_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf64u %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4838,7 +4838,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%hhb %d", (unsigned char) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%hhb %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4847,7 +4847,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%hb %d", (unsigned short) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%hb %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4856,7 +4856,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%b %d", (unsigned int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%b %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4865,7 +4865,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%lb %d", (unsigned long int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%lb %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4874,7 +4874,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%llb %d", (unsigned long long int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%llb %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4883,7 +4883,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w8b %d", (uint8_t) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%w8b %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4892,7 +4892,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w16b %d", (uint16_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w16b %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4901,7 +4901,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w32b %d", (uint32_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w32b %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4910,7 +4910,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w64b %d", (uint64_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w64b %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4919,7 +4919,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf8b %d", (uint_fast8_t) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf8b %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4928,7 +4928,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf16b %d", (uint_fast16_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf16b %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4937,7 +4937,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf32b %d", (uint_fast32_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf32b %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4946,7 +4946,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf64b %d", (uint_fast64_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf64b %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4958,7 +4958,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%hho %d", (unsigned char) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%hho %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4967,7 +4967,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%ho %d", (unsigned short) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%ho %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4976,7 +4976,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%o %d", (unsigned int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%o %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4985,7 +4985,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%lo %d", (unsigned long int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%lo %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (length == strlen (result));
free (result);
@@ -4994,7 +4994,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%llo %d", (unsigned long long int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%llo %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5003,7 +5003,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w8o %d", (uint8_t) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%w8o %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5012,7 +5012,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w16o %d", (uint16_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w16o %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5021,7 +5021,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w32o %d", (uint32_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w32o %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5030,7 +5030,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w64o %d", (uint64_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w64o %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5039,7 +5039,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf8o %d", (uint_fast8_t) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf8o %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5048,7 +5048,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf16o %d", (uint_fast16_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf16o %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5057,7 +5057,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf32o %d", (uint_fast32_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf32o %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5066,7 +5066,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf64o %d", (uint_fast64_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf64o %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5078,7 +5078,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%hhX %d", (unsigned char) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%hhX %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5087,7 +5087,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%hX %d", (unsigned short) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%hX %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5096,7 +5096,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%X %d", (unsigned int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%X %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5105,7 +5105,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%lX %d", (unsigned long int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%lX %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5114,7 +5114,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%llX %d", (unsigned long long int) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%llX %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5123,7 +5123,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w8X %d", (uint8_t) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%w8X %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5132,7 +5132,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w16X %d", (uint16_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w16X %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5141,7 +5141,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w32X %d", (uint32_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w32X %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5150,7 +5150,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%w64X %d", (uint64_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%w64X %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5159,7 +5159,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf8X %d", (uint_fast8_t) 42, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf8X %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5168,7 +5168,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf16X %d", (uint_fast16_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf16X %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5177,7 +5177,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf32X %d", (uint_fast32_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf32X %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (length == strlen (result));
free (result);
@@ -5186,7 +5186,7 @@ test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
{
size_t length;
char *result =
my_asnprintf (NULL, &length, "%wf64X %d", (uint_fast64_t) 12345, 33, 44, 55);
my_asnprintf (NULL, &length, "%wf64X %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (length == strlen (result));
free (result);

144
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[] = { (wchar_t) 1702057263, 114, 0 };
static const wchar_t input[] = { 1702057263, 114, 0 };
size_t length;
wchar_t *result = my_asnwprintf (NULL, &length, L"%ls %d", input, 99);
if (result == NULL)
@@ -3991,7 +3991,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
free (result);
}
{
static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 };
static const wchar_t input[] = { 1702057263, 114, 0 };
size_t length;
wchar_t *result = my_asnwprintf (NULL, &length, L"%3ls %d", input, 99);
if (result == NULL)
@@ -4000,7 +4000,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
free (result);
}
{
static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 };
static const wchar_t input[] = { 1702057263, 114, 0 };
size_t length;
wchar_t *result = my_asnwprintf (NULL, &length, L"%.1ls %d", input, 99);
if (result == NULL)
@@ -4009,7 +4009,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
free (result);
}
{
static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 };
static const wchar_t input[] = { 1702057263, 114, 0 };
size_t length;
wchar_t *result = my_asnwprintf (NULL, &length, L"%3.1ls %d", input, 99);
if (result == NULL)
@@ -4102,7 +4102,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
}
#endif
static wint_t L_x = (wchar_t) 'x';
static wint_t L_x = L'x';
{ /* Width. */
size_t length;
@@ -4162,7 +4162,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
free (result);
}
static wint_t L_invalid = (wchar_t) 0x76543210;
static wint_t L_invalid = 0x76543210;
{ /* Invalid wide character. */
size_t length;
@@ -4171,7 +4171,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
/* No failure is allowed: ISO C says "the wint_t argument is converted
to wchar_t and written." */
ASSERT (result != NULL);
ASSERT (result[0] == (wchar_t) 0x76543210);
ASSERT (result[0] == 0x76543210);
ASSERT (wmemcmp (result + 1, L" 33\0", 3 + 1) == 0);
ASSERT (length == 4);
free (result);
@@ -4185,7 +4185,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
to wchar_t and written." */
ASSERT (result != NULL);
ASSERT (wmemcmp (result, L" ", 9) == 0);
ASSERT (result[9] == (wchar_t) 0x76543210);
ASSERT (result[9] == 0x76543210);
ASSERT (wmemcmp (result + 10, L" 33\0", 3 + 1) == 0);
ASSERT (length == 13);
free (result);
@@ -4654,7 +4654,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%hhd %d", (signed char) -42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%hhd %d", (signed char) {-42}, 33, 44, 55);
ASSERT (wcscmp (result, L"-42 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4663,7 +4663,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%hd %d", (short) -12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%hd %d", (short) {-12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"-12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4681,7 +4681,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%ld %d", (long int) -12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%ld %d", -12345L, 33, 44, 55);
ASSERT (wcscmp (result, L"-12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4690,7 +4690,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%lld %d", (long long int) -12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%lld %d", -12345LL, 33, 44, 55);
ASSERT (wcscmp (result, L"-12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4699,7 +4699,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w8d %d", (int8_t) -42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w8d %d", (int8_t) {-42}, 33, 44, 55);
ASSERT (wcscmp (result, L"-42 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4708,7 +4708,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w16d %d", (int16_t) -12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w16d %d", (int16_t) {-12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"-12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4717,7 +4717,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w32d %d", (int32_t) -12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w32d %d", (int32_t) {-12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"-12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4726,7 +4726,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w64d %d", (int64_t) -12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w64d %d", (int64_t) {-12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"-12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4735,7 +4735,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf8d %d", (int_fast8_t) -42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf8d %d", (int_fast8_t) {-42}, 33, 44, 55);
ASSERT (wcscmp (result, L"-42 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4744,7 +4744,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf16d %d", (int_fast16_t) -12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf16d %d", (int_fast16_t) {-12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"-12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4753,7 +4753,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf32d %d", (int_fast32_t) -12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf32d %d", (int_fast32_t) {-12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"-12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4762,7 +4762,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf64d %d", (int_fast64_t) -12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf64d %d", (int_fast64_t) {-12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"-12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4774,7 +4774,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%hhu %d", (unsigned char) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%hhu %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"42 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4783,7 +4783,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%hu %d", (unsigned short) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%hu %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4792,7 +4792,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%u %d", (unsigned int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%u %d", 12345U, 33, 44, 55);
ASSERT (wcscmp (result, L"12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4801,7 +4801,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%lu %d", (unsigned long int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%lu %d", 12345UL, 33, 44, 55);
ASSERT (wcscmp (result, L"12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4810,7 +4810,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%llu %d", (unsigned long long int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%llu %d", 12345ULL, 33, 44, 55);
ASSERT (wcscmp (result, L"12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4819,7 +4819,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w8u %d", (uint8_t) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w8u %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"42 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4828,7 +4828,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w16u %d", (uint16_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w16u %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4837,7 +4837,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w32u %d", (uint32_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w32u %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4846,7 +4846,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w64u %d", (uint64_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w64u %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4855,7 +4855,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf8u %d", (uint_fast8_t) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf8u %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"42 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4864,7 +4864,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf16u %d", (uint_fast16_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf16u %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4873,7 +4873,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf32u %d", (uint_fast32_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf32u %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4882,7 +4882,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf64u %d", (uint_fast64_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf64u %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"12345 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4894,7 +4894,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%hhb %d", (unsigned char) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%hhb %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"101010 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4903,7 +4903,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%hb %d", (unsigned short) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%hb %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"11000000111001 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4912,7 +4912,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%b %d", (unsigned int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%b %d", 12345U, 33, 44, 55);
ASSERT (wcscmp (result, L"11000000111001 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4921,7 +4921,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%lb %d", (unsigned long int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%lb %d", 12345UL, 33, 44, 55);
ASSERT (wcscmp (result, L"11000000111001 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4930,7 +4930,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%llb %d", (unsigned long long int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%llb %d", 12345ULL, 33, 44, 55);
ASSERT (wcscmp (result, L"11000000111001 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4939,7 +4939,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w8b %d", (uint8_t) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w8b %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"101010 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4948,7 +4948,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w16b %d", (uint16_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w16b %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"11000000111001 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4957,7 +4957,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w32b %d", (uint32_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w32b %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"11000000111001 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4966,7 +4966,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w64b %d", (uint64_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w64b %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"11000000111001 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4975,7 +4975,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf8b %d", (uint_fast8_t) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf8b %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"101010 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4984,7 +4984,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf16b %d", (uint_fast16_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf16b %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"11000000111001 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -4993,7 +4993,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf32b %d", (uint_fast32_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf32b %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"11000000111001 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5002,7 +5002,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf64b %d", (uint_fast64_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf64b %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"11000000111001 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5014,7 +5014,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%hho %d", (unsigned char) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%hho %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"52 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5023,7 +5023,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%ho %d", (unsigned short) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%ho %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"30071 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5032,7 +5032,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%o %d", (unsigned int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%o %d", 12345U, 33, 44, 55);
ASSERT (wcscmp (result, L"30071 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5041,7 +5041,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%lo %d", (unsigned long int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%lo %d", 12345UL, 33, 44, 55);
ASSERT (wcscmp (result, L"30071 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5050,7 +5050,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%llo %d", (unsigned long long int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%llo %d", 12345ULL, 33, 44, 55);
ASSERT (wcscmp (result, L"30071 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5059,7 +5059,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w8o %d", (uint8_t) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w8o %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"52 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5068,7 +5068,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w16o %d", (uint16_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w16o %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"30071 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5077,7 +5077,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w32o %d", (uint32_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w32o %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"30071 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5086,7 +5086,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w64o %d", (uint64_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w64o %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"30071 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5095,7 +5095,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf8o %d", (uint_fast8_t) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf8o %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"52 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5104,7 +5104,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf16o %d", (uint_fast16_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf16o %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"30071 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5113,7 +5113,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf32o %d", (uint_fast32_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf32o %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"30071 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5122,7 +5122,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf64o %d", (uint_fast64_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf64o %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"30071 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5134,7 +5134,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%hhX %d", (unsigned char) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%hhX %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"2A 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5143,7 +5143,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%hX %d", (unsigned short) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%hX %d", (unsigned short) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"3039 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5152,7 +5152,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%X %d", (unsigned int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%X %d", 12345U, 33, 44, 55);
ASSERT (wcscmp (result, L"3039 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5161,7 +5161,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%lX %d", (unsigned long int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%lX %d", 12345UL, 33, 44, 55);
ASSERT (wcscmp (result, L"3039 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5170,7 +5170,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%llX %d", (unsigned long long int) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%llX %d", 12345ULL, 33, 44, 55);
ASSERT (wcscmp (result, L"3039 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5179,7 +5179,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w8X %d", (uint8_t) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w8X %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"2A 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5188,7 +5188,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w16X %d", (uint16_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w16X %d", (uint16_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"3039 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5197,7 +5197,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w32X %d", (uint32_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w32X %d", (uint32_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"3039 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5206,7 +5206,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%w64X %d", (uint64_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%w64X %d", (uint64_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"3039 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5215,7 +5215,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf8X %d", (uint_fast8_t) 42, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf8X %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (wcscmp (result, L"2A 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5224,7 +5224,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf16X %d", (uint_fast16_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf16X %d", (uint_fast16_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"3039 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5233,7 +5233,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf32X %d", (uint_fast32_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf32X %d", (uint_fast32_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"3039 33") == 0);
ASSERT (length == wcslen (result));
free (result);
@@ -5242,7 +5242,7 @@ test_function (wchar_t * (*my_asnwprintf) (wchar_t *, size_t *, const wchar_t *,
{
size_t length;
wchar_t *result =
my_asnwprintf (NULL, &length, L"%wf64X %d", (uint_fast64_t) 12345, 33, 44, 55);
my_asnwprintf (NULL, &length, L"%wf64X %d", (uint_fast64_t) {12345}, 33, 44, 55);
ASSERT (wcscmp (result, L"3039 33") == 0);
ASSERT (length == wcslen (result));
free (result);

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

@@ -3991,7 +3991,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
free (result);
}
static wint_t L_x = (wchar_t) 'x';
static wint_t L_x = L'x';
{ /* Width. */
char *result;
@@ -4057,7 +4057,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
free (result);
}
static wint_t L_invalid = (wchar_t) 0x76543210;
static wint_t L_invalid = 0x76543210;
{ /* Invalid wide character.
The conversion may succeed or may fail, but it should not abort. */
@@ -4540,7 +4540,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%hhd %d", (signed char) -42, 33, 44, 55);
my_asprintf (&result, "%hhd %d", (signed char) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4549,7 +4549,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%hd %d", (short) -12345, 33, 44, 55);
my_asprintf (&result, "%hd %d", (short) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4567,7 +4567,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%ld %d", (long int) -12345, 33, 44, 55);
my_asprintf (&result, "%ld %d", -12345L, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4576,7 +4576,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%lld %d", (long long int) -12345, 33, 44, 55);
my_asprintf (&result, "%lld %d", -12345LL, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4585,7 +4585,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%w8d %d", (int8_t) -42, 33, 44, 55);
my_asprintf (&result, "%w8d %d", (int8_t) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4594,7 +4594,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%w16d %d", (int16_t) -12345, 33, 44, 55);
my_asprintf (&result, "%w16d %d", (int16_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4603,7 +4603,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%w32d %d", (int32_t) -12345, 33, 44, 55);
my_asprintf (&result, "%w32d %d", (int32_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4612,7 +4612,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%w64d %d", (int64_t) -12345, 33, 44, 55);
my_asprintf (&result, "%w64d %d", (int64_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4621,7 +4621,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%wf8d %d", (int_fast8_t) -42, 33, 44, 55);
my_asprintf (&result, "%wf8d %d", (int_fast8_t) {-42}, 33, 44, 55);
ASSERT (streq (result, "-42 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4630,7 +4630,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%wf16d %d", (int_fast16_t) -12345, 33, 44, 55);
my_asprintf (&result, "%wf16d %d", (int_fast16_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4639,7 +4639,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%wf32d %d", (int_fast32_t) -12345, 33, 44, 55);
my_asprintf (&result, "%wf32d %d", (int_fast32_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4648,7 +4648,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%wf64d %d", (int_fast64_t) -12345, 33, 44, 55);
my_asprintf (&result, "%wf64d %d", (int_fast64_t) {-12345}, 33, 44, 55);
ASSERT (streq (result, "-12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4660,7 +4660,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%hhu %d", (unsigned char) 42, 33, 44, 55);
my_asprintf (&result, "%hhu %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4678,7 +4678,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%u %d", (unsigned int) 12345, 33, 44, 55);
my_asprintf (&result, "%u %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4687,7 +4687,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%lu %d", (unsigned long int) 12345, 33, 44, 55);
my_asprintf (&result, "%lu %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4696,7 +4696,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%llu %d", (unsigned long long int) 12345, 33, 44, 55);
my_asprintf (&result, "%llu %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "12345 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4705,7 +4705,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%w8u %d", (uint8_t) 42, 33, 44, 55);
my_asprintf (&result, "%w8u %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4741,7 +4741,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%wf8u %d", (uint_fast8_t) 42, 33, 44, 55);
my_asprintf (&result, "%wf8u %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "42 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4780,7 +4780,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%hhb %d", (unsigned char) 42, 33, 44, 55);
my_asprintf (&result, "%hhb %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4798,7 +4798,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%b %d", (unsigned int) 12345, 33, 44, 55);
my_asprintf (&result, "%b %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4807,7 +4807,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%lb %d", (unsigned long int) 12345, 33, 44, 55);
my_asprintf (&result, "%lb %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4816,7 +4816,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%llb %d", (unsigned long long int) 12345, 33, 44, 55);
my_asprintf (&result, "%llb %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "11000000111001 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4825,7 +4825,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%w8b %d", (uint8_t) 42, 33, 44, 55);
my_asprintf (&result, "%w8b %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4861,7 +4861,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%wf8b %d", (uint_fast8_t) 42, 33, 44, 55);
my_asprintf (&result, "%wf8b %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "101010 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4900,7 +4900,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%hho %d", (unsigned char) 42, 33, 44, 55);
my_asprintf (&result, "%hho %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4918,7 +4918,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%o %d", (unsigned int) 12345, 33, 44, 55);
my_asprintf (&result, "%o %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4927,7 +4927,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%lo %d", (unsigned long int) 12345, 33, 44, 55);
my_asprintf (&result, "%lo %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4936,7 +4936,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%llo %d", (unsigned long long int) 12345, 33, 44, 55);
my_asprintf (&result, "%llo %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "30071 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4945,7 +4945,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%w8o %d", (uint8_t) 42, 33, 44, 55);
my_asprintf (&result, "%w8o %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -4981,7 +4981,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%wf8o %d", (uint_fast8_t) 42, 33, 44, 55);
my_asprintf (&result, "%wf8o %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "52 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -5020,7 +5020,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%hhX %d", (unsigned char) 42, 33, 44, 55);
my_asprintf (&result, "%hhX %d", (unsigned char) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -5038,7 +5038,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%X %d", (unsigned int) 12345, 33, 44, 55);
my_asprintf (&result, "%X %d", 12345U, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -5047,7 +5047,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%lX %d", (unsigned long int) 12345, 33, 44, 55);
my_asprintf (&result, "%lX %d", 12345UL, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -5056,7 +5056,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%llX %d", (unsigned long long int) 12345, 33, 44, 55);
my_asprintf (&result, "%llX %d", 12345ULL, 33, 44, 55);
ASSERT (streq (result, "3039 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -5065,7 +5065,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%w8X %d", (uint8_t) 42, 33, 44, 55);
my_asprintf (&result, "%w8X %d", (uint8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (retval == strlen (result));
free (result);
@@ -5101,7 +5101,7 @@ test_function (int (*my_asprintf) (char **, const char *, ...))
{
char *result;
int retval =
my_asprintf (&result, "%wf8X %d", (uint_fast8_t) 42, 33, 44, 55);
my_asprintf (&result, "%wf8X %d", (uint_fast8_t) {42}, 33, 44, 55);
ASSERT (streq (result, "2A 33"));
ASSERT (retval == strlen (result));
free (result);

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 = (wchar_t) 0xBADFACE;
wc = 0xBADFACE;
iret = mbtowc (&wc, s, n);
ASSERT (iret == n);

12
tests/test-wcscmp.c
View File

@@ -70,9 +70,9 @@ main (int argc, char *argv[])
subclause order two wide characters the same way as two integers of
the underlying integer type designated by wchar_t." */
{
static const wchar_t input1[] = { (wchar_t) 0x76547654, 0 };
static const wchar_t input2[] = { (wchar_t) 0x9abc9abc, 0 };
if ((wchar_t)-1 < 0)
static const wchar_t input1[] = { 0x76547654, 0 };
static const wchar_t input2[] = { 0x9abc9abc, 0 };
if ((wchar_t) {-1} < 0)
{
/* wchar_t is signed. */
ASSERT (wcscmp (input1, input2) > 0);
@@ -102,9 +102,9 @@ main (int argc, char *argv[])
This means that the comparison extends up to and *including* the first
null wchar_t. */
{
static const wchar_t input1[] = { (wchar_t) 'x', 0 };
static const wchar_t input2[] = { (wchar_t) 'x', (wchar_t) 0x9abc9abc, 0 };
if ((wchar_t)-1 < 0)
static const wchar_t input1[] = { L'x', 0 };
static const wchar_t input2[] = { L'x', 0x9abc9abc, 0 };
if ((wchar_t) {-1} < 0)
{
/* wchar_t is signed. */
ASSERT (wcscmp (input1, input2) > 0);

12
tests/test-wcsncmp.c
View File

@@ -118,10 +118,10 @@ main (int argc, char *argv[])
subclause order two wide characters the same way as two integers of
the underlying integer type designated by wchar_t." */
{
static const wchar_t input1[] = { (wchar_t) 0x76547654, 0 };
static const wchar_t input2[] = { (wchar_t) 0x9abc9abc, 0 };
static const wchar_t input1[] = { 0x76547654, 0 };
static const wchar_t input2[] = { 0x9abc9abc, 0 };
ASSERT (wcsncmp (input1, input2, 0) == 0);
if ((wchar_t)-1 < 0)
if ((wchar_t) {-1} < 0)
{
/* wchar_t is signed. */
ASSERT (wcsncmp (input1, input2, 1) > 0);
@@ -164,11 +164,11 @@ main (int argc, char *argv[])
This means that the comparison extends up to and *including* the first
null wchar_t. */
{
static const wchar_t input1[] = { (wchar_t) 'x', 0 };
static const wchar_t input2[] = { (wchar_t) 'x', (wchar_t) 0x9abc9abc, 0 };
static const wchar_t input1[] = { L'x', 0 };
static const wchar_t input2[] = { L'x', 0x9abc9abc, 0 };
ASSERT (wcsncmp (input1, input2, 0) == 0);
ASSERT (wcsncmp (input1, input2, 1) == 0);
if ((wchar_t)-1 < 0)
if ((wchar_t) {-1} < 0)
{
/* wchar_t is signed. */
ASSERT (wcsncmp (input1, input2, 2) > 0);

6
tests/test-wmemcmp.c
View File

@@ -80,9 +80,9 @@ main (int argc, char *argv[])
subclause order two wide characters the same way as two integers of
the underlying integer type designated by wchar_t." */
{
static const wchar_t input1[] = { (wchar_t) 0x76547654 };
static const wchar_t input2[] = { (wchar_t) 0x9abc9abc };
if ((wchar_t)-1 < 0)
static const wchar_t input1[] = { 0x76547654 };
static const wchar_t input2[] = { 0x9abc9abc };
if ((wchar_t) {-1} < 0)
{
/* wchar_t is signed. */
ASSERT (wmemcmp (input1, input2, 1) > 0);

6
tests/uniwidth/test-uc_width2.c
View File

@@ -36,10 +36,10 @@ finish_interval (void)
if (current_width != 0)
{
if (current_start == current_end)
printf ("%04X\t\t%c\n", (unsigned) current_start, current_width);
printf ("%04X\t\t%c\n", (unsigned) {current_start}, current_width);
else
printf ("%04X..%04X\t%c\n", (unsigned) current_start,
(unsigned) current_end, current_width);
printf ("%04X..%04X\t%c\n", (unsigned) {current_start},
(unsigned) {current_end}, current_width);
current_width = 0;
}
}