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

/* Test and measure memcmp functions.
   Copyright (C) 1999-2014 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Written by Jakub Jelinek <jakub@redhat.com>, 1999.
   Added wmemcmp support by Liubov Dmitrieva <liubov.dmitrieva@gmail.com>, 2011.

   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
#ifdef WIDE
# define TEST_NAME "wmemcmp"
#else
# define TEST_NAME "memcmp"
#endif
#include "test-string.h"
#ifdef WIDE
# include <inttypes.h>
# include <wchar.h>

# define MEMCMP wmemcmp
# define MEMCPY wmemcpy
# define SIMPLE_MEMCMP simple_wmemcmp
# define CHAR wchar_t
# define UCHAR wchar_t
# define CHARBYTES 4
# define CHAR__MIN WCHAR_MIN
# define CHAR__MAX WCHAR_MAX
int
simple_wmemcmp (const wchar_t *s1, const wchar_t *s2, size_t n)
{
  int ret = 0;
  /* Warning!
	wmemcmp has to use SIGNED comparison for elements.
	memcmp has to use UNSIGNED comparison for elemnts.
  */
  while (n-- && (ret = *s1 < *s2 ? -1 : *s1 == *s2 ? 0 : 1) == 0) {s1++; s2++;}
  return ret;
}
#else
# include <limits.h>

# define MEMCMP memcmp
# define MEMCPY memcpy
# define SIMPLE_MEMCMP simple_memcmp
# define CHAR char
# define MAX_CHAR 255
# define UCHAR unsigned char
# define CHARBYTES 1
# define CHAR__MIN CHAR_MIN
# define CHAR__MAX CHAR_MAX

int
simple_memcmp (const char *s1, const char *s2, size_t n)
{
  int ret = 0;

  while (n-- && (ret = *(unsigned char *) s1++ - *(unsigned char *) s2++) == 0);
  return ret;
}
#endif

typedef int (*proto_t) (const CHAR *, const CHAR *, size_t);

IMPL (SIMPLE_MEMCMP, 0)
IMPL (MEMCMP, 1)

static int
check_result (impl_t *impl, const CHAR *s1, const CHAR *s2, size_t len,
	      int exp_result)
{
  int result = CALL (impl, s1, s2, len);
  if ((exp_result == 0 && result != 0)
      || (exp_result < 0 && result >= 0)
      || (exp_result > 0 && result <= 0))
    {
      error (0, 0, "Wrong result in function %s %d %d", impl->name,
	     result, exp_result);
      ret = 1;
      return -1;
    }

  return 0;
}

static void
do_one_test (impl_t *impl, const CHAR *s1, const CHAR *s2, size_t len,
	     int exp_result)
{
  if (check_result (impl, s1, s2, len, exp_result) < 0)
    return;
}

static void
do_test (size_t align1, size_t align2, size_t len, int exp_result)
{
  size_t i;
  CHAR *s1, *s2;

  if (len == 0)
    return;

  align1 &= 63;
  if (align1 + (len + 1) * CHARBYTES >= page_size)
    return;

  align2 &= 63;
  if (align2 + (len + 1) * CHARBYTES >= page_size)
    return;

  s1 = (CHAR *) (buf1 + align1);
  s2 = (CHAR *) (buf2 + align2);

  for (i = 0; i < len; i++)
    s1[i] = s2[i] = 1 + (23 << ((CHARBYTES - 1) * 8)) * i % CHAR__MAX;

  s1[len] = align1;
  s2[len] = align2;
  s2[len - 1] -= exp_result;

  FOR_EACH_IMPL (impl, 0)
    do_one_test (impl, s1, s2, len, exp_result);
}

static void
do_random_tests (void)
{
  size_t i, j, n, align1, align2, pos, len;
  int result;
  long r;
  UCHAR *p1 =  (UCHAR *) (buf1 + page_size - 512 * CHARBYTES);
  UCHAR *p2 =  (UCHAR *) (buf2 + page_size - 512 * CHARBYTES);

  for (n = 0; n < ITERATIONS; n++)
    {
   align1 = random () & 31;
      if (random () & 1)
	align2 = random () & 31;
      else
	align2 = align1 + (random () & 24);
      pos = random () & 511;
      j = align1;
      if (align2 > j)
	j = align2;
      if (pos + j >= 512)
	pos = 511 - j - (random () & 7);
      len = random () & 511;
      if (len + j >= 512)
	len = 511 - j - (random () & 7);
      j = len + align1 + 64;
      if (j > 512) j = 512;
      for (i = 0; i < j; ++i)
	p1[i] = random () & 255;
      for (i = 0; i < j; ++i)
	p2[i] = random () & 255;

      result = 0;
      if (pos >= len)
	MEMCPY ((CHAR *) p2 + align2, (const CHAR *) p1 + align1, len);
      else
	{
	  MEMCPY ((CHAR *) p2 + align2, (const CHAR *) p1 + align1, pos);
	  if (p2[align2 + pos] == p1[align1 + pos])
	    {
	      p2[align2 + pos] = random () & 255;
	      if (p2[align2 + pos] == p1[align1 + pos])
		p2[align2 + pos] = p1[align1 + pos] + 3 + (random () & 127);
	    }

	  if (p1[align1 + pos] < p2[align2 + pos])
	    result = -1;
	  else
	    result = 1;
	}

      FOR_EACH_IMPL (impl, 1)
	{
	  r = CALL (impl, (CHAR *) p1 + align1, (const CHAR *) p2 + align2,
		    len);
	  if ((r == 0 && result)
	      || (r < 0 && result >= 0)
	      || (r > 0 && result <= 0))
	    {
	      error (0, 0, "Iteration %zd - wrong result in function %s (%zd, %zd, %zd, %zd) %ld != %d, p1 %p p2 %p",
		     n, impl->name, align1 * CHARBYTES & 63,  align2 * CHARBYTES & 63, len, pos, r, result, p1, p2);
	      ret = 1;
	    }
	}
    }
}

static void
check1 (void)
{
  CHAR s1[116], s2[116];
  int n, exp_result;

  s1[0] = -108;
  s2[0] = -108;
  s1[1] = 99;
  s2[1] = 99;
  s1[2] = -113;
  s2[2] = -113;
  s1[3] = 1;
  s2[3] = 1;
  s1[4] = 116;
  s2[4] = 116;
  s1[5] = 99;
  s2[5] = 99;
  s1[6] = -113;
  s2[6] = -113;
  s1[7] = 1;
  s2[7] = 1;
  s1[8] = 84;
  s2[8] = 84;
  s1[9] = 99;
  s2[9] = 99;
  s1[10] = -113;
  s2[10] = -113;
  s1[11] = 1;
  s2[11] = 1;
  s1[12] = 52;
  s2[12] = 52;
  s1[13] = 99;
  s2[13] = 99;
  s1[14] = -113;
  s2[14] = -113;
  s1[15] = 1;
  s2[15] = 1;
  s1[16] = -76;
  s2[16] = -76;
  s1[17] = -14;
  s2[17] = -14;
  s1[18] = -109;
  s2[18] = -109;
  s1[19] = 1;
  s2[19] = 1;
  s1[20] = -108;
  s2[20] = -108;
  s1[21] = -14;
  s2[21] = -14;
  s1[22] = -109;
  s2[22] = -109;
  s1[23] = 1;
  s2[23] = 1;
  s1[24] = 84;
  s2[24] = 84;
  s1[25] = -15;
  s2[25] = -15;
  s1[26] = -109;
  s2[26] = -109;
  s1[27] = 1;
  s2[27] = 1;
  s1[28] = 52;
  s2[28] = 52;
  s1[29] = -15;
  s2[29] = -15;
  s1[30] = -109;
  s2[30] = -109;
  s1[31] = 1;
  s2[31] = 1;
  s1[32] = 20;
  s2[32] = 20;
  s1[33] = -15;
  s2[33] = -15;
  s1[34] = -109;
  s2[34] = -109;
  s1[35] = 1;
  s2[35] = 1;
  s1[36] = 20;
  s2[36] = 20;
  s1[37] = -14;
  s2[37] = -14;
  s1[38] = -109;
  s2[38] = -109;
  s1[39] = 1;
  s2[39] = 1;
  s1[40] = 52;
  s2[40] = 52;
  s1[41] = -14;
  s2[41] = -14;
  s1[42] = -109;
  s2[42] = -109;
  s1[43] = 1;
  s2[43] = 1;
  s1[44] = 84;
  s2[44] = 84;
  s1[45] = -14;
  s2[45] = -14;
  s1[46] = -109;
  s2[46] = -109;
  s1[47] = 1;
  s2[47] = 1;
  s1[48] = 116;
  s2[48] = 116;
  s1[49] = -14;
  s2[49] = -14;
  s1[50] = -109;
  s2[50] = -109;
  s1[51] = 1;
  s2[51] = 1;
  s1[52] = 116;
  s2[52] = 116;
  s1[53] = -15;
  s2[53] = -15;
  s1[54] = -109;
  s2[54] = -109;
  s1[55] = 1;
  s2[55] = 1;
  s1[56] = -44;
  s2[56] = -44;
  s1[57] = -14;
  s2[57] = -14;
  s1[58] = -109;
  s2[58] = -109;
  s1[59] = 1;
  s2[59] = 1;
  s1[60] = -108;
  s2[60] = -108;
  s1[61] = -15;
  s2[61] = -15;
  s1[62] = -109;
  s2[62] = -109;
  s1[63] = 1;
  s2[63] = 1;
  s1[64] = -76;
  s2[64] = -76;
  s1[65] = -15;
  s2[65] = -15;
  s1[66] = -109;
  s2[66] = -109;
  s1[67] = 1;
  s2[67] = 1;
  s1[68] = -44;
  s2[68] = -44;
  s1[69] = -15;
  s2[69] = -15;
  s1[70] = -109;
  s2[70] = -109;
  s1[71] = 1;
  s2[71] = 1;
  s1[72] = -12;
  s2[72] = -12;
  s1[73] = -15;
  s2[73] = -15;
  s1[74] = -109;
  s2[74] = -109;
  s1[75] = 1;
  s2[75] = 1;
  s1[76] = -12;
  s2[76] = -12;
  s1[77] = -14;
  s2[77] = -14;
  s1[78] = -109;
  s2[78] = -109;
  s1[79] = 1;
  s2[79] = 1;
  s1[80] = 20;
  s2[80] = -68;
  s1[81] = -12;
  s2[81] = 64;
  s1[82] = -109;
  s2[82] = -106;
  s1[83] = 1;
  s2[83] = 1;
  s1[84] = -12;
  s2[84] = -12;
  s1[85] = -13;
  s2[85] = -13;
  s1[86] = -109;
  s2[86] = -109;
  s1[87] = 1;
  s2[87] = 1;
  s1[88] = -44;
  s2[88] = -44;
  s1[89] = -13;
  s2[89] = -13;
  s1[90] = -109;
  s2[90] = -109;
  s1[91] = 1;
  s2[91] = 1;
  s1[92] = -76;
  s2[92] = -76;
  s1[93] = -13;
  s2[93] = -13;
  s1[94] = -109;
  s2[94] = -109;
  s1[95] = 1;
  s2[95] = 1;
  s1[96] = -108;
  s2[96] = -108;
  s1[97] = -13;
  s2[97] = -13;
  s1[98] = -109;
  s2[98] = -109;
  s1[99] = 1;
  s2[99] = 1;
  s1[100] = 116;
  s2[100] = 116;
  s1[101] = CHAR__MIN;
  s2[101] = CHAR__MAX;
  s1[102] = -109;
  s2[102] = -109;
  s1[103] = 1;
  s2[103] = 1;
  s1[104] = 84;
  s2[104] = 84;
  s1[105] = -13;
  s2[105] = -13;
  s1[106] = -109;
  s2[106] = -109;
  s1[107] = 1;
  s2[107] = 1;
  s1[108] = 52;
  s2[108] = 52;
  s1[109] = -13;
  s2[109] = -13;
  s1[110] = -109;
  s2[110] = -109;
  s1[111] = 1;
  s2[111] = 1;
  s1[112] = CHAR__MAX;
  s2[112] = CHAR__MIN;
  s1[113] = -13;
  s2[113] = -13;
  s1[114] = -109;
  s2[114] = -109;
  s1[115] = 1;
  s2[115] = 1;

  n = 116;
  for (size_t i = 0; i < n; i++)
    {
      exp_result = SIMPLE_MEMCMP (s1 + i, s2 + i, n - i);
      FOR_EACH_IMPL (impl, 0)
	check_result (impl, s1 + i, s2 + i, n - i, exp_result);
    }
}

/* This test checks that memcmp doesn't overrun buffers.  */
static void
check2 (void)
{
  size_t max_length = page_size / sizeof (CHAR);

  /* Initialize buf2 to the same values as buf1.  The bug requires the
     last compared byte to be different.  */
  memcpy (buf2, buf1, page_size);
  ((char *) buf2)[page_size - 1] ^= 0x11;

  for (size_t length = 1; length < max_length; length++)
    {
      CHAR *s1 = (CHAR *) buf1 + max_length - length;
      CHAR *s2 = (CHAR *) buf2 + max_length - length;

      const int exp_result = SIMPLE_MEMCMP (s1, s2, length);

      FOR_EACH_IMPL (impl, 0)
	check_result (impl, s1, s2, length, exp_result);
    }
}

int
test_main (void)
{
  size_t i;

  test_init ();

  check1 ();
  check2 ();

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

  for (i = 1; i < 16; ++i)
    {
      do_test (i * CHARBYTES, i * CHARBYTES, i, 0);
      do_test (i * CHARBYTES, i * CHARBYTES, i, 1);
      do_test (i * CHARBYTES, i * CHARBYTES, i, -1);
    }

  for (i = 0; i < 16; ++i)
    {
      do_test (0, 0, i, 0);
      do_test (0, 0, i, 1);
      do_test (0, 0, i, -1);
    }

  for (i = 1; i < 10; ++i)
    {
      do_test (0, 0, 2 << i, 0);
      do_test (0, 0, 2 << i, 1);
      do_test (0, 0, 2 << i, -1);
      do_test (0, 0, 16 << i, 0);
      do_test ((8 - i) * CHARBYTES, (2 * i) * CHARBYTES, 16 << i, 0);
      do_test (0, 0, 16 << i, 1);
      do_test (0, 0, 16 << i, -1);
    }

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

  do_random_tests ();
  return ret;
}
#include "../test-skeleton.c"
Commit	Line	Data
58ef9ef7	1	/* Test and measure memcmp functions.
d4697bc9	2	Copyright (C) 1999-2014 Free Software Foundation, Inc.
58ef9ef7 RM	3	This file is part of the GNU C Library.
58ef9ef7 RM	4	Written by Jakub Jelinek <jakub@redhat.com>, 1999.
4badf7e8	5	Added wmemcmp support by Liubov Dmitrieva <liubov.dmitrieva@gmail.com>, 2011.
58ef9ef7 RM	6
	7	The GNU C Library is free software; you can redistribute it and/or
	8	modify it under the terms of the GNU Lesser General Public
	9	License as published by the Free Software Foundation; either
	10	version 2.1 of the License, or (at your option) any later version.
	11
	12	The GNU C Library is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	Lesser General Public License for more details.
	16
	17	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	18	License along with the GNU C Library; if not, see
59ba27a6 PE	19	<http://www.gnu.org/licenses/>. */
58ef9ef7 RM	20
58ef9ef7 RM	21	#define TEST_MAIN
69f07e5f L	22	#ifdef WIDE
	23	# define TEST_NAME "wmemcmp"
	24	#else
	25	# define TEST_NAME "memcmp"
	26	#endif
58ef9ef7	27	#include "test-string.h"
4badf7e8 LD	28	#ifdef WIDE
	29	# include <inttypes.h>
	30	# include <wchar.h>
	31
4badf7e8 LD	32	# define MEMCMP wmemcmp
	33	# define MEMCPY wmemcpy
	34	# define SIMPLE_MEMCMP simple_wmemcmp
4badf7e8	35	# define CHAR wchar_t
be13f7bf	36	# define UCHAR wchar_t
4badf7e8	37	# define CHARBYTES 4
be13f7bf LD	38	# define CHAR__MIN WCHAR_MIN
	39	# define CHAR__MAX WCHAR_MAX
	40	int
	41	simple_wmemcmp (const wchar_t s1, const wchar_t s2, size_t n)
	42	{
	43	int ret = 0;
	44	/* Warning!
	45	wmemcmp has to use SIGNED comparison for elements.
	46	memcmp has to use UNSIGNED comparison for elemnts.
	47	*/
	48	while (n-- && (ret = s1 < s2 ? -1 : s1 == s2 ? 0 : 1) == 0) {s1++; s2++;}
	49	return ret;
	50	}
4badf7e8	51	#else
302cadd3 TS	52	# include <limits.h>
302cadd3 TS	53
4badf7e8 LD	54	# define MEMCMP memcmp
	55	# define MEMCPY memcpy
	56	# define SIMPLE_MEMCMP simple_memcmp
4badf7e8 LD	57	# define CHAR char
	58	# define MAX_CHAR 255
	59	# define UCHAR unsigned char
	60	# define CHARBYTES 1
be13f7bf LD	61	# define CHAR__MIN CHAR_MIN
be13f7bf LD	62	# define CHAR__MAX CHAR_MAX
58ef9ef7 RM	63
58ef9ef7 RM	64	int
be13f7bf	65	simple_memcmp (const char s1, const char s2, size_t n)
58ef9ef7 RM	66	{
	67	int ret = 0;
	68
be13f7bf	69	while (n-- && (ret = (unsigned char ) s1++ - (unsigned char ) s2++) == 0);
58ef9ef7 RM	70	return ret;
58ef9ef7 RM	71	}
be13f7bf LD	72	#endif
	73
	74	typedef int (proto_t) (const CHAR , const CHAR *, size_t);
58ef9ef7	75
4badf7e8 LD	76	IMPL (SIMPLE_MEMCMP, 0)
	77	IMPL (MEMCMP, 1)
	78
8863605a	79	static int
4badf7e8	80	check_result (impl_t impl, const CHAR s1, const CHAR *s2, size_t len,
8863605a	81	int exp_result)
58ef9ef7 RM	82	{
	83	int result = CALL (impl, s1, s2, len);
	84	if ((exp_result == 0 && result != 0)
	85	\|\| (exp_result < 0 && result >= 0)
	86	\|\| (exp_result > 0 && result <= 0))
	87	{
	88	error (0, 0, "Wrong result in function %s %d %d", impl->name,
	89	result, exp_result);
	90	ret = 1;
8863605a	91	return -1;
58ef9ef7 RM	92	}
58ef9ef7 RM	93
8863605a L	94	return 0;
	95	}
	96
	97	static void
4badf7e8	98	do_one_test (impl_t impl, const CHAR s1, const CHAR *s2, size_t len,
8863605a L	99	int exp_result)
	100	{
	101	if (check_result (impl, s1, s2, len, exp_result) < 0)
	102	return;
58ef9ef7 RM	103	}
	104
	105	static void
	106	do_test (size_t align1, size_t align2, size_t len, int exp_result)
	107	{
	108	size_t i;
4badf7e8	109	CHAR s1, s2;
58ef9ef7 RM	110
	111	if (len == 0)
	112	return;
	113
4badf7e8 LD	114	align1 &= 63;
4badf7e8 LD	115	if (align1 + (len + 1) * CHARBYTES >= page_size)
58ef9ef7 RM	116	return;
58ef9ef7 RM	117
4badf7e8 LD	118	align2 &= 63;
4badf7e8 LD	119	if (align2 + (len + 1) * CHARBYTES >= page_size)
58ef9ef7 RM	120	return;
58ef9ef7 RM	121
4badf7e8 LD	122	s1 = (CHAR *) (buf1 + align1);
4badf7e8 LD	123	s2 = (CHAR *) (buf2 + align2);
58ef9ef7 RM	124
58ef9ef7 RM	125	for (i = 0; i < len; i++)
be13f7bf	126	s1[i] = s2[i] = 1 + (23 << ((CHARBYTES - 1) * 8)) * i % CHAR__MAX;
58ef9ef7 RM	127
	128	s1[len] = align1;
	129	s2[len] = align2;
	130	s2[len - 1] -= exp_result;
	131
58ef9ef7 RM	132	FOR_EACH_IMPL (impl, 0)
58ef9ef7 RM	133	do_one_test (impl, s1, s2, len, exp_result);
58ef9ef7 RM	134	}
	135
	136	static void
	137	do_random_tests (void)
	138	{
	139	size_t i, j, n, align1, align2, pos, len;
9fb0cae8 RM	140	int result;
9fb0cae8 RM	141	long r;
4badf7e8 LD	142	UCHAR p1 = (UCHAR ) (buf1 + page_size - 512 * CHARBYTES);
4badf7e8 LD	143	UCHAR p2 = (UCHAR ) (buf2 + page_size - 512 * CHARBYTES);
58ef9ef7 RM	144
	145	for (n = 0; n < ITERATIONS; n++)
	146	{
4badf7e8	147	align1 = random () & 31;
58ef9ef7 RM	148	if (random () & 1)
	149	align2 = random () & 31;
	150	else
	151	align2 = align1 + (random () & 24);
	152	pos = random () & 511;
	153	j = align1;
	154	if (align2 > j)
	155	j = align2;
	156	if (pos + j >= 512)
	157	pos = 511 - j - (random () & 7);
	158	len = random () & 511;
	159	if (len + j >= 512)
4badf7e8	160	len = 511 - j - (random () & 7);
58ef9ef7 RM	161	j = len + align1 + 64;
	162	if (j > 512) j = 512;
	163	for (i = 0; i < j; ++i)
	164	p1[i] = random () & 255;
	165	for (i = 0; i < j; ++i)
	166	p2[i] = random () & 255;
	167
	168	result = 0;
	169	if (pos >= len)
4badf7e8	170	MEMCPY ((CHAR ) p2 + align2, (const CHAR ) p1 + align1, len);
58ef9ef7 RM	171	else
58ef9ef7 RM	172	{
4badf7e8	173	MEMCPY ((CHAR ) p2 + align2, (const CHAR ) p1 + align1, pos);
58ef9ef7 RM	174	if (p2[align2 + pos] == p1[align1 + pos])
	175	{
	176	p2[align2 + pos] = random () & 255;
	177	if (p2[align2 + pos] == p1[align1 + pos])
	178	p2[align2 + pos] = p1[align1 + pos] + 3 + (random () & 127);
	179	}
	180
	181	if (p1[align1 + pos] < p2[align2 + pos])
	182	result = -1;
	183	else
	184	result = 1;
	185	}
	186
	187	FOR_EACH_IMPL (impl, 1)
	188	{
4badf7e8 LD	189	r = CALL (impl, (CHAR ) p1 + align1, (const CHAR ) p2 + align2,
4badf7e8 LD	190	len);
58ef9ef7 RM	191	if ((r == 0 && result)
	192	\|\| (r < 0 && result >= 0)
	193	\|\| (r > 0 && result <= 0))
	194	{
9fb0cae8	195	error (0, 0, "Iteration %zd - wrong result in function %s (%zd, %zd, %zd, %zd) %ld != %d, p1 %p p2 %p",
4badf7e8	196	n, impl->name, align1 * CHARBYTES & 63, align2 * CHARBYTES & 63, len, pos, r, result, p1, p2);
58ef9ef7 RM	197	ret = 1;
	198	}
	199	}
	200	}
	201	}
	202
8863605a L	203	static void
	204	check1 (void)
	205	{
4badf7e8	206	CHAR s1[116], s2[116];
8863605a L	207	int n, exp_result;
	208
	209	s1[0] = -108;
	210	s2[0] = -108;
	211	s1[1] = 99;
	212	s2[1] = 99;
	213	s1[2] = -113;
	214	s2[2] = -113;
	215	s1[3] = 1;
	216	s2[3] = 1;
	217	s1[4] = 116;
	218	s2[4] = 116;
	219	s1[5] = 99;
	220	s2[5] = 99;
	221	s1[6] = -113;
	222	s2[6] = -113;
	223	s1[7] = 1;
	224	s2[7] = 1;
	225	s1[8] = 84;
	226	s2[8] = 84;
	227	s1[9] = 99;
	228	s2[9] = 99;
	229	s1[10] = -113;
	230	s2[10] = -113;
	231	s1[11] = 1;
	232	s2[11] = 1;
	233	s1[12] = 52;
	234	s2[12] = 52;
	235	s1[13] = 99;
	236	s2[13] = 99;
	237	s1[14] = -113;
	238	s2[14] = -113;
	239	s1[15] = 1;
	240	s2[15] = 1;
	241	s1[16] = -76;
	242	s2[16] = -76;
	243	s1[17] = -14;
	244	s2[17] = -14;
	245	s1[18] = -109;
	246	s2[18] = -109;
	247	s1[19] = 1;
	248	s2[19] = 1;
	249	s1[20] = -108;
	250	s2[20] = -108;
	251	s1[21] = -14;
	252	s2[21] = -14;
	253	s1[22] = -109;
	254	s2[22] = -109;
	255	s1[23] = 1;
	256	s2[23] = 1;
	257	s1[24] = 84;
	258	s2[24] = 84;
	259	s1[25] = -15;
	260	s2[25] = -15;
	261	s1[26] = -109;
	262	s2[26] = -109;
	263	s1[27] = 1;
	264	s2[27] = 1;
	265	s1[28] = 52;
	266	s2[28] = 52;
	267	s1[29] = -15;
	268	s2[29] = -15;
	269	s1[30] = -109;
	270	s2[30] = -109;
271	s1[31] = 1;
272	s2[31] = 1;
273	s1[32] = 20;
274	s2[32] = 20;
275	s1[33] = -15;
276	s2[33] = -15;
277	s1[34] = -109;
278	s2[34] = -109;
279	s1[35] = 1;
280	s2[35] = 1;
281	s1[36] = 20;
282	s2[36] = 20;
283	s1[37] = -14;
284	s2[37] = -14;
285	s1[38] = -109;
286	s2[38] = -109;
287	s1[39] = 1;
288	s2[39] = 1;
289	s1[40] = 52;
290	s2[40] = 52;
291	s1[41] = -14;
292	s2[41] = -14;
293	s1[42] = -109;
294	s2[42] = -109;
295	s1[43] = 1;
296	s2[43] = 1;
297	s1[44] = 84;
298	s2[44] = 84;
299	s1[45] = -14;
300	s2[45] = -14;
301	s1[46] = -109;
302	s2[46] = -109;
303	s1[47] = 1;
304	s2[47] = 1;
305	s1[48] = 116;
306	s2[48] = 116;
307	s1[49] = -14;
308	s2[49] = -14;
309	s1[50] = -109;
310	s2[50] = -109;
311	s1[51] = 1;
312	s2[51] = 1;
313	s1[52] = 116;
314	s2[52] = 116;
315	s1[53] = -15;
316	s2[53] = -15;
317	s1[54] = -109;
318	s2[54] = -109;
319	s1[55] = 1;
320	s2[55] = 1;
321	s1[56] = -44;
322	s2[56] = -44;
323	s1[57] = -14;
324	s2[57] = -14;
325	s1[58] = -109;
326	s2[58] = -109;
327	s1[59] = 1;
328	s2[59] = 1;
329	s1[60] = -108;
330	s2[60] = -108;
331	s1[61] = -15;
332	s2[61] = -15;
333	s1[62] = -109;
334	s2[62] = -109;
335	s1[63] = 1;
336	s2[63] = 1;
337	s1[64] = -76;
338	s2[64] = -76;
339	s1[65] = -15;
340	s2[65] = -15;
341	s1[66] = -109;
342	s2[66] = -109;
343	s1[67] = 1;
344	s2[67] = 1;
345	s1[68] = -44;
346	s2[68] = -44;
347	s1[69] = -15;
348	s2[69] = -15;
349	s1[70] = -109;
350	s2[70] = -109;
351	s1[71] = 1;
352	s2[71] = 1;
353	s1[72] = -12;
354	s2[72] = -12;
355	s1[73] = -15;
356	s2[73] = -15;
357	s1[74] = -109;
358	s2[74] = -109;
359	s1[75] = 1;
360	s2[75] = 1;
361	s1[76] = -12;
362	s2[76] = -12;
363	s1[77] = -14;
364	s2[77] = -14;
365	s1[78] = -109;
366	s2[78] = -109;
367	s1[79] = 1;
368	s2[79] = 1;
369	s1[80] = 20;
370	s2[80] = -68;
371	s1[81] = -12;
372	s2[81] = 64;
373	s1[82] = -109;
374	s2[82] = -106;
375	s1[83] = 1;
376	s2[83] = 1;
377	s1[84] = -12;
378	s2[84] = -12;
379	s1[85] = -13;
380	s2[85] = -13;
381	s1[86] = -109;
382	s2[86] = -109;
383	s1[87] = 1;
384	s2[87] = 1;
385	s1[88] = -44;
386	s2[88] = -44;
387	s1[89] = -13;
388	s2[89] = -13;
389	s1[90] = -109;
390	s2[90] = -109;
391	s1[91] = 1;
392	s2[91] = 1;
393	s1[92] = -76;
394	s2[92] = -76;
395	s1[93] = -13;
396	s2[93] = -13;
397	s1[94] = -109;
398	s2[94] = -109;
399	s1[95] = 1;
400	s2[95] = 1;
401	s1[96] = -108;
402	s2[96] = -108;
403	s1[97] = -13;
404	s2[97] = -13;
405	s1[98] = -109;
406	s2[98] = -109;
407	s1[99] = 1;
408	s2[99] = 1;
409	s1[100] = 116;
410	s2[100] = 116;
be13f7bf LD	411	s1[101] = CHAR__MIN;
be13f7bf LD	412	s2[101] = CHAR__MAX;
8863605a L	413	s1[102] = -109;
	414	s2[102] = -109;
	415	s1[103] = 1;
	416	s2[103] = 1;
	417	s1[104] = 84;
	418	s2[104] = 84;
	419	s1[105] = -13;
	420	s2[105] = -13;
	421	s1[106] = -109;
	422	s2[106] = -109;
	423	s1[107] = 1;
	424	s2[107] = 1;
	425	s1[108] = 52;
	426	s2[108] = 52;
	427	s1[109] = -13;
	428	s2[109] = -13;
	429	s1[110] = -109;
	430	s2[110] = -109;
	431	s1[111] = 1;
	432	s2[111] = 1;
be13f7bf LD	433	s1[112] = CHAR__MAX;
be13f7bf LD	434	s2[112] = CHAR__MIN;
8863605a L	435	s1[113] = -13;
	436	s2[113] = -13;
	437	s1[114] = -109;
	438	s2[114] = -109;
	439	s1[115] = 1;
	440	s2[115] = 1;
	441
	442	n = 116;
be13f7bf LD	443	for (size_t i = 0; i < n; i++)
	444	{
	445	exp_result = SIMPLE_MEMCMP (s1 + i, s2 + i, n - i);
	446	FOR_EACH_IMPL (impl, 0)
	447	check_result (impl, s1 + i, s2 + i, n - i, exp_result);
	448	}
8863605a L	449	}
8863605a L	450
bb5bb87c L	451	/* This test checks that memcmp doesn't overrun buffers. */
	452	static void
	453	check2 (void)
	454	{
	455	size_t max_length = page_size / sizeof (CHAR);
	456
	457	/* Initialize buf2 to the same values as buf1. The bug requires the
	458	last compared byte to be different. */
	459	memcpy (buf2, buf1, page_size);
	460	((char *) buf2)[page_size - 1] ^= 0x11;
	461
	462	for (size_t length = 1; length < max_length; length++)
	463	{
	464	CHAR s1 = (CHAR ) buf1 + max_length - length;
	465	CHAR s2 = (CHAR ) buf2 + max_length - length;
	466
	467	const int exp_result = SIMPLE_MEMCMP (s1, s2, length);
	468
	469	FOR_EACH_IMPL (impl, 0)
	470	check_result (impl, s1, s2, length, exp_result);
	471	}
	472	}
	473
58ef9ef7 RM	474	int
	475	test_main (void)
	476	{
	477	size_t i;
	478
	479	test_init ();
	480
8863605a	481	check1 ();
bb5bb87c	482	check2 ();
8863605a	483
58ef9ef7 RM	484	printf ("%23s", "");
	485	FOR_EACH_IMPL (impl, 0)
	486	printf ("\t%s", impl->name);
	487	putchar ('\n');
	488
	489	for (i = 1; i < 16; ++i)
	490	{
4badf7e8 LD	491	do_test (i * CHARBYTES, i * CHARBYTES, i, 0);
	492	do_test (i * CHARBYTES, i * CHARBYTES, i, 1);
	493	do_test (i * CHARBYTES, i * CHARBYTES, i, -1);
58ef9ef7 RM	494	}
	495
	496	for (i = 0; i < 16; ++i)
	497	{
	498	do_test (0, 0, i, 0);
	499	do_test (0, 0, i, 1);
	500	do_test (0, 0, i, -1);
	501	}
	502
	503	for (i = 1; i < 10; ++i)
	504	{
	505	do_test (0, 0, 2 << i, 0);
	506	do_test (0, 0, 2 << i, 1);
	507	do_test (0, 0, 2 << i, -1);
	508	do_test (0, 0, 16 << i, 0);
4badf7e8	509	do_test ((8 - i) * CHARBYTES, (2 * i) * CHARBYTES, 16 << i, 0);
58ef9ef7 RM	510	do_test (0, 0, 16 << i, 1);
	511	do_test (0, 0, 16 << i, -1);
	512	}
	513
	514	for (i = 1; i < 8; ++i)
	515	{
4badf7e8 LD	516	do_test (i * CHARBYTES, 2 * (i * CHARBYTES), 8 << i, 0);
	517	do_test (i * CHARBYTES, 2 * (i * CHARBYTES), 8 << i, 1);
	518	do_test (i * CHARBYTES, 2 * (i * CHARBYTES), 8 << i, -1);
58ef9ef7 RM	519	}
	520
	521	do_random_tests ();
	522	return ret;
	523	}
58ef9ef7	524	#include "../test-skeleton.c"