[thirdparty/glibc.git] / string / stratcliff.c

/* Test for string function add boundaries of usable memory.
   Copyright (C) 1996-2015 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.

   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 _GNU_SOURCE 1

/* Make sure we don't test the optimized inline functions if we want to
   test the real implementation.  */
#undef __USE_STRING_INLINES

#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/param.h>

#ifndef CHAR
# define L(c) c
# define CHAR char
# define MEMSET memset
# define STRLEN strlen
# define STRNLEN strnlen
# define STRCHR strchr
# define STRRCHR strrchr
# define STRCPY strcpy
# define STRNCPY strncpy
# define MEMCMP memcmp
# define STPCPY stpcpy
# define STPNCPY stpncpy
# define MEMCPY memcpy
# define MEMPCPY mempcpy
# define MEMCHR memchr
# define STRCMP strcmp
# define STRNCMP strncmp
#endif


#define STRINGIFY(s) STRINGIFY2 (s)
#define STRINGIFY2(s) #s


static int
do_test (void)
{
  int size = sysconf (_SC_PAGESIZE);
  int nchars = size / sizeof (CHAR);
  CHAR *adr;
  CHAR *dest;
  int result = 0;

  adr = (CHAR *) mmap (NULL, 3 * size, PROT_READ | PROT_WRITE,
		       MAP_PRIVATE | MAP_ANON, -1, 0);
  dest = (CHAR *) mmap (NULL, 3 * size, PROT_READ | PROT_WRITE,
			MAP_PRIVATE | MAP_ANON, -1, 0);
  if (adr == MAP_FAILED || dest == MAP_FAILED)
    {
      if (errno == ENOSYS)
	puts ("No test, mmap not available.");
      else
	{
	  printf ("mmap failed: %m");
	  result = 1;
	}
    }
  else
    {
      int inner, middle, outer;

      mprotect (adr, size, PROT_NONE);
      mprotect (adr + 2 * nchars, size, PROT_NONE);
      adr += nchars;

      mprotect (dest, size, PROT_NONE);
      mprotect (dest + 2 * nchars, size, PROT_NONE);
      dest += nchars;

      MEMSET (adr, L('T'), nchars);

      /* strlen/wcslen test */
      for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
	    {
	      adr[inner] = L('\0');

	      if (STRLEN (&adr[outer]) != (size_t) (inner - outer))
		{
		  printf ("%s flunked for outer = %d, inner = %d\n",
			  STRINGIFY (STRLEN), outer, inner);
		  result = 1;
		}

	      adr[inner] = L('T');
	    }
	}

      /* strnlen/wcsnlen test */
      for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
	    {
	      adr[inner] = L('\0');

	      if (STRNLEN (&adr[outer], inner - outer + 1)
		  != (size_t) (inner - outer))
		{
		  printf ("%s flunked for outer = %d, inner = %d\n",
			  STRINGIFY (STRNLEN), outer, inner);
		  result = 1;
		}

	      adr[inner] = L('T');
	    }
	}
      for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (inner = MAX (outer, nchars - 64); inner <= nchars; ++inner)
	    {
	      if (STRNLEN (&adr[outer], inner - outer)
		  != (size_t) (inner - outer))
		{
		  printf ("%s flunked bounded for outer = %d, inner = %d\n",
			  STRINGIFY (STRNLEN), outer, inner);
		  result = 1;
		}
	    }
	}

      /* strchr/wcschr test */
      for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
	    {
	      for (inner = middle; inner < nchars; ++inner)
		{
		  adr[middle] = L('V');
		  adr[inner] = L('\0');

		  CHAR *cp = STRCHR (&adr[outer], L('V'));

		  if ((inner == middle && cp != NULL)
		      || (inner != middle
			  && (cp - &adr[outer]) != middle - outer))
		    {
		      printf ("%s flunked for outer = %d, middle = %d, "
			      "inner = %d\n",
			      STRINGIFY (STRCHR), outer, middle, inner);
		      result = 1;
		    }

		  adr[inner] = L('T');
		  adr[middle] = L('T');
		}
	    }
	}

      /* Special test.  */
      adr[nchars - 1] = L('\0');
      if (STRCHR (&adr[nchars - 1], L('\n')) != NULL)
	{
	  printf ("%s flunked test of empty string at end of page\n",
		  STRINGIFY (STRCHR));
	  result = 1;
	}

      /* strrchr/wcsrchr test */
      for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
	    {
	      for (inner = middle; inner < nchars; ++inner)
		{
		  adr[middle] = L('V');
		  adr[inner] = L('\0');

		  CHAR *cp = STRRCHR (&adr[outer], L('V'));

		  if ((inner == middle && cp != NULL)
		      || (inner != middle
			  && (cp - &adr[outer]) != middle - outer))
		    {
		      printf ("%s flunked for outer = %d, middle = %d, "
			      "inner = %d\n",
			      STRINGIFY (STRRCHR), outer, middle, inner);
		      result = 1;
		    }

		  adr[inner] = L('T');
		  adr[middle] = L('T');
		}
	    }
	}

      /* memchr test */
      for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
	    {
	      adr[middle] = L('V');

	      CHAR *cp = MEMCHR (&adr[outer], L('V'), 3 * size);

	      if (cp - &adr[outer] != middle - outer)
		{
		  printf ("%s flunked for outer = %d, middle = %d\n",
			  STRINGIFY (MEMCHR), outer, middle);
		  result = 1;
		}

	      adr[middle] = L('T');
	    }
	}
      for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
	{
	  CHAR *cp = MEMCHR (&adr[outer], L('V'), nchars - outer);

	  if (cp != NULL)
	    {
	      printf ("%s flunked for outer = %d\n",
		      STRINGIFY (MEMCHR), outer);
	      result = 1;
	    }
	}

      /* These functions only exist for single-byte characters.  */
#ifndef WCSTEST
      /* rawmemchr test */
      for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
	    {
	      adr[middle] = L('V');

	      CHAR *cp = rawmemchr (&adr[outer], L('V'));

	      if (cp - &adr[outer] != middle - outer)
		{
		  printf ("%s flunked for outer = %d, middle = %d\n",
			  STRINGIFY (rawmemchr), outer, middle);
		  result = 1;
		}

	      adr[middle] = L('T');
	    }
	}

      /* memrchr test */
      for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
	    {
	      adr[middle] = L('V');

	      CHAR *cp = memrchr (&adr[outer], L('V'), nchars - outer);

	      if (cp - &adr[outer] != middle - outer)
		{
		  printf ("%s flunked for outer = %d, middle = %d\n",
			  STRINGIFY (memrchr), outer, middle);
		  result = 1;
		}

	      adr[middle] = L('T');
	    }
	}
      for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
	{
	  CHAR *cp = memrchr (&adr[outer], L('V'), nchars - outer);

	  if (cp != NULL)
	    {
	      printf ("%s flunked for outer = %d\n",
		      STRINGIFY (memrchr), outer);
	      result = 1;
	    }
	}
#endif

      /* strcpy/wcscpy test */
      for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
	    {
	      adr[inner] = L('\0');

	      if (STRCPY (dest, &adr[outer]) != dest
		  || STRLEN (dest) != (size_t) (inner - outer))
		{
		  printf ("%s flunked for outer = %d, inner = %d\n",
			  STRINGIFY (STRCPY), outer, inner);
		  result = 1;
		}

	      adr[inner] = L('T');
	    }
	}

      /* strcmp/wcscmp tests */
      for (outer = 1; outer < 32; ++outer)
	for (middle = 0; middle < 16; ++middle)
	  {
	    MEMSET (adr + middle, L('T'), 256);
	    adr[256] = L('\0');
	    MEMSET (dest + nchars - outer, L('T'), outer - 1);
	    dest[nchars - 1] = L('\0');

	    if (STRCMP (adr + middle, dest + nchars - outer) <= 0)
	      {
		printf ("%s 1 flunked for outer = %d, middle = %d\n",
			STRINGIFY (STRCMP), outer, middle);
		result = 1;
	      }

	    if (STRCMP (dest + nchars - outer, adr + middle) >= 0)
	      {
		printf ("%s 2 flunked for outer = %d, middle = %d\n",
			STRINGIFY (STRCMP), outer, middle);
		result = 1;
	      }
	  }

      /* strncmp/wcsncmp tests */
      for (outer = 1; outer < 32; ++outer)
	for (middle = 0; middle < 16; ++middle)
	  {
	    MEMSET (adr + middle, L('T'), 256);
	    adr[256] = L('\0');
	    MEMSET (dest + nchars - outer, L('T'), outer - 1);
	    dest[nchars - 1] = L('U');

	    for (inner = 0; inner < outer; ++inner)
	      {
		if (STRNCMP (adr + middle, dest + nchars - outer, inner) != 0)
		  {
		    printf ("%s 1 flunked for outer = %d, middle = %d, "
			    "inner = %d\n",
			    STRINGIFY (STRNCMP), outer, middle, inner);
		    result = 1;
		  }

		if (STRNCMP (dest + nchars - outer, adr + middle, inner) != 0)
		  {
		    printf ("%s 2 flunked for outer = %d, middle = %d, "
			    "inner = %d\n",
			    STRINGIFY (STRNCMP), outer, middle, inner);
		    result = 1;
		  }
	      }

	    if (STRNCMP (adr + middle, dest + nchars - outer, outer) >= 0)
	      {
		printf ("%s 1 flunked for outer = %d, middle = %d, full\n",
			STRINGIFY (STRNCMP), outer, middle);
		result = 1;
	      }

	    if (STRNCMP (dest + nchars - outer, adr + middle, outer) <= 0)
	      {
		printf ("%s 2 flunked for outer = %d, middle = %d, full\n",
			STRINGIFY (STRNCMP), outer, middle);
		result = 1;
	      }
	  }

      /* strncpy/wcsncpy tests */
      adr[nchars - 1] = L('T');
      for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
	{
	  size_t len;

	  for (len = 0; len < nchars - outer; ++len)
	    {
	      if (STRNCPY (dest, &adr[outer], len) != dest
		  || MEMCMP (dest, &adr[outer], len) != 0)
		{
		  printf ("outer %s flunked for outer = %d, len = %Zd\n",
			  STRINGIFY (STRNCPY), outer, len);
		  result = 1;
		}
	    }
	}
      adr[nchars - 1] = L('\0');

      for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
	    {
	      size_t len;

	      adr[inner] = L('\0');

	      for (len = 0; len < nchars - outer + 64; ++len)
		{
		  if (STRNCPY (dest, &adr[outer], len) != dest
		      || MEMCMP (dest, &adr[outer],
				 MIN (inner - outer, len)) != 0
		      || (inner - outer < len
			  && STRLEN (dest) != (inner - outer)))
		    {
		      printf ("%s flunked for outer = %d, inner = %d, "
			      "len = %Zd\n",
			      STRINGIFY (STRNCPY), outer, inner, len);
		      result = 1;
		    }
		  if (STRNCPY (dest + 1, &adr[outer], len) != dest + 1
		      || MEMCMP (dest + 1, &adr[outer],
				 MIN (inner - outer, len)) != 0
		      || (inner - outer < len
			  && STRLEN (dest + 1) != (inner - outer)))
		    {
		      printf ("%s+1 flunked for outer = %d, inner = %d, "
			      "len = %Zd\n",
			      STRINGIFY (STRNCPY), outer, inner, len);
		      result = 1;
		    }
		}

	      adr[inner] = L('T');
	    }
	}

      /* stpcpy/wcpcpy test */
      for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
	    {
	      adr[inner] = L('\0');

	      if ((STPCPY (dest, &adr[outer]) - dest) != inner - outer)
		{
		  printf ("%s flunked for outer = %d, inner = %d\n",
			  STRINGIFY (STPCPY), outer, inner);
		  result = 1;
		}

	      adr[inner] = L('T');
	    }
	}

      /* stpncpy/wcpncpy test */
      adr[nchars - 1] = L('T');
      for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
	{
	  size_t len;

	  for (len = 0; len < nchars - outer; ++len)
	    {
	      if (STPNCPY (dest, &adr[outer], len) != dest + len
		  || MEMCMP (dest, &adr[outer], len) != 0)
		{
		  printf ("outer %s flunked for outer = %d, len = %Zd\n",
			  STRINGIFY (STPNCPY), outer, len);
		  result = 1;
		}
	    }
	}
      adr[nchars - 1] = L('\0');

      for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	{
	  for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
	    {
	      adr[middle] = L('\0');

	      for (inner = 0; inner < nchars - outer; ++ inner)
		{
		  if ((STPNCPY (dest, &adr[outer], inner) - dest)
		      != MIN (inner, middle - outer))
		    {
		      printf ("%s flunked for outer = %d, middle = %d, "
			      "inner = %d\n",
			      STRINGIFY (STPNCPY), outer, middle, inner);
		      result = 1;
		    }
		}

	      adr[middle] = L('T');
	    }
	}

      /* memcpy/wmemcpy test */
      for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
	for (inner = 0; inner < nchars - outer; ++inner)
	  if (MEMCPY (dest, &adr[outer], inner) !=  dest)
	    {
	      printf ("%s flunked for outer = %d, inner = %d\n",
		      STRINGIFY (MEMCPY), outer, inner);
	      result = 1;
	    }

      /* mempcpy/wmempcpy test */
      for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
	for (inner = 0; inner < nchars - outer; ++inner)
	  if (MEMPCPY (dest, &adr[outer], inner) !=  dest + inner)
	    {
	      printf ("%s flunked for outer = %d, inner = %d\n",
		      STRINGIFY (MEMPCPY), outer, inner);
	      result = 1;
	    }

      /* This function only exists for single-byte characters.  */
#ifndef WCSTEST
      /* memccpy test */
      memset (adr, '\0', nchars);
      for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
	for (inner = 0; inner < nchars - outer; ++inner)
	  if (memccpy (dest, &adr[outer], L('\1'), inner) != NULL)
	    {
	      printf ("memccpy flunked full copy for outer = %d, inner = %d\n",
		      outer, inner);
	      result = 1;
	    }
      for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	for (middle = 0; middle < nchars - outer; ++middle)
	  {
	    memset (dest, L('\2'), middle + 1);
	    for (inner = 0; inner < middle; ++inner)
	      {
		adr[outer + inner] = L('\1');

		if (memccpy (dest, &adr[outer], '\1', middle + 128)
		    !=  dest + inner + 1)
		  {
		    printf ("\
memccpy flunked partial copy for outer = %d, middle = %d, inner = %d\n",
			    outer, middle, inner);
		    result = 1;
		  }
		else if (dest[inner + 1] != L('\2'))
		  {
		    printf ("\
memccpy copied too much for outer = %d, middle = %d, inner = %d\n",
			    outer, middle, inner);
		    result = 1;
		  }
		adr[outer + inner] = L('\0');
	      }
	  }
#endif
    }

  return result;
}

#define TEST_FUNCTION do_test ()
#include "../test-skeleton.c"
Commit	Line	Data
2c6fe0bd	1	/* Test for string function add boundaries of usable memory.
b168057a	2	Copyright (C) 1996-2015 Free Software Foundation, Inc.
2c6fe0bd UD	3	This file is part of the GNU C Library.
	4	Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
	5
	6	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	7	modify it under the terms of the GNU Lesser General Public
	8	License as published by the Free Software Foundation; either
	9	version 2.1 of the License, or (at your option) any later version.
2c6fe0bd UD	10
	11	The GNU C Library is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	14	Lesser General Public License for more details.
2c6fe0bd	15
41bdb6e2	16	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	17	License along with the GNU C Library; if not, see
59ba27a6 PE	18	<http://www.gnu.org/licenses/>. */
2c6fe0bd	19
46ec036d	20	#define _GNU_SOURCE 1
9a0a462c UD	21
	22	/* Make sure we don't test the optimized inline functions if we want to
	23	test the real implementation. */
	24	#undef __USE_STRING_INLINES
	25
46ec036d UD	26	#include <errno.h>
	27	#include <stdio.h>
	28	#include <string.h>
	29	#include <unistd.h>
	30	#include <sys/mman.h>
	31	#include <sys/param.h>
	32
9cc198f6 UD	33	#ifndef CHAR
	34	# define L(c) c
	35	# define CHAR char
	36	# define MEMSET memset
	37	# define STRLEN strlen
	38	# define STRNLEN strnlen
	39	# define STRCHR strchr
	40	# define STRRCHR strrchr
	41	# define STRCPY strcpy
	42	# define STRNCPY strncpy
	43	# define MEMCMP memcmp
	44	# define STPCPY stpcpy
	45	# define STPNCPY stpncpy
	46	# define MEMCPY memcpy
	47	# define MEMPCPY mempcpy
ddba0f17	48	# define MEMCHR memchr
45db99c7 UD	49	# define STRCMP strcmp
45db99c7 UD	50	# define STRNCMP strncmp
46ec036d UD	51	#endif
46ec036d UD	52
9cc198f6 UD	53
	54	#define STRINGIFY(s) STRINGIFY2 (s)
	55	#define STRINGIFY2(s) #s
	56
	57
	58	static int
	59	do_test (void)
46ec036d	60	{
2c6fe0bd	61	int size = sysconf (_SC_PAGESIZE);
9cc198f6 UD	62	int nchars = size / sizeof (CHAR);
	63	CHAR *adr;
	64	CHAR *dest;
46ec036d UD	65	int result = 0;
46ec036d UD	66
9cc198f6	67	adr = (CHAR ) mmap (NULL, 3 size, PROT_READ \| PROT_WRITE,
76e680a8	68	MAP_PRIVATE \| MAP_ANON, -1, 0);
9cc198f6	69	dest = (CHAR ) mmap (NULL, 3 size, PROT_READ \| PROT_WRITE,
76e680a8	70	MAP_PRIVATE \| MAP_ANON, -1, 0);
0413b54c	71	if (adr == MAP_FAILED \|\| dest == MAP_FAILED)
46ec036d UD	72	{
46ec036d UD	73	if (errno == ENOSYS)
45db99c7	74	puts ("No test, mmap not available.");
46ec036d	75	else
45db99c7 UD	76	{
	77	printf ("mmap failed: %m");
	78	result = 1;
	79	}
46ec036d UD	80	}
	81	else
	82	{
46ec036d UD	83	int inner, middle, outer;
46ec036d UD	84
9cc198f6 UD	85	mprotect (adr, size, PROT_NONE);
	86	mprotect (adr + 2 * nchars, size, PROT_NONE);
	87	adr += nchars;
ba1ffaa1	88
9cc198f6 UD	89	mprotect (dest, size, PROT_NONE);
	90	mprotect (dest + 2 * nchars, size, PROT_NONE);
	91	dest += nchars;
ba1ffaa1	92
9cc198f6	93	MEMSET (adr, L('T'), nchars);
46ec036d	94
9cc198f6 UD	95	/* strlen/wcslen test */
9cc198f6 UD	96	for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
45db99c7 UD	97	{
45db99c7 UD	98	for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
46ec036d	99	{
9cc198f6	100	adr[inner] = L('\0');
46ec036d	101
9cc198f6	102	if (STRLEN (&adr[outer]) != (size_t) (inner - outer))
46ec036d	103	{
9cc198f6 UD	104	printf ("%s flunked for outer = %d, inner = %d\n",
9cc198f6 UD	105	STRINGIFY (STRLEN), outer, inner);
46ec036d UD	106	result = 1;
	107	}
	108
9cc198f6	109	adr[inner] = L('T');
46ec036d	110	}
45db99c7	111	}
46ec036d	112
9cc198f6 UD	113	/* strnlen/wcsnlen test */
9cc198f6 UD	114	for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
45db99c7 UD	115	{
45db99c7 UD	116	for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
46ec036d	117	{
9cc198f6 UD	118	adr[inner] = L('\0');
	119
	120	if (STRNLEN (&adr[outer], inner - outer + 1)
	121	!= (size_t) (inner - outer))
46ec036d	122	{
9cc198f6 UD	123	printf ("%s flunked for outer = %d, inner = %d\n",
	124	STRINGIFY (STRNLEN), outer, inner);
	125	result = 1;
	126	}
46ec036d	127
9cc198f6 UD	128	adr[inner] = L('T');
9cc198f6 UD	129	}
45db99c7	130	}
9cc198f6	131	for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
45db99c7	132	{
15417de3	133	for (inner = MAX (outer, nchars - 64); inner <= nchars; ++inner)
9cc198f6	134	{
15417de3 UD	135	if (STRNLEN (&adr[outer], inner - outer)
15417de3 UD	136	!= (size_t) (inner - outer))
9cc198f6 UD	137	{
	138	printf ("%s flunked bounded for outer = %d, inner = %d\n",
	139	STRINGIFY (STRNLEN), outer, inner);
	140	result = 1;
	141	}
	142	}
45db99c7	143	}
9cc198f6 UD	144
	145	/* strchr/wcschr test */
	146	for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
45db99c7	147	{
9cc198f6 UD	148	for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
	149	{
	150	for (inner = middle; inner < nchars; ++inner)
	151	{
	152	adr[middle] = L('V');
	153	adr[inner] = L('\0');
	154
	155	CHAR *cp = STRCHR (&adr[outer], L('V'));
46ec036d UD	156
	157	if ((inner == middle && cp != NULL)
	158	\|\| (inner != middle
	159	&& (cp - &adr[outer]) != middle - outer))
	160	{
9cc198f6 UD	161	printf ("%s flunked for outer = %d, middle = %d, "
	162	"inner = %d\n",
	163	STRINGIFY (STRCHR), outer, middle, inner);
46ec036d UD	164	result = 1;
	165	}
	166
9cc198f6 UD	167	adr[inner] = L('T');
9cc198f6 UD	168	adr[middle] = L('T');
46ec036d UD	169	}
46ec036d UD	170	}
45db99c7	171	}
46ec036d	172
76e680a8	173	/* Special test. */
9cc198f6 UD	174	adr[nchars - 1] = L('\0');
9cc198f6 UD	175	if (STRCHR (&adr[nchars - 1], L('\n')) != NULL)
76e680a8	176	{
9cc198f6 UD	177	printf ("%s flunked test of empty string at end of page\n",
9cc198f6 UD	178	STRINGIFY (STRCHR));
76e680a8 UD	179	result = 1;
	180	}
	181
9cc198f6 UD	182	/* strrchr/wcsrchr test */
9cc198f6 UD	183	for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
45db99c7	184	{
9cc198f6	185	for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
46ec036d	186	{
9cc198f6	187	for (inner = middle; inner < nchars; ++inner)
46ec036d	188	{
9cc198f6 UD	189	adr[middle] = L('V');
9cc198f6 UD	190	adr[inner] = L('\0');
46ec036d	191
9cc198f6	192	CHAR *cp = STRRCHR (&adr[outer], L('V'));
46ec036d UD	193
	194	if ((inner == middle && cp != NULL)
	195	\|\| (inner != middle
	196	&& (cp - &adr[outer]) != middle - outer))
	197	{
9cc198f6 UD	198	printf ("%s flunked for outer = %d, middle = %d, "
	199	"inner = %d\n",
	200	STRINGIFY (STRRCHR), outer, middle, inner);
46ec036d UD	201	result = 1;
	202	}
	203
9cc198f6 UD	204	adr[inner] = L('T');
9cc198f6 UD	205	adr[middle] = L('T');
46ec036d UD	206	}
46ec036d UD	207	}
45db99c7	208	}
46ec036d	209
ddba0f17 UD	210	/* memchr test */
ddba0f17 UD	211	for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
45db99c7	212	{
ddba0f17 UD	213	for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
	214	{
	215	adr[middle] = L('V');
	216
	217	CHAR cp = MEMCHR (&adr[outer], L('V'), 3 size);
	218
	219	if (cp - &adr[outer] != middle - outer)
	220	{
	221	printf ("%s flunked for outer = %d, middle = %d\n",
	222	STRINGIFY (MEMCHR), outer, middle);
	223	result = 1;
	224	}
	225
	226	adr[middle] = L('T');
	227	}
45db99c7	228	}
15417de3	229	for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
45db99c7	230	{
ddba0f17 UD	231	CHAR *cp = MEMCHR (&adr[outer], L('V'), nchars - outer);
	232
	233	if (cp != NULL)
	234	{
	235	printf ("%s flunked for outer = %d\n",
	236	STRINGIFY (MEMCHR), outer);
	237	result = 1;
	238	}
45db99c7	239	}
ddba0f17	240
5298ffa8	241	/* These functions only exist for single-byte characters. */
9cc198f6	242	#ifndef WCSTEST
d9163744	243	/* rawmemchr test */
9cc198f6	244	for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
45db99c7	245	{
9cc198f6	246	for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
d9163744	247	{
9cc198f6	248	adr[middle] = L('V');
d9163744	249
9cc198f6	250	CHAR *cp = rawmemchr (&adr[outer], L('V'));
d9163744 UD	251
	252	if (cp - &adr[outer] != middle - outer)
	253	{
9cc198f6 UD	254	printf ("%s flunked for outer = %d, middle = %d\n",
9cc198f6 UD	255	STRINGIFY (rawmemchr), outer, middle);
d9163744 UD	256	result = 1;
	257	}
	258
9cc198f6	259	adr[middle] = L('T');
d9163744	260	}
45db99c7	261	}
5298ffa8 AS	262
	263	/* memrchr test */
	264	for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
	265	{
	266	for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
	267	{
	268	adr[middle] = L('V');
	269
	270	CHAR *cp = memrchr (&adr[outer], L('V'), nchars - outer);
	271
	272	if (cp - &adr[outer] != middle - outer)
	273	{
	274	printf ("%s flunked for outer = %d, middle = %d\n",
	275	STRINGIFY (memrchr), outer, middle);
	276	result = 1;
	277	}
	278
	279	adr[middle] = L('T');
	280	}
	281	}
	282	for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
	283	{
	284	CHAR *cp = memrchr (&adr[outer], L('V'), nchars - outer);
	285
	286	if (cp != NULL)
	287	{
	288	printf ("%s flunked for outer = %d\n",
	289	STRINGIFY (memrchr), outer);
	290	result = 1;
	291	}
	292	}
9cc198f6	293	#endif
d9163744	294
9cc198f6 UD	295	/* strcpy/wcscpy test */
9cc198f6 UD	296	for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
45db99c7 UD	297	{
45db99c7 UD	298	for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
46ec036d	299	{
9cc198f6	300	adr[inner] = L('\0');
46ec036d	301
9cc198f6 UD	302	if (STRCPY (dest, &adr[outer]) != dest
9cc198f6 UD	303	\|\| STRLEN (dest) != (size_t) (inner - outer))
46ec036d	304	{
9cc198f6 UD	305	printf ("%s flunked for outer = %d, inner = %d\n",
9cc198f6 UD	306	STRINGIFY (STRCPY), outer, inner);
46ec036d UD	307	result = 1;
	308	}
	309
9cc198f6	310	adr[inner] = L('T');
46ec036d	311	}
45db99c7 UD	312	}
	313
	314	/* strcmp/wcscmp tests */
	315	for (outer = 1; outer < 32; ++outer)
	316	for (middle = 0; middle < 16; ++middle)
	317	{
	318	MEMSET (adr + middle, L('T'), 256);
	319	adr[256] = L('\0');
	320	MEMSET (dest + nchars - outer, L('T'), outer - 1);
	321	dest[nchars - 1] = L('\0');
	322
	323	if (STRCMP (adr + middle, dest + nchars - outer) <= 0)
	324	{
	325	printf ("%s 1 flunked for outer = %d, middle = %d\n",
	326	STRINGIFY (STRCMP), outer, middle);
	327	result = 1;
	328	}
	329
	330	if (STRCMP (dest + nchars - outer, adr + middle) >= 0)
	331	{
	332	printf ("%s 2 flunked for outer = %d, middle = %d\n",
	333	STRINGIFY (STRCMP), outer, middle);
	334	result = 1;
	335	}
	336	}
	337
	338	/* strncmp/wcsncmp tests */
	339	for (outer = 1; outer < 32; ++outer)
	340	for (middle = 0; middle < 16; ++middle)
	341	{
	342	MEMSET (adr + middle, L('T'), 256);
	343	adr[256] = L('\0');
	344	MEMSET (dest + nchars - outer, L('T'), outer - 1);
	345	dest[nchars - 1] = L('U');
	346
	347	for (inner = 0; inner < outer; ++inner)
	348	{
	349	if (STRNCMP (adr + middle, dest + nchars - outer, inner) != 0)
	350	{
	351	printf ("%s 1 flunked for outer = %d, middle = %d, "
	352	"inner = %d\n",
	353	STRINGIFY (STRNCMP), outer, middle, inner);
	354	result = 1;
	355	}
	356
	357	if (STRNCMP (dest + nchars - outer, adr + middle, inner) != 0)
	358	{
	359	printf ("%s 2 flunked for outer = %d, middle = %d, "
	360	"inner = %d\n",
	361	STRINGIFY (STRNCMP), outer, middle, inner);
	362	result = 1;
	363	}
	364	}
	365
	366	if (STRNCMP (adr + middle, dest + nchars - outer, outer) >= 0)
	367	{
	368	printf ("%s 1 flunked for outer = %d, middle = %d, full\n",
	369	STRINGIFY (STRNCMP), outer, middle);
	370	result = 1;
	371	}
	372
	373	if (STRNCMP (dest + nchars - outer, adr + middle, outer) <= 0)
	374	{
	375	printf ("%s 2 flunked for outer = %d, middle = %d, full\n",
376	STRINGIFY (STRNCMP), outer, middle);
377	result = 1;
378	}
379	}
46ec036d	380
15417de3	381	/* strncpy/wcsncpy tests */
9cc198f6	382	adr[nchars - 1] = L('T');
15417de3	383	for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
2836ec90 UD	384	{
	385	size_t len;
	386
9cc198f6	387	for (len = 0; len < nchars - outer; ++len)
2836ec90	388	{
9cc198f6 UD	389	if (STRNCPY (dest, &adr[outer], len) != dest
9cc198f6 UD	390	\|\| MEMCMP (dest, &adr[outer], len) != 0)
2836ec90	391	{
9cc198f6 UD	392	printf ("outer %s flunked for outer = %d, len = %Zd\n",
9cc198f6 UD	393	STRINGIFY (STRNCPY), outer, len);
2836ec90 UD	394	result = 1;
	395	}
	396	}
45db99c7	397	}
9cc198f6	398	adr[nchars - 1] = L('\0');
2836ec90	399
9cc198f6	400	for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
45db99c7 UD	401	{
45db99c7 UD	402	for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
a5ae1fc2 UD	403	{
	404	size_t len;
	405
9cc198f6	406	adr[inner] = L('\0');
a5ae1fc2	407
9cc198f6	408	for (len = 0; len < nchars - outer + 64; ++len)
a5ae1fc2	409	{
9cc198f6 UD	410	if (STRNCPY (dest, &adr[outer], len) != dest
9cc198f6 UD	411	\|\| MEMCMP (dest, &adr[outer],
a5ae1fc2 UD	412	MIN (inner - outer, len)) != 0
a5ae1fc2 UD	413	\|\| (inner - outer < len
9cc198f6	414	&& STRLEN (dest) != (inner - outer)))
a5ae1fc2	415	{
9cc198f6 UD	416	printf ("%s flunked for outer = %d, inner = %d, "
	417	"len = %Zd\n",
	418	STRINGIFY (STRNCPY), outer, inner, len);
a5ae1fc2 UD	419	result = 1;
a5ae1fc2 UD	420	}
9cc198f6 UD	421	if (STRNCPY (dest + 1, &adr[outer], len) != dest + 1
9cc198f6 UD	422	\|\| MEMCMP (dest + 1, &adr[outer],
2836ec90 UD	423	MIN (inner - outer, len)) != 0
2836ec90 UD	424	\|\| (inner - outer < len
9cc198f6	425	&& STRLEN (dest + 1) != (inner - outer)))
2836ec90	426	{
9cc198f6 UD	427	printf ("%s+1 flunked for outer = %d, inner = %d, "
	428	"len = %Zd\n",
	429	STRINGIFY (STRNCPY), outer, inner, len);
2836ec90 UD	430	result = 1;
2836ec90 UD	431	}
a5ae1fc2 UD	432	}
a5ae1fc2 UD	433
9cc198f6	434	adr[inner] = L('T');
a5ae1fc2	435	}
45db99c7	436	}
a5ae1fc2	437
9cc198f6 UD	438	/* stpcpy/wcpcpy test */
9cc198f6 UD	439	for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
45db99c7 UD	440	{
45db99c7 UD	441	for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
46ec036d	442	{
9cc198f6	443	adr[inner] = L('\0');
46ec036d	444
9cc198f6	445	if ((STPCPY (dest, &adr[outer]) - dest) != inner - outer)
46ec036d	446	{
9cc198f6 UD	447	printf ("%s flunked for outer = %d, inner = %d\n",
9cc198f6 UD	448	STRINGIFY (STPCPY), outer, inner);
46ec036d UD	449	result = 1;
	450	}
	451
9cc198f6	452	adr[inner] = L('T');
46ec036d	453	}
45db99c7	454	}
c13f651e	455
9cc198f6	456	/* stpncpy/wcpncpy test */
15417de3 UD	457	adr[nchars - 1] = L('T');
	458	for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
	459	{
	460	size_t len;
	461
	462	for (len = 0; len < nchars - outer; ++len)
	463	{
	464	if (STPNCPY (dest, &adr[outer], len) != dest + len
	465	\|\| MEMCMP (dest, &adr[outer], len) != 0)
	466	{
	467	printf ("outer %s flunked for outer = %d, len = %Zd\n",
	468	STRINGIFY (STPNCPY), outer, len);
	469	result = 1;
	470	}
	471	}
	472	}
	473	adr[nchars - 1] = L('\0');
	474
9cc198f6	475	for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
45db99c7 UD	476	{
45db99c7 UD	477	for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
c13f651e	478	{
9cc198f6	479	adr[middle] = L('\0');
c13f651e	480
9cc198f6	481	for (inner = 0; inner < nchars - outer; ++ inner)
c13f651e	482	{
9cc198f6	483	if ((STPNCPY (dest, &adr[outer], inner) - dest)
c13f651e UD	484	!= MIN (inner, middle - outer))
c13f651e UD	485	{
9cc198f6 UD	486	printf ("%s flunked for outer = %d, middle = %d, "
	487	"inner = %d\n",
	488	STRINGIFY (STPNCPY), outer, middle, inner);
c13f651e UD	489	result = 1;
	490	}
	491	}
	492
9cc198f6	493	adr[middle] = L('T');
c13f651e	494	}
45db99c7	495	}
c13f651e	496
9cc198f6	497	/* memcpy/wmemcpy test */
15417de3	498	for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
9cc198f6 UD	499	for (inner = 0; inner < nchars - outer; ++inner)
9cc198f6 UD	500	if (MEMCPY (dest, &adr[outer], inner) != dest)
c13f651e	501	{
9cc198f6 UD	502	printf ("%s flunked for outer = %d, inner = %d\n",
9cc198f6 UD	503	STRINGIFY (MEMCPY), outer, inner);
c13f651e UD	504	result = 1;
	505	}
	506
9cc198f6	507	/* mempcpy/wmempcpy test */
15417de3	508	for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
9cc198f6 UD	509	for (inner = 0; inner < nchars - outer; ++inner)
9cc198f6 UD	510	if (MEMPCPY (dest, &adr[outer], inner) != dest + inner)
c13f651e	511	{
9cc198f6 UD	512	printf ("%s flunked for outer = %d, inner = %d\n",
9cc198f6 UD	513	STRINGIFY (MEMPCPY), outer, inner);
c13f651e UD	514	result = 1;
c13f651e UD	515	}
2036b767	516
9cc198f6 UD	517	/* This function only exists for single-byte characters. */
9cc198f6 UD	518	#ifndef WCSTEST
2036b767	519	/* memccpy test */
9cc198f6	520	memset (adr, '\0', nchars);
15417de3	521	for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
9cc198f6 UD	522	for (inner = 0; inner < nchars - outer; ++inner)
9cc198f6 UD	523	if (memccpy (dest, &adr[outer], L('\1'), inner) != NULL)
2036b767 UD	524	{
	525	printf ("memccpy flunked full copy for outer = %d, inner = %d\n",
	526	outer, inner);
	527	result = 1;
	528	}
9cc198f6 UD	529	for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
9cc198f6 UD	530	for (middle = 0; middle < nchars - outer; ++middle)
2036b767	531	{
9cc198f6	532	memset (dest, L('\2'), middle + 1);
2036b767 UD	533	for (inner = 0; inner < middle; ++inner)
2036b767 UD	534	{
9cc198f6	535	adr[outer + inner] = L('\1');
2036b767 UD	536
	537	if (memccpy (dest, &adr[outer], '\1', middle + 128)
	538	!= dest + inner + 1)
	539	{
	540	printf ("\
	541	memccpy flunked partial copy for outer = %d, middle = %d, inner = %d\n",
	542	outer, middle, inner);
	543	result = 1;
	544	}
9cc198f6	545	else if (dest[inner + 1] != L('\2'))
2036b767 UD	546	{
	547	printf ("\
	548	memccpy copied too much for outer = %d, middle = %d, inner = %d\n",
	549	outer, middle, inner);
	550	result = 1;
	551	}
9cc198f6	552	adr[outer + inner] = L('\0');
2036b767 UD	553	}
2036b767 UD	554	}
9cc198f6	555	#endif
46ec036d UD	556	}
	557
	558	return result;
	559	}
9cc198f6 UD	560
	561	#define TEST_FUNCTION do_test ()
	562	#include "../test-skeleton.c"