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):
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)
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;
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.
size_t ret;
memset (&state, '\0', sizeof (mbstate_t));
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == 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);
size_t ret;
memset (&state, '\0', sizeof (mbstate_t));
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == 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);
size_t ret;
memset (&state, '\0', sizeof (mbstate_t));
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == 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);
size_t ret;
memset (&state, '\0', sizeof (mbstate_t));
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == 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);
size_t ret;
memset (&state, '\0', sizeof (mbstate_t));
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == 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);
size_t ret;
memset (&state, '\0', sizeof (mbstate_t));
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == 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);
size_t ret;
memset (&state, '\0', sizeof (mbstate_t));
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
iret = mbrtoc32 (&wc, s, n, &state);
ASSERT (iret == 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);
struct multibyte result;
memset (&state, '\0', sizeof (mbstate_t));
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, s, n, &state);
ASSERT (ret == n);
/* 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);
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;
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;
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;
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;
/* 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);
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);
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);
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);
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))
/* 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));
/* 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);
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);
/* 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));
}
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');
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');
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');
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');
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');
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');
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');
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);
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);
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);
input[7] = '\0';
input[8] = '\0';
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 9, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '!');
/* 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);
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);
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);
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);
input[5] = '\0';
input[6] = '\0';
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
/* 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));
}
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);
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);
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);
input[5] = '\0';
input[6] = '\0';
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
/* 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 == '?'));
}
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);
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);
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);
input[5] = '\0';
input[6] = '\0';
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
/* 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 == '?'));
}
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);
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);
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);
input[9] = '\0';
input[10] = '\0';
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 11, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '!');
/* 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);
/* 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));
/* 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);
/* 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);
/* 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));
}
/* 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
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');
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');
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');
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);
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);
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);
input[7] = '\0';
input[8] = '\0';
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 9, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '!');
{ /* \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 */
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);
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);
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);
input[5] = '\0';
input[6] = '\0';
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
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);
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);
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);
input[9] = '\0';
input[10] = '\0';
- wc = (char32_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtoc32 (&wc, input + 11, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '!');
{ /* \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
/* 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).
/* 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);
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);
/* 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));
}
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');
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');
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');
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');
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');
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');
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);
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);
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');
/* 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);
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);
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);
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);
input[5] = '\0';
input[6] = '\0';
- wc = (wchar_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
/* 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));
}
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);
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);
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);
input[5] = '\0';
input[6] = '\0';
- wc = (wchar_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
/* 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 == '?'));
}
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);
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);
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);
input[5] = '\0';
input[6] = '\0';
- wc = (wchar_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
/* 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 == '?'));
}
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);
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);
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');
/* 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);
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);
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);
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');
/* 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);
/* 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));
/* 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);
/* 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);
/* 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));
}
/* 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." */
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');
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');
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);
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);
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');
{ /* \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);
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);
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);
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);
input[5] = '\0';
input[6] = '\0';
- wc = (wchar_t) 0xBADFACE;
+ wc = 0xBADFACE;
ret = mbrtowc (&wc, input + 7, 1, &state);
ASSERT (ret == 1);
ASSERT (wc == '>');
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);
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);
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');
{ /* \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);
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);
mbstate_t temp_state;
for (size_t i = 0; i < BUFSIZE; i++)
- buf[i] = (char32_t) 0xBADFACE;
+ buf[i] = 0xBADFACE;
switch (argv[1][0])
{
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));
}
{
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
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');
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;
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';
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;
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);
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';
{
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;
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';
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;
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);
mbstate_t temp_state;
for (size_t i = 0; i < BUFSIZE; i++)
- buf[i] = (wchar_t) 0xBADFACE;
+ buf[i] = 0xBADFACE;
switch (argv[1][0])
{
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));
}
{
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
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');
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;
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';
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;
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);
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';
{
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;
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';
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;
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);
mbstate_t temp_state;
for (size_t i = 0; i < BUFSIZE; i++)
- buf[i] = (char32_t) 0xBADFACE;
+ buf[i] = 0xBADFACE;
switch (argv[1][0])
{
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));
}
{
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
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');
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;
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';
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;
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);
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';
{
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;
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';
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;
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);
mbstate_t temp_state;
for (size_t i = 0; i < BUFSIZE; i++)
- buf[i] = (wchar_t) 0xBADFACE;
+ buf[i] = 0xBADFACE;
switch (argv[1][0])
{
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));
}
{
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
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');
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;
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';
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;
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);
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';
{
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;
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';
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;
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);
const char *src;
for (size_t i = 0; i < BUFSIZE; i++)
- buf[i] = (char32_t) 0xBADFACE;
+ buf[i] = 0xBADFACE;
switch (argv[1][0])
{
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];
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
{
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');
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;
{
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 */
{
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;
{
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);
{
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;
{
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);
{
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;
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);
const char *src;
for (size_t i = 0; i < BUFSIZE; i++)
- buf[i] = (wchar_t) 0xBADFACE;
+ buf[i] = 0xBADFACE;
switch (argv[1][0])
{
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];
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
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;
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;
{
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;
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;
{
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;
}
}
ASSERT (retval == 6);
}
- static wint_t L_x = (wchar_t) 'x';
+ static wint_t L_x = L'x';
{ /* Width. */
int retval =
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. */
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
ASSERT (retval == 6);
}
- static wint_t L_x = (wchar_t) 'x';
+ static wint_t L_x = L'x';
{ /* Width. */
int retval =
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. */
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
{
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));
}
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);
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");
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;
/* 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);
/* 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)
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)
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)
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)
free (result);
}
- static wint_t L_x = (wchar_t) 'x';
+ static wint_t L_x = L'x';
{ /* Width. */
size_t length;
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. */
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
/* 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)
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)
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)
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)
}
#endif
- static wint_t L_x = (wchar_t) 'x';
+ static wint_t L_x = L'x';
{ /* Width. */
size_t length;
free (result);
}
- static wint_t L_invalid = (wchar_t) 0x76543210;
+ static wint_t L_invalid = 0x76543210;
{ /* Invalid wide character. */
size_t length;
/* 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);
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
free (result);
}
- static wint_t L_x = (wchar_t) 'x';
+ static wint_t L_x = L'x';
{ /* Width. */
char *result;
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. */
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
int iret;
size_t ret;
- wc = (wchar_t) 0xBADFACE;
+ wc = 0xBADFACE;
iret = mbtowc (&wc, s, n);
ASSERT (iret == n);
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);
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);
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);
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);
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);
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;
}
}
projects / thirdparty / gnulib.git / commitdiff
