[thirdparty/glibc.git] / string / test-strncat.c

/* Test strncat functions.
   Copyright (C) 2011-2019 Free Software Foundation, Inc.
   Contributed by Intel Corporation.

   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
   <http://www.gnu.org/licenses/>.  */

#define TEST_MAIN
#ifndef WIDE
# define TEST_NAME "strncat"
#else
# define TEST_NAME "wcsncat"
#endif /* WIDE */
#include "test-string.h"

#ifndef WIDE
# define STRNCAT strncat
# define CHAR char
# define UCHAR unsigned char
# define SIMPLE_STRNCAT simple_strncat
# define STUPID_STRNCAT stupid_strncat
# define STRLEN strlen
# define MEMSET memset
# define MEMCPY memcpy
# define MEMCMP memcmp
# define BIG_CHAR CHAR_MAX
# define SMALL_CHAR 127
#else
# include <wchar.h>
# define STRNCAT wcsncat
# define CHAR wchar_t
# define UCHAR wchar_t
# define SIMPLE_STRNCAT simple_wcsncat
# define STUPID_STRNCAT stupid_wcsncat
# define STRLEN wcslen
# define MEMSET wmemset
# define MEMCPY wmemcpy
# define MEMCMP wmemcmp
# define BIG_CHAR WCHAR_MAX
# define SMALL_CHAR 1273
#endif /* WIDE */

typedef CHAR *(*proto_t) (CHAR *, const CHAR *, size_t);
CHAR *STUPID_STRNCAT (CHAR *, const CHAR *, size_t);
CHAR *SIMPLE_STRNCAT (CHAR *, const CHAR *, size_t);

IMPL (STUPID_STRNCAT, 0)
IMPL (STRNCAT, 2)

CHAR *
STUPID_STRNCAT (CHAR *dst, const CHAR *src, size_t n)
{
  CHAR *ret = dst;
  while (*dst++ != '\0');
  --dst;
  while (n--)
    if ((*dst++ = *src++) == '\0')
      return ret;
  *dst = '\0';
  return ret;
}

static void
do_one_test (impl_t *impl, CHAR *dst, const CHAR *src, size_t n)
{
  size_t k = STRLEN (dst);
  if (CALL (impl, dst, src, n) != dst)
    {
      error (0, 0, "Wrong result in function %s %p != %p", impl->name,
	     CALL (impl, dst, src, n), dst);
      ret = 1;
      return;
    }

  size_t len = STRLEN (src);
  if (MEMCMP (dst + k, src, len + 1 > n ? n : len + 1) != 0)
    {
      error (0, 0, "Incorrect concatenation in function %s",
	     impl->name);
      ret = 1;
      return;
    }
  if (n < len && dst[k + n] != '\0')
    {
      error (0, 0, "There is no zero in the end of output string in %s",
	     impl->name);
      ret = 1;
      return;
    }
}

static void
do_test (size_t align1, size_t align2, size_t len1, size_t len2,
	 size_t n, int max_char)
{
  size_t i;
  CHAR *s1, *s2;

  align1 &= 7;
  if ((align1 + len1) * sizeof (CHAR) >= page_size)
    return;
  if ((align1 + n) * sizeof (CHAR) > page_size)
    return;
  align2 &= 7;
  if ((align2 + len1 + len2) * sizeof (CHAR) >= page_size)
    return;
  if ((align2 + len1 + n) * sizeof (CHAR) > page_size)
    return;
  s1 = (CHAR *) (buf1) + align1;
  s2 = (CHAR *) (buf2) + align2;

  for (i = 0; i < len1; ++i)
    s1[i] = 32 + 23 * i % (max_char - 32);
  s1[len1] = '\0';

  for (i = 0; i < len2; i++)
    s2[i] = 32 + 23 * i % (max_char - 32);

  FOR_EACH_IMPL (impl, 0)
    {
      s2[len2] = '\0';
      do_one_test (impl, s2, s1, n);
    }
}

static void
do_random_tests (void)
{
  size_t i, j, n, align1, align2, len1, len2, N;
  UCHAR *p1 = (UCHAR *) (buf1 + page_size) - 512;
  UCHAR *p2 = (UCHAR *) (buf2 + page_size) - 512;
  UCHAR *p3 = (UCHAR *) buf1;
  UCHAR *res;
  fprintf (stdout, "Number of iterations in random test = %zd\n",
	   ITERATIONS);
  for (n = 0; n < ITERATIONS; n++)
    {
      N = random () & 255;
      align1 = random () & 31;
      if (random () & 1)
	align2 = random () & 31;
      else
	align2 = align1 + (random () & 24);
      len1 = random () & 511;
      if (len1 + align2 > 512)
	len2 = random () & 7;
      else
	len2 = (512 - len1 - align2) * (random () & (1024 * 1024 - 1))
	  / (1024 * 1024);
      j = align1;
      if (align2 + len2 > j)
	j = align2 + len2;
      if (len1 + j >= 511)
	len1 = 510 - j - (random () & 7);
      if (len1 >= 512)
	len1 = 0;
      if (align1 + len1 < 512 - 8)
	{
	  j = 510 - align1 - len1 - (random () & 31);
	  if (j > 0 && j < 512)
	    align1 += j;
	}
      j = len1 + align1 + 64;
      if (j > 512)
	j = 512;
      for (i = 0; i < j; i++)
	{
	  if (i == len1 + align1)
	    p1[i] = 0;
	  else
	    {
	      p1[i] = random () & BIG_CHAR;
	      if (i >= align1 && i < len1 + align1 && !p1[i])
		p1[i] = (random () & SMALL_CHAR) + 3;
	    }
	}
      for (i = 0; i < len2; i++)
	{
	  p3[i] = random () & BIG_CHAR;
	  if (!p3[i])
	    p3[i] = (random () & SMALL_CHAR) + 3;
	}
      p3[len2] = 0;

      FOR_EACH_IMPL (impl, 1)
	{
	  MEMSET (p2 - 64, '\1', align2 + 64);
	  MEMSET (p2 + align2 + len2 + 1, '\1', 512 - align2 - len2 - 1);
	  MEMCPY (p2 + align2, p3, len2 + 1);
	  res = (UCHAR *) CALL (impl, (CHAR *) (p2 + align2),
				(CHAR *) (p1 + align1), N);
	  if (res != p2 + align2)
	    {
	      error (0, 0, "Iteration %zd - wrong result in function %s "
		     "(%zd, %zd, %zd, %zd, %zd) %p != %p",
		     n, impl->name, align1, align2, len1, len2, N,
		     res, p2 + align2);
	      ret = 1;
	    }
	  for (j = 0; j < align2 + 64; ++j)
	    {
	      if (p2[j - 64] != '\1')
		{
		  error (0, 0, "Iteration %zd - garbage before dst, %s "
			 "%zd, %zd, %zd, %zd, %zd)",
			 n, impl->name, align1, align2, len1, len2, N);
		  ret = 1;
		  break;
		}
	    }
	  if (MEMCMP (p2 + align2, p3, len2))
	    {
	      error (0, 0, "Iteration %zd - garbage in string before, %s "
		     "(%zd, %zd, %zd, %zd, %zd)",
		     n, impl->name, align1, align2, len1, len2, N);
	      ret = 1;
	    }

	  if ((len1 + 1) > N)
	    j = align2 + N + 1 + len2;
	  else
	    j = align2 + len1 + 1 + len2;
	  for (; j < 512; ++j)
	    {
	      if (p2[j] != '\1')
		{
		  error (0, 0, "Iteration %zd - garbage after, %s "
			 "(%zd, %zd, %zd, %zd, %zd)",
			 n, impl->name, align1, align2, len1, len2, N);
		  ret = 1;
		  break;
		}
	    }
	  if (len1 + 1 > N)
	    {
	      if (p2[align2 + N + len2] != '\0')
		{
		  error (0, 0, "Iteration %zd - there is no zero at the "
			 "end of output string, %s (%zd, %zd, %zd, %zd, %zd)",
			 n, impl->name, align1, align2, len1, len2, N);
		  ret = 1;
		}
	    }
	  if (MEMCMP (p1 + align1, p2 + align2 + len2,
		      (len1 + 1) > N ? N : len1 + 1))
	    {
	      error (0, 0, "Iteration %zd - different strings, %s "
		     "(%zd, %zd, %zd, %zd, %zd)",
		     n, impl->name, align1, align2, len1, len2, N);
	      ret = 1;
	    }
	}
    }
}

int
test_main (void)
{
  size_t i, n;

  test_init ();

  printf ("%28s", "");
  FOR_EACH_IMPL (impl, 0)
    printf ("\t%s", impl->name);
  putchar ('\n');

  for (n = 2; n <= 2048; n*=4)
    {
      do_test (0, 2, 2, 2, n, SMALL_CHAR);
      do_test (0, 0, 4, 4, n, SMALL_CHAR);
      do_test (4, 0, 4, 4, n, BIG_CHAR);
      do_test (0, 0, 8, 8, n, SMALL_CHAR);
      do_test (0, 8, 8, 8, n, SMALL_CHAR);

      do_test (0, 2, 2, 2, SIZE_MAX, SMALL_CHAR);
      do_test (0, 0, 4, 4, SIZE_MAX, SMALL_CHAR);
      do_test (4, 0, 4, 4, SIZE_MAX, BIG_CHAR);
      do_test (0, 0, 8, 8, SIZE_MAX, SMALL_CHAR);
      do_test (0, 8, 8, 8, SIZE_MAX, SMALL_CHAR);

      for (i = 1; i < 8; ++i)
	{
	  do_test (0, 0, 8 << i, 8 << i, n, SMALL_CHAR);
	  do_test (8 - i, 2 * i, 8 << i, 8 << i, n, SMALL_CHAR);
	  do_test (0, 0, 8 << i, 2 << i, n, SMALL_CHAR);
	  do_test (8 - i, 2 * i, 8 << i, 2 << i, n, SMALL_CHAR);

	  do_test (0, 0, 8 << i, 8 << i, SIZE_MAX, SMALL_CHAR);
	  do_test (8 - i, 2 * i, 8 << i, 8 << i, SIZE_MAX, SMALL_CHAR);
	  do_test (0, 0, 8 << i, 2 << i, SIZE_MAX, SMALL_CHAR);
	  do_test (8 - i, 2 * i, 8 << i, 2 << i, SIZE_MAX, SMALL_CHAR);
	}

      for (i = 1; i < 8; ++i)
	{
	  do_test (i, 2 * i, 8 << i, 1, n, SMALL_CHAR);
	  do_test (2 * i, i, 8 << i, 1, n, BIG_CHAR);
	  do_test (i, i, 8 << i, 10, n, SMALL_CHAR);

	  do_test (i, 2 * i, 8 << i, 1, SIZE_MAX, SMALL_CHAR);
	  do_test (2 * i, i, 8 << i, 1, SIZE_MAX, BIG_CHAR);
	  do_test (i, i, 8 << i, 10, SIZE_MAX, SMALL_CHAR);
	}
    }

  do_random_tests ();
  return ret;
}

#include <support/test-driver.c>
Commit	Line	Data
e1fe9118	1	/* Test strncat functions.
04277e02	2	Copyright (C) 2011-2019 Free Software Foundation, Inc.
6f0eec67 UD	3	Contributed by Intel Corporation.
	4
	5	The GNU C Library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	16	License along with the GNU C Library; if not, see
59ba27a6 PE	17	<http://www.gnu.org/licenses/>. */
6f0eec67 UD	18
6f0eec67 UD	19	#define TEST_MAIN
e1fe9118 SL	20	#ifndef WIDE
	21	# define TEST_NAME "strncat"
	22	#else
	23	# define TEST_NAME "wcsncat"
	24	#endif /* WIDE */
6f0eec67 UD	25	#include "test-string.h"
6f0eec67 UD	26
e1fe9118 SL	27	#ifndef WIDE
	28	# define STRNCAT strncat
	29	# define CHAR char
	30	# define UCHAR unsigned char
	31	# define SIMPLE_STRNCAT simple_strncat
	32	# define STUPID_STRNCAT stupid_strncat
	33	# define STRLEN strlen
	34	# define MEMSET memset
	35	# define MEMCPY memcpy
	36	# define MEMCMP memcmp
	37	# define BIG_CHAR CHAR_MAX
	38	# define SMALL_CHAR 127
	39	#else
	40	# include <wchar.h>
	41	# define STRNCAT wcsncat
	42	# define CHAR wchar_t
	43	# define UCHAR wchar_t
	44	# define SIMPLE_STRNCAT simple_wcsncat
	45	# define STUPID_STRNCAT stupid_wcsncat
	46	# define STRLEN wcslen
	47	# define MEMSET wmemset
	48	# define MEMCPY wmemcpy
	49	# define MEMCMP wmemcmp
	50	# define BIG_CHAR WCHAR_MAX
	51	# define SMALL_CHAR 1273
	52	#endif /* WIDE */
6f0eec67	53
e1fe9118 SL	54	typedef CHAR (proto_t) (CHAR , const CHAR , size_t);
	55	CHAR STUPID_STRNCAT (CHAR , const CHAR *, size_t);
	56	CHAR SIMPLE_STRNCAT (CHAR , const CHAR *, size_t);
6f0eec67	57
e1fe9118 SL	58	IMPL (STUPID_STRNCAT, 0)
	59	IMPL (STRNCAT, 2)
	60
	61	CHAR *
	62	STUPID_STRNCAT (CHAR dst, const CHAR src, size_t n)
6f0eec67	63	{
e1fe9118	64	CHAR *ret = dst;
6f0eec67 UD	65	while (*dst++ != '\0');
	66	--dst;
	67	while (n--)
e1fe9118	68	if ((dst++ = src++) == '\0')
6f0eec67 UD	69	return ret;
	70	*dst = '\0';
	71	return ret;
	72	}
	73
	74	static void
e1fe9118	75	do_one_test (impl_t impl, CHAR dst, const CHAR *src, size_t n)
6f0eec67	76	{
e1fe9118	77	size_t k = STRLEN (dst);
6f0eec67 UD	78	if (CALL (impl, dst, src, n) != dst)
	79	{
	80	error (0, 0, "Wrong result in function %s %p != %p", impl->name,
	81	CALL (impl, dst, src, n), dst);
	82	ret = 1;
	83	return;
	84	}
	85
e1fe9118 SL	86	size_t len = STRLEN (src);
e1fe9118 SL	87	if (MEMCMP (dst + k, src, len + 1 > n ? n : len + 1) != 0)
6f0eec67	88	{
e1fe9118	89	error (0, 0, "Incorrect concatenation in function %s",
6f0eec67 UD	90	impl->name);
	91	ret = 1;
	92	return;
	93	}
	94	if (n < len && dst[k + n] != '\0')
	95	{
	96	error (0, 0, "There is no zero in the end of output string in %s",
	97	impl->name);
	98	ret = 1;
	99	return;
	100	}
6f0eec67 UD	101	}
	102
	103	static void
	104	do_test (size_t align1, size_t align2, size_t len1, size_t len2,
	105	size_t n, int max_char)
	106	{
	107	size_t i;
e1fe9118	108	CHAR s1, s2;
6f0eec67 UD	109
6f0eec67 UD	110	align1 &= 7;
e1fe9118	111	if ((align1 + len1) * sizeof (CHAR) >= page_size)
6f0eec67	112	return;
e1fe9118	113	if ((align1 + n) * sizeof (CHAR) > page_size)
6f0eec67 UD	114	return;
6f0eec67 UD	115	align2 &= 7;
e1fe9118	116	if ((align2 + len1 + len2) * sizeof (CHAR) >= page_size)
6f0eec67	117	return;
e1fe9118	118	if ((align2 + len1 + n) * sizeof (CHAR) > page_size)
6f0eec67	119	return;
e1fe9118 SL	120	s1 = (CHAR *) (buf1) + align1;
e1fe9118 SL	121	s2 = (CHAR *) (buf2) + align2;
6f0eec67 UD	122
	123	for (i = 0; i < len1; ++i)
	124	s1[i] = 32 + 23 * i % (max_char - 32);
	125	s1[len1] = '\0';
	126
	127	for (i = 0; i < len2; i++)
	128	s2[i] = 32 + 23 * i % (max_char - 32);
	129
6f0eec67 UD	130	FOR_EACH_IMPL (impl, 0)
	131	{
	132	s2[len2] = '\0';
	133	do_one_test (impl, s2, s1, n);
	134	}
6f0eec67 UD	135	}
	136
	137	static void
	138	do_random_tests (void)
	139	{
	140	size_t i, j, n, align1, align2, len1, len2, N;
e1fe9118 SL	141	UCHAR p1 = (UCHAR ) (buf1 + page_size) - 512;
	142	UCHAR p2 = (UCHAR ) (buf2 + page_size) - 512;
	143	UCHAR p3 = (UCHAR ) buf1;
	144	UCHAR *res;
6f0eec67 UD	145	fprintf (stdout, "Number of iterations in random test = %zd\n",
	146	ITERATIONS);
	147	for (n = 0; n < ITERATIONS; n++)
	148	{
	149	N = random () & 255;
	150	align1 = random () & 31;
	151	if (random () & 1)
	152	align2 = random () & 31;
	153	else
	154	align2 = align1 + (random () & 24);
	155	len1 = random () & 511;
	156	if (len1 + align2 > 512)
	157	len2 = random () & 7;
	158	else
	159	len2 = (512 - len1 - align2) * (random () & (1024 * 1024 - 1))
	160	/ (1024 * 1024);
	161	j = align1;
	162	if (align2 + len2 > j)
	163	j = align2 + len2;
	164	if (len1 + j >= 511)
	165	len1 = 510 - j - (random () & 7);
	166	if (len1 >= 512)
	167	len1 = 0;
	168	if (align1 + len1 < 512 - 8)
	169	{
	170	j = 510 - align1 - len1 - (random () & 31);
	171	if (j > 0 && j < 512)
	172	align1 += j;
	173	}
	174	j = len1 + align1 + 64;
	175	if (j > 512)
	176	j = 512;
	177	for (i = 0; i < j; i++)
	178	{
	179	if (i == len1 + align1)
	180	p1[i] = 0;
	181	else
	182	{
e1fe9118	183	p1[i] = random () & BIG_CHAR;
6f0eec67	184	if (i >= align1 && i < len1 + align1 && !p1[i])
e1fe9118	185	p1[i] = (random () & SMALL_CHAR) + 3;
6f0eec67 UD	186	}
	187	}
	188	for (i = 0; i < len2; i++)
	189	{
e1fe9118 SL	190	p3[i] = random () & BIG_CHAR;
	191	if (!p3[i])
	192	p3[i] = (random () & SMALL_CHAR) + 3;
6f0eec67	193	}
e1fe9118	194	p3[len2] = 0;
6f0eec67 UD	195
	196	FOR_EACH_IMPL (impl, 1)
	197	{
e1fe9118 SL	198	MEMSET (p2 - 64, '\1', align2 + 64);
	199	MEMSET (p2 + align2 + len2 + 1, '\1', 512 - align2 - len2 - 1);
	200	MEMCPY (p2 + align2, p3, len2 + 1);
	201	res = (UCHAR ) CALL (impl, (CHAR ) (p2 + align2),
	202	(CHAR *) (p1 + align1), N);
6f0eec67 UD	203	if (res != p2 + align2)
	204	{
	205	error (0, 0, "Iteration %zd - wrong result in function %s "
	206	"(%zd, %zd, %zd, %zd, %zd) %p != %p",
	207	n, impl->name, align1, align2, len1, len2, N,
	208	res, p2 + align2);
	209	ret = 1;
	210	}
	211	for (j = 0; j < align2 + 64; ++j)
	212	{
	213	if (p2[j - 64] != '\1')
	214	{
	215	error (0, 0, "Iteration %zd - garbage before dst, %s "
	216	"%zd, %zd, %zd, %zd, %zd)",
	217	n, impl->name, align1, align2, len1, len2, N);
	218	ret = 1;
	219	break;
	220	}
	221	}
e1fe9118	222	if (MEMCMP (p2 + align2, p3, len2))
6f0eec67 UD	223	{
	224	error (0, 0, "Iteration %zd - garbage in string before, %s "
	225	"(%zd, %zd, %zd, %zd, %zd)",
	226	n, impl->name, align1, align2, len1, len2, N);
	227	ret = 1;
	228	}
	229
	230	if ((len1 + 1) > N)
	231	j = align2 + N + 1 + len2;
	232	else
	233	j = align2 + len1 + 1 + len2;
	234	for (; j < 512; ++j)
	235	{
	236	if (p2[j] != '\1')
	237	{
	238	error (0, 0, "Iteration %zd - garbage after, %s "
	239	"(%zd, %zd, %zd, %zd, %zd)",
	240	n, impl->name, align1, align2, len1, len2, N);
	241	ret = 1;
	242	break;
	243	}
	244	}
	245	if (len1 + 1 > N)
	246	{
	247	if (p2[align2 + N + len2] != '\0')
	248	{
	249	error (0, 0, "Iteration %zd - there is no zero at the "
	250	"end of output string, %s (%zd, %zd, %zd, %zd, %zd)",
	251	n, impl->name, align1, align2, len1, len2, N);
	252	ret = 1;
	253	}
	254	}
e1fe9118	255	if (MEMCMP (p1 + align1, p2 + align2 + len2,
6f0eec67 UD	256	(len1 + 1) > N ? N : len1 + 1))
	257	{
	258	error (0, 0, "Iteration %zd - different strings, %s "
	259	"(%zd, %zd, %zd, %zd, %zd)",
	260	n, impl->name, align1, align2, len1, len2, N);
	261	ret = 1;
	262	}
	263	}
	264	}
	265	}
	266
	267	int
e1fe9118	268	test_main (void)
6f0eec67 UD	269	{
	270	size_t i, n;
	271
	272	test_init ();
	273
	274	printf ("%28s", "");
	275	FOR_EACH_IMPL (impl, 0)
	276	printf ("\t%s", impl->name);
	277	putchar ('\n');
	278
	279	for (n = 2; n <= 2048; n*=4)
	280	{
e1fe9118 SL	281	do_test (0, 2, 2, 2, n, SMALL_CHAR);
	282	do_test (0, 0, 4, 4, n, SMALL_CHAR);
	283	do_test (4, 0, 4, 4, n, BIG_CHAR);
	284	do_test (0, 0, 8, 8, n, SMALL_CHAR);
	285	do_test (0, 8, 8, 8, n, SMALL_CHAR);
6f0eec67	286
8dad7299 AZ	287	do_test (0, 2, 2, 2, SIZE_MAX, SMALL_CHAR);
	288	do_test (0, 0, 4, 4, SIZE_MAX, SMALL_CHAR);
	289	do_test (4, 0, 4, 4, SIZE_MAX, BIG_CHAR);
	290	do_test (0, 0, 8, 8, SIZE_MAX, SMALL_CHAR);
	291	do_test (0, 8, 8, 8, SIZE_MAX, SMALL_CHAR);
	292
6f0eec67 UD	293	for (i = 1; i < 8; ++i)
6f0eec67 UD	294	{
e1fe9118 SL	295	do_test (0, 0, 8 << i, 8 << i, n, SMALL_CHAR);
	296	do_test (8 - i, 2 * i, 8 << i, 8 << i, n, SMALL_CHAR);
	297	do_test (0, 0, 8 << i, 2 << i, n, SMALL_CHAR);
	298	do_test (8 - i, 2 * i, 8 << i, 2 << i, n, SMALL_CHAR);
8dad7299 AZ	299
	300	do_test (0, 0, 8 << i, 8 << i, SIZE_MAX, SMALL_CHAR);
	301	do_test (8 - i, 2 * i, 8 << i, 8 << i, SIZE_MAX, SMALL_CHAR);
	302	do_test (0, 0, 8 << i, 2 << i, SIZE_MAX, SMALL_CHAR);
	303	do_test (8 - i, 2 * i, 8 << i, 2 << i, SIZE_MAX, SMALL_CHAR);
6f0eec67 UD	304	}
	305
	306	for (i = 1; i < 8; ++i)
	307	{
e1fe9118 SL	308	do_test (i, 2 * i, 8 << i, 1, n, SMALL_CHAR);
	309	do_test (2 * i, i, 8 << i, 1, n, BIG_CHAR);
	310	do_test (i, i, 8 << i, 10, n, SMALL_CHAR);
8dad7299 AZ	311
	312	do_test (i, 2 * i, 8 << i, 1, SIZE_MAX, SMALL_CHAR);
	313	do_test (2 * i, i, 8 << i, 1, SIZE_MAX, BIG_CHAR);
	314	do_test (i, i, 8 << i, 10, SIZE_MAX, SMALL_CHAR);
6f0eec67 UD	315	}
	316	}
	317
	318	do_random_tests ();
	319	return ret;
	320	}
e1fe9118	321
fb82116f	322	#include <support/test-driver.c>