static void do_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 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; 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'); }
int test_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 void do_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 void do_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 void do_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'); }
int test_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 void do_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'); }
int test_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; }
int test_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; }
int test_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 void do_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'); }
int test_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 void do_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'); }
int test_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; }
int test_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 void do_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 void do_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 void do_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 int test_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 void do_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 void check1 (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 void do_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'); }
int test_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 void do_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); }
int test_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; }
int test_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 void do_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 void do_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 void do_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'); }