glibc/stdio-common/tst-printf-bz25691.c

109 lines
3.5 KiB
C

/* Test for memory leak with large width (BZ#25691).
Copyright (C) 2020-2024 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <stdint.h>
#include <locale.h>
#include <mcheck.h>
#include <support/check.h>
#include <support/support.h>
static int
do_test (void)
{
mtrace ();
/* For 's' conversion specifier with 'l' modifier the array must be
converted to multibyte characters up to the precision specific
value. */
{
/* The input size value is to force a heap allocation on temporary
buffer (in the old implementation). */
const size_t winputsize = 64 * 1024 + 1;
wchar_t *winput = xmalloc (winputsize * sizeof (wchar_t));
wmemset (winput, L'a', winputsize - 1);
winput[winputsize - 1] = L'\0';
char result[9];
const char expected[] = "aaaaaaaa";
int ret;
ret = snprintf (result, sizeof (result), "%.65537ls", winput);
TEST_COMPARE (ret, winputsize - 1);
TEST_COMPARE_BLOB (result, sizeof (result), expected, sizeof (expected));
ret = snprintf (result, sizeof (result), "%ls", winput);
TEST_COMPARE (ret, winputsize - 1);
TEST_COMPARE_BLOB (result, sizeof (result), expected, sizeof (expected));
free (winput);
}
/* For 's' conversion specifier the array is interpreted as a multibyte
character sequence and converted to wide characters up to the precision
specific value. */
{
/* The input size value is to force a heap allocation on temporary
buffer (in the old implementation). */
const size_t mbssize = 32 * 1024;
char *mbs = xmalloc (mbssize);
memset (mbs, 'a', mbssize - 1);
mbs[mbssize - 1] = '\0';
const size_t expectedsize = 32 * 1024;
wchar_t *expected = xmalloc (expectedsize * sizeof (wchar_t));
wmemset (expected, L'a', expectedsize - 1);
expected[expectedsize-1] = L'\0';
const size_t resultsize = mbssize * sizeof (wchar_t);
wchar_t *result = xmalloc (resultsize);
int ret;
ret = swprintf (result, mbssize, L"%.65537s", mbs);
TEST_COMPARE (ret, mbssize - 1);
TEST_COMPARE_BLOB (result, (ret + 1) * sizeof (wchar_t),
expected, expectedsize * sizeof (wchar_t));
ret = swprintf (result, mbssize, L"%1$.65537s", mbs);
TEST_COMPARE (ret, mbssize - 1);
TEST_COMPARE_BLOB (result, (ret + 1) * sizeof (wchar_t),
expected, expectedsize * sizeof (wchar_t));
/* Same test, but with an invalid multibyte sequence. */
mbs[mbssize - 2] = 0xff;
ret = swprintf (result, mbssize, L"%.65537s", mbs);
TEST_COMPARE (ret, -1);
ret = swprintf (result, mbssize, L"%1$.65537s", mbs);
TEST_COMPARE (ret, -1);
free (mbs);
free (result);
free (expected);
}
return 0;
}
#include <support/test-driver.c>