自学教程：C++ FOR_EACH_IMPL函数代码示例

static voiddo_test_limit (size_t align1, size_t align2, size_t len, size_t n, int max_char,	 int exp_result){  size_t i, align_n;  char *s1, *s2;  if (n == 0)    {      s1 = (char*)(buf1 + page_size);      s2 = (char*)(buf2 + page_size);      printf ("Length %d/%d:", len, n);      FOR_EACH_IMPL (impl, 0)	do_one_test (impl, s1, s2, n, 0);      putchar ('/n');      return;    }  align1 &= 15;  align2 &= 15;  align_n = (page_size - n) & 15;  s1 = (char*)(buf1 + page_size - n);  s2 = (char*)(buf2 + page_size - n);  if (align1 < align_n)    s1 -= (align_n - align1);  if (align2 < align_n)    s2 -= (align_n - align2);  for (i = 0; i < n; i++)    s1[i] = s2[i] = 1 + 23 * i % max_char;  if (len < n)    {      s1[len] = 0;      s2[len] = 0;      if (exp_result < 0)	s2[len] = 32;      else if (exp_result > 0)	s1[len] = 64;    }  printf ("Length %d/%d, alignment %d/%d:", len, n, align1, align2);  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, s1, s2, n, exp_result);  putchar ('/n');}

static voiddo_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;    printf ("Length %4zd, alignment %2zd/%2zd:", len, align1, align2);    FOR_EACH_IMPL (impl, 0)    do_one_test (impl, s1, s2, len, exp_result);    putchar ('/n');}

inttest_main (void){  size_t i;  int c = 0;  test_init ();  printf ("%24s", "");  FOR_EACH_IMPL (impl, 0)    printf ("/t%s", impl->name);  putchar ('/n');#ifndef TEST_BZERO  for (c = -65; c <= 130; c += 65)#endif    {      for (i = 0; i < 18; ++i)	do_test (0, c, 1 << i);      for (i = 1; i < 32; ++i)	{	  do_test (i, c, i);	  if (i & (i - 1))	    do_test (0, c, i);	}      do_test (1, c, 14);      do_test (3, c, 1024);      do_test (4, c, 64);      do_test (2, c, 25);    }  return ret;}

static voiddo_test (json_ctx_t *json_ctx, size_t align1, size_t align2, size_t len){  size_t i, j;  char *s1, *s2;  align1 &= 63;  if (align1 + len >= page_size)    return;  align2 &= 63;  if (align2 + len >= page_size)    return;  s1 = (char *) (buf2 + align1);  s2 = (char *) (buf2 + align2);  for (i = 0, j = 1; i < len; i++, j += 23)    s1[i] = j;  json_element_object_begin (json_ctx);  json_attr_uint (json_ctx, "length", (double) len);  json_attr_uint (json_ctx, "align1", (double) align1);  json_attr_uint (json_ctx, "align2", (double) align2);  json_array_begin (json_ctx, "timings");  FOR_EACH_IMPL (impl, 0)    do_one_test (json_ctx, impl, s2, s1, len);  json_array_end (json_ctx);  json_element_object_end (json_ctx);}

static voiddo_test (size_t align1, size_t align2, size_t len){  size_t i, j;  char *s1, *s2;  align1 &= 63;  if (align1 + len >= page_size)    return;  align2 &= 63;  if (align2 + len >= page_size)    return;  s1 = (char *) (buf1 + align1);  s2 = (char *) (buf2 + align2);  for (i = 0, j = 1; i < len; i++, j += 23)    s1[i] = j;  printf ("Length %4zd, alignment %d/%d:", len, align1, align2);  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, s2, (char *) (buf2 + align1), s1, len);  putchar ('/n');}

static voiddo_test (size_t align1, size_t align2, size_t len, size_t n, int max_char){  size_t i;  char *s1, *s2;  align1 &= 7;  if (align1 + len >= page_size)    return;  align2 &= 7;  if (align2 + len >= page_size)    return;  s1 = (char *) (buf1 + align1);  s2 = (char *) (buf2 + align2);  for (i = 0; i < len; ++i)    s1[i] = 32 + 23 * i % (max_char - 32);  s1[len] = 0;  for (i = len + 1; i + align1 < page_size && i < len + 64; ++i)    s1[i] = 32 + 32 * i % (max_char - 32);  if (HP_TIMING_AVAIL)    printf ("Length %4zd, n %4zd, alignment %2zd/%2zd:", len, n, align1, align2);  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, s2, s1, len, n);  if (HP_TIMING_AVAIL)    putchar ('/n');}

inttest_main (void){  size_t i;  test_init ();  printf ("%28s", "");  FOR_EACH_IMPL (impl, 0)    printf ("/t%s", impl->name);  putchar ('/n');  for (i = 1; i < 8; ++i)    {      do_test (i, i, 16, 16, SMALL_CHAR);      do_test (i, i, 16, 16, BIG_CHAR);      do_test (i, 2 * i, 16, 16, SMALL_CHAR);      do_test (2 * i, i, 16, 16, BIG_CHAR);      do_test (8 - i, 2 * i, 1 << i, 2 << i, SMALL_CHAR);      do_test (2 * i, 8 - i, 2 << i, 1 << i, SMALL_CHAR);      do_test (8 - i, 2 * i, 1 << i, 2 << i, BIG_CHAR);      do_test (2 * i, 8 - i, 2 << i, 1 << i, BIG_CHAR);    }  for (i = 1; i < 8; ++i)    {      do_test (0, 0, 4 << i, 8 << i, SMALL_CHAR);      do_test (0, 0, 16 << i, 8 << i, SMALL_CHAR);      do_test (8 - i, 2 * i, 4 << i, 8 << i, SMALL_CHAR);      do_test (8 - i, 2 * i, 16 << i, 8 << i, SMALL_CHAR);    }  return ret;}

static voiddo_test (size_t align1, size_t align2, size_t len, int max_char){  size_t i;  CHAR *s1, *s2;/* For wcscpy: align1 and align2 here mean alignment not in bytes,   but in wchar_ts, in bytes it will equal to align * (sizeof (wchar_t))   len for wcschr here isn't in bytes but it's number of wchar_t symbols.  */  align1 &= 7;  if ((align1 + len) * sizeof(CHAR) >= page_size)    return;  align2 &= 7;  if ((align2 + len) * sizeof(CHAR) >= page_size)    return;  s1 = (CHAR *) (buf1) + align1;  s2 = (CHAR *) (buf2) + align2;  for (i = 0; i < len; i++)    s1[i] = 32 + 23 * i % (max_char - 32);  s1[len] = 0;  printf ("Length %4zd, alignments in bytes %2zd/%2zd:", len, align1 * sizeof(CHAR), align2 * sizeof(CHAR));  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, s2, s1, len);  putchar ('/n');}

inttest_main (void){  json_ctx_t json_ctx;  size_t i;  test_init ();  json_init (&json_ctx, 0, stdout);  json_document_begin (&json_ctx);  json_attr_string (&json_ctx, "timing_type", TIMING_TYPE);  json_attr_object_begin (&json_ctx, "functions");  json_attr_object_begin (&json_ctx, TEST_NAME);  json_attr_string (&json_ctx, "bench-variant", "default");  json_array_begin (&json_ctx, "ifuncs");  FOR_EACH_IMPL (impl, 0)    json_element_string (&json_ctx, impl->name);  json_array_end (&json_ctx);  json_array_begin (&json_ctx, "results");  for (i = 1; i < 32; ++i)    {      do_test (&json_ctx, CHARBYTES * i, CHARBYTES * i, i, MIDCHAR, 0);      do_test (&json_ctx, CHARBYTES * i, CHARBYTES * i, i, MIDCHAR, 1);      do_test (&json_ctx, CHARBYTES * i, CHARBYTES * i, i, MIDCHAR, -1);    }  for (i = 1; i < 10 + CHARBYTESLOG; ++i)    {      do_test (&json_ctx, 0, 0, 2 << i, MIDCHAR, 0);      do_test (&json_ctx, 0, 0, 2 << i, LARGECHAR, 0);      do_test (&json_ctx, 0, 0, 2 << i, MIDCHAR, 1);      do_test (&json_ctx, 0, 0, 2 << i, LARGECHAR, 1);      do_test (&json_ctx, 0, 0, 2 << i, MIDCHAR, -1);      do_test (&json_ctx, 0, 0, 2 << i, LARGECHAR, -1);      do_test (&json_ctx, 0, CHARBYTES * i, 2 << i, MIDCHAR, 1);      do_test (&json_ctx, CHARBYTES * i, CHARBYTES * (i + 1), 2 << i, LARGECHAR, 1);    }  for (i = 1; i < 8; ++i)    {      do_test (&json_ctx, CHARBYTES * i, 2 * CHARBYTES * i, 8 << i, MIDCHAR, 0);      do_test (&json_ctx, 2 * CHARBYTES * i, CHARBYTES * i, 8 << i, LARGECHAR, 0);      do_test (&json_ctx, CHARBYTES * i, 2 * CHARBYTES * i, 8 << i, MIDCHAR, 1);      do_test (&json_ctx, 2 * CHARBYTES * i, CHARBYTES * i, 8 << i, LARGECHAR, 1);      do_test (&json_ctx, CHARBYTES * i, 2 * CHARBYTES * i, 8 << i, MIDCHAR, -1);      do_test (&json_ctx, 2 * CHARBYTES * i, CHARBYTES * i, 8 << i, LARGECHAR, -1);    }  json_array_end (&json_ctx);  json_attr_object_end (&json_ctx);  json_attr_object_end (&json_ctx);  json_document_end (&json_ctx);  return ret;}

inttest_main (void){  size_t i;  test_init ();  printf ("%28s", "");  FOR_EACH_IMPL (impl, 0)    printf ("/t%s", impl->name);  putchar ('/n');  for (i = 1; i < 8; ++i)    {      do_test (i, i, 12, 16, 16, 127);      do_test (i, i, 23, 16, 16, 255);      do_test (i, 2 * i, 28, 16, 16, 127);      do_test (2 * i, i, 31, 16, 16, 255);      do_test (8 - i, 2 * i, 1, 1 << i, 2 << i, 127);      do_test (2 * i, 8 - i, 17, 2 << i, 1 << i, 127);      do_test (8 - i, 2 * i, 0, 1 << i, 2 << i, 255);      do_test (2 * i, 8 - i, i, 2 << i, 1 << i, 255);    }  for (i = 1; i < 8; ++i)    {      do_test (0, 0, i, 4 << i, 8 << i, 127);      do_test (0, 0, i, 16 << i, 8 << i, 127);      do_test (8 - i, 2 * i, i, 4 << i, 8 << i, 127);      do_test (8 - i, 2 * i, i, 16 << i, 8 << i, 127);    }  return ret;}

inttest_main (void){  size_t i;  test_init ();  printf ("%20s", "");  FOR_EACH_IMPL (impl, 0)    printf ("/t%s", impl->name);  putchar ('/n');  /* Checking with only 4 * N alignments for wcslen, other alignments are wrong for wchar_t type arrays*/  for (i = 1; i < 8; ++i)  {    do_test (sizeof(CHAR) * i, i);    do_test (0, i);  }  for (i = 2; i <= 12; ++i)    {      do_test (0, 1 << i);      do_test (sizeof(CHAR) * 7, 1 << i);      do_test (sizeof(CHAR) * i, 1 << i);      do_test (sizeof(CHAR) * i, (size_t)((1 << i) / 1.5));    }  return ret;}

static voiddo_test (size_t align, size_t pos, size_t len, int seek_char){  size_t i;  char *result;  align &= 7;  if (align + len >= page_size)    return;  for (i = 0; i < len; ++i)    {      buf1[align + i] = 1 + 23 * i % 127;      if (buf1[align + i] == seek_char)	buf1[align + i] = seek_char + 1;    }  buf1[align + len] = 0;  assert (pos < len);  buf1[align + pos] = seek_char;  buf1[align + len] = -seek_char;  result = (char *) (buf1 + align + pos);  if (HP_TIMING_AVAIL)    printf ("Length %4zd, alignment %2zd:", pos, align);  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, (char *) (buf1 + align), seek_char, result);  if (HP_TIMING_AVAIL)    putchar ('/n');}

inttest_main (void){  size_t i;  test_init ();  printf ("%20s", "");  FOR_EACH_IMPL (impl, 0)    printf ("/t%s", impl->name);  putchar ('/n');  for (i = 1; i < 7; ++i)    {      do_test (0, 16 << i, 2048, 23);      do_test (i, 64, 256, 23);      do_test (0, 16 << i, 2048, 0);      do_test (i, 64, 256, 0);    }  for (i = 1; i < 32; ++i)    {      do_test (0, i, i + 1, 23);      do_test (0, i, i + 1, 0);    }  return ret;}

static voiddo_test (size_t align1, size_t align2, size_t len, size_t dlen, int max_char){  size_t i;  char *s1, *s2;  align1 &= 7;  if (align1 + len >= page_size)    return;  align2 &= 7;  if (align2 + len >= page_size)    return;  s1 = (char *) buf1 + align1;  s2 = (char *) buf2 + align2;  for (i = 0; i < len; i++)    s1[i] = 32 + 23 * i % (max_char - 32);  s1[len] = 0;  if (dlen > len)    printf ("Length %4zd, alignment %2zd/%2zd:", len, align1, align2);  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, s2, s1, len, dlen);  if (dlen > len)    putchar ('/n');}

inttest_main (void){  size_t i;  test_init ();  printf ("%32s", "");  FOR_EACH_IMPL (impl, 0)    printf ("/t%s", impl->name);  putchar ('/n');  for (i = 0; i < 32; ++i)    {      do_test (0, 512, i);      do_test (i, 512, i);    }  for (i = 1; i < 8; ++i)    {      do_test (0, 16 << i, 4);      do_test (i, 16 << i, 4);    }  for (i = 1; i < 8; ++i)    do_test (i, 64, 10);  for (i = 0; i < 64; ++i)    do_test (0, i, 6);  return ret;}

inttest_main (void){  size_t i;  test_init ();  printf ("%23s", "");  FOR_EACH_IMPL (impl, 0)    printf ("/t%s", impl->name);  putchar ('/n');  for (i = 0; i < BUF1PAGES * page_size; ++i)    buf1[i] = 60 + random () % 32;  for (i = 0; i < sizeof (strs) / sizeof (strs[0]); ++i)    for (size_t j = 0; j < 120; j += 7)      {	size_t len = strlen (strs[i]);	do_test (strs[i], len, j);      }  do_random_tests ();  return ret;}

static voiddo_random_tests (void){  for (size_t n = 0; n < ITERATIONS; ++n)    {      char tmpbuf[32];      size_t shift = random () % 11;      size_t rel = random () % ((2 << (shift + 1)) * 64);      size_t idx = MIN ((2 << shift) * 64 + rel, BUF1PAGES * page_size - 2);      size_t len = random () % (sizeof (tmpbuf) - 1) + 1;      len = MIN (len, BUF1PAGES * page_size - idx - 1);      memcpy (tmpbuf, buf1 + idx, len);      for (size_t i = random () % len / 2 + 1; i > 0; --i)	{	  size_t off = random () % len;	  char ch = '0' + random () % 10;	  buf1[idx + off] = ch;	}      printf ("String %.*s, offset %zd:", (int) len, buf1 + idx, idx);      FOR_EACH_IMPL (impl, 0)	do_one_test (impl, buf1, BUF1PAGES * page_size, buf1 + idx, len,		     buf1 + idx);      putchar ('/n');      memcpy (buf1 + idx, tmpbuf, len);    }}

static voiddo_test (size_t align1, size_t align2, int c, size_t len, size_t n,	 int max_char){  size_t i;  char *s1, *s2;  align1 &= 7;  if (align1 + len >= page_size)    return;  align2 &= 7;  if (align2 + len >= page_size)    return;  s1 = (char *) (buf1 + align1);  s2 = (char *) (buf2 + align2);  for (i = 0; i < len - 1; ++i)    {      s1[i] = 32 + 23 * i % (max_char - 32);      if (s1[i] == (char) c)	--s1[i];    }  s1[len - 1] = c;  for (i = len; i + align1 < page_size && i < len + 64; ++i)    s1[i] = 32 + 32 * i % (max_char - 32);  printf ("Length %4zd, n %4zd, char %d, alignment %2zd/%2zd:", len, n, c, align1, align2);  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, s2, s1, c, len, n);  putchar ('/n');}

static voiddo_test (size_t align1, size_t align2, size_t len, size_t n, int max_char){  size_t i;  CHAR *s1, *s2;/* For wcsncpy: align1 and align2 here mean alignment not in bytes,   but in wchar_ts, in bytes it will equal to align * (sizeof (wchar_t)).  */  align1 &= 7;  if ((align1 + len) * sizeof (CHAR) >= page_size)    return;  align2 &= 7;  if ((align2 + len) * sizeof (CHAR) >= page_size)    return;  s1 = (CHAR *) (buf1) + align1;  s2 = (CHAR *) (buf2) + align2;  for (i = 0; i < len; ++i)    s1[i] = 32 + 23 * i % (max_char - 32);  s1[len] = 0;  for (i = len + 1; (i + align1) * sizeof (CHAR) < page_size && i < len + 64;       ++i)    s1[i] = 32 + 32 * i % (max_char - 32);  printf ("Length %4zd, n %4zd, alignment %2zd/%2zd:", len, n, align1, align2);  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, s2, s1, len, n);  putchar ('/n');}

static inttest_main (void){  test_init ();  check1 ();  printf ("%23s", "");  FOR_EACH_IMPL (impl, 0)    printf ("/t%s", impl->name);  putchar ('/n');  for (size_t klen = 2; klen < 32; ++klen)    for (size_t hlen = 2 * klen; hlen < 16 * klen; hlen += klen)      {	do_test (0, 0, hlen, klen, 0);	do_test (0, 0, hlen, klen, 1);	do_test (0, 3, hlen, klen, 0);	do_test (0, 3, hlen, klen, 1);	do_test (0, 9, hlen, klen, 0);	do_test (0, 9, hlen, klen, 1);	do_test (0, 15, hlen, klen, 0);	do_test (0, 15, hlen, klen, 1);	do_test (3, 0, hlen, klen, 0);	do_test (3, 0, hlen, klen, 1);	do_test (3, 3, hlen, klen, 0);	do_test (3, 3, hlen, klen, 1);	do_test (3, 9, hlen, klen, 0);	do_test (3, 9, hlen, klen, 1);	do_test (3, 15, hlen, klen, 0);	do_test (3, 15, hlen, klen, 1);	do_test (9, 0, hlen, klen, 0);	do_test (9, 0, hlen, klen, 1);	do_test (9, 3, hlen, klen, 0);	do_test (9, 3, hlen, klen, 1);	do_test (9, 9, hlen, klen, 0);	do_test (9, 9, hlen, klen, 1);	do_test (9, 15, hlen, klen, 0);	do_test (9, 15, hlen, klen, 1);	do_test (15, 0, hlen, klen, 0);	do_test (15, 0, hlen, klen, 1);	do_test (15, 3, hlen, klen, 0);	do_test (15, 3, hlen, klen, 1);	do_test (15, 9, hlen, klen, 0);	do_test (15, 9, hlen, klen, 1);	do_test (15, 15, hlen, klen, 0);	do_test (15, 15, hlen, klen, 1);      }  do_test (0, 0, page_size - 1, 16, 0);  do_test (0, 0, page_size - 1, 16, 1);  return ret;}

static voiddo_test (size_t align, size_t pos, size_t len){  size_t i;  int c;  RES_TYPE result;  char *rej, *s;  align &= 7;  if (align + pos + 10 >= page_size || len > 240)    return;  rej = (char *) (buf2 + (random () & 255));  s = (char *) (buf1 + align);  for (i = 0; i < len; ++i)    {      rej[i] = random () & 255;      if (!rej[i])	rej[i] = random () & 255;      if (!rej[i])	rej[i] = 1 + (random () & 127);    }  rej[len] = '/0';  for (c = 1; c <= 255; ++c)    if (strchr (rej, c) == NULL)      break;  for (i = 0; i < pos; ++i)    {      s[i] = random () & 255;      if (strchr (rej, s[i]))	{	  s[i] = random () & 255;	  if (strchr (rej, s[i]))	    s[i] = c;	}    }  s[pos] = rej[random () % (len + 1)];  if (s[pos])    {      for (i = pos + 1; i < pos + 10; ++i)	s[i] = random () & 255;      s[i] = '/0';    }  result = STRPBRK_RESULT (s, pos);  if (HP_TIMING_AVAIL)    printf ("Length %4zd, alignment %2zd, rej len %2zd:", pos, align, len);  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, s, rej, result);  if (HP_TIMING_AVAIL)    putchar ('/n');}

static voidcheck1 (void){  const char s1[] = "AOKB";  const char s2[] = "OK";  char *exp_result;  exp_result = stupid_strcasestr (s1, s2);  FOR_EACH_IMPL (impl, 0)    check_result (impl, s1, s2, exp_result);}

static voiddo_test (size_t align, size_t pos, size_t len){  size_t i;  int c;  RES_TYPE result;  CHAR *rej, *s;  align &= 7;  if ((align + pos + 10) * sizeof (CHAR) >= page_size || len > 240)    return;  rej = (CHAR *) (buf2) + (random () & 255);  s = (CHAR *) (buf1) + align;  for (i = 0; i < len; ++i)    {      rej[i] = random () & BIG_CHAR;      if (!rej[i])	rej[i] = random () & BIG_CHAR;      if (!rej[i])	rej[i] = 1 + (random () & SMALL_CHAR);    }  rej[len] = '/0';  for (c = 1; c <= BIG_CHAR; ++c)    if (STRCHR (rej, c) == NULL)      break;  for (i = 0; i < pos; ++i)    {      s[i] = random () & BIG_CHAR;      if (STRCHR (rej, s[i]))	{	  s[i] = random () & BIG_CHAR;	  if (STRCHR (rej, s[i]))	    s[i] = c;	}    }  s[pos] = rej[random () % (len + 1)];  if (s[pos])    {      for (i = pos + 1; i < pos + 10; ++i)	s[i] = random () & BIG_CHAR;      s[i] = '/0';    }  result = STRPBRK_RESULT (s, pos);  printf ("Length %4zd, alignment %2zd, rej len %2zd:", pos, align, len);  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, s, rej, result);  putchar ('/n');}

inttest_main (void){  size_t i;  test_init ();  printf ("%23s", "");  FOR_EACH_IMPL (impl, 0)    printf ("/t%s", impl->name);  putchar ('/n');  for (i = 0; i < 16; ++i)    {      do_test (0, 0, i, SMALL_CHAR);      do_test (0, 0, i, BIG_CHAR);      do_test (0, i, i, SMALL_CHAR);      do_test (i, 0, i, BIG_CHAR);    }  for (i = 1; i < 8; ++i)    {      do_test (0, 0, 8 << i, SMALL_CHAR);      do_test (8 - i, 2 * i, 8 << i, SMALL_CHAR);    }  for (i = 1; i < 8; ++i)    {      do_test (i, 2 * i, 8 << i, SMALL_CHAR);      do_test (2 * i, i, 8 << i, BIG_CHAR);      do_test (i, i, 8 << i, SMALL_CHAR);      do_test (i, i, 8 << i, BIG_CHAR);    }  for (i = 16; i <= 512; i+=4)    {      do_test (0, 4, i, SMALL_CHAR);      do_test (4, 0, i, BIG_CHAR);      do_test (4, 4, i, SMALL_CHAR);      do_test (2, 2, i, BIG_CHAR);      do_test (2, 6, i, SMALL_CHAR);      do_test (6, 2, i, BIG_CHAR);      do_test (1, 7, i, SMALL_CHAR);      do_test (7, 1, i, BIG_CHAR);      do_test (3, 4, i, SMALL_CHAR);      do_test (4, 3, i, BIG_CHAR);      do_test (5, 7, i, SMALL_CHAR);      do_test (7, 5, i, SMALL_CHAR);    }  return ret;}

static voiddo_test (json_ctx_t *json_ctx, size_t len){  json_element_object_begin (json_ctx);  json_attr_uint (json_ctx, "length", (double) len);  json_array_begin (json_ctx, "timings");  FOR_EACH_IMPL (impl, 0)    do_one_test (json_ctx, impl, (char *) buf2, (char *) buf1, len);  json_array_end (json_ctx);  json_element_object_end (json_ctx);}

inttest_main (void){  size_t i;  test_init ();  printf ("%20s", "");  FOR_EACH_IMPL (impl, 0)    printf ("/t%s", impl->name);  putchar ('/n');  for (i = 1; i < 8; ++i)    {      do_test (0, 16 << i, 2048, 23, SMALL_CHAR);      do_test (i, 16 << i, 2048, 23, SMALL_CHAR);    }  for (i = 1; i < 8; ++i)    {      do_test (i, 64, 256, 23, SMALL_CHAR);      do_test (i, 64, 256, 23, BIG_CHAR);    }  for (i = 0; i < 32; ++i)    {      do_test (0, i, i + 1, 23, SMALL_CHAR);      do_test (0, i, i + 1, 23, BIG_CHAR);    }  for (i = 1; i < 8; ++i)    {      do_test (0, 16 << i, 2048, 0, SMALL_CHAR);      do_test (i, 16 << i, 2048, 0, SMALL_CHAR);    }  for (i = 1; i < 8; ++i)    {      do_test (i, 64, 256, 0, SMALL_CHAR);      do_test (i, 64, 256, 0, BIG_CHAR);    }  for (i = 0; i < 32; ++i)    {      do_test (0, i, i + 1, 0, SMALL_CHAR);      do_test (0, i, i + 1, 0, BIG_CHAR);    }  do_random_tests ();  return ret;}

inttest_main (void){  size_t i;  test_init ();  printf ("%23s", "");  FOR_EACH_IMPL (impl, 0)    printf ("/t%s", impl->name);  putchar ('/n');  for (i = 0; i < 18; ++i)    {      do_test (0, 0, 1 << i);      do_test (i, 0, 1 << i);      do_test (0, i, 1 << i);      do_test (i, i, 1 << i);    }  for (i = 0; i < 32; ++i)    {      do_test (0, 0, i);      do_test (i, 0, i);      do_test (0, i, i);      do_test (i, i, i);    }  for (i = 3; i < 32; ++i)    {      if ((i & (i - 1)) == 0)	continue;      do_test (0, 0, 16 * i);      do_test (i, 0, 16 * i);      do_test (0, i, 16 * i);      do_test (i, i, 16 * i);    }  for (i = 32; i < 64; ++i)    {      do_test (0, 0, 32 * i);      do_test (i, 0, 32 * i);      do_test (0, i, 32 * i);      do_test (i, i, 32 * i);    }  do_test (0, 0, getpagesize ());  return ret;}

static voiddo_test (size_t align, int c, size_t len){  align &= 7;  if (align + len > page_size)    return;  printf ("Length %4zd, alignment %2zd, c %2d:", len, align, c);  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, (char *) buf1 + align, c, len);  putchar ('/n');}

static voiddo_test (size_t align, int c, size_t len){  align &= 63;  if ((align + len) * sizeof (CHAR) > page_size)    return;  printf ("Length %4zd, alignment %2zd, c %2d:", len, align, c);  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, (CHAR *) (buf1) + align, c, len);  putchar ('/n');}

static voiddo_test (size_t align1, size_t align2, size_t len1, size_t len2,	 int fail){  char *s1 = (char *) (buf1 + align1);  char *s2 = (char *) (buf2 + align2);  static const char d[] = "1234567890abcxyz";#define dl (sizeof (d) - 1)  char *ss2 = s2;  for (size_t l = len2; l > 0; l = l > dl ? l - dl : 0)    {      size_t t = l > dl ? dl : l;      ss2 = mempcpy (ss2, d, t);    }  s2[len2] = '/0';  if (fail)    {      char *ss1 = s1;      for (size_t l = len1; l > 0; l = l > dl ? l - dl : 0)	{	  size_t t = l > dl ? dl : l;	  memcpy (ss1, d, t);	  ++ss1[len2 > 7 ? 7 : len2 - 1];	  ss1 += t;	}    }  else    {      memset (s1, '0', len1);      for (size_t i = 0; i < len2; ++i)	s1[len1 - len2 + i] = toupper (s2[i]);    }  s1[len1] = '/0';  if (HP_TIMING_AVAIL)    printf ("Length %4zd/%zd, alignment %2zd/%2zd, %s:",	    len1, len2, align1, align2, fail ? "fail" : "found");  FOR_EACH_IMPL (impl, 0)    do_one_test (impl, s1, s2, fail ? NULL : s1 + len1 - len2);  if (HP_TIMING_AVAIL)    putchar ('/n');}