void RunCmpBufferAlignTest(
size_t max_test_size, void (*test_cmp_func)(uint8_t*, uint8_t*, size_t),
void (*test_miscmp_func)(uint8_t*, uint8_t*, size_t, size_t),
size_t (*set_incr)(size_t)) {
if (!set_incr) {
set_incr = SetIncrement;
}
// Allocate two large buffers for all of the testing.
uint8_t* buf1 = new uint8_t[3*max_test_size];
uint8_t* buf2 = new uint8_t[3*max_test_size];
uint8_t* buf1_align;
uint8_t* buf2_align;
for (size_t i = 0; i < g_double_aligns_len; i++) {
size_t incr = 1;
for (size_t len = 0; len <= max_test_size; len += incr) {
incr = set_incr(len);
buf1_align =
reinterpret_cast<uint8_t*>(GetAlignedPtr(
buf1, g_double_aligns[i][0], g_double_aligns[i][1]));
buf2_align =
reinterpret_cast<uint8_t*>(GetAlignedPtr(
buf2, g_double_aligns[i][2], g_double_aligns[i][3]));
// Check by putting all zeroes after both buffers.
memset(buf1_align+len, 0, 32);
memset(buf2_align+len, 0, 32);
test_cmp_func(buf1_align, buf2_align, len);
// Check by putting different values after both buffers.
for (size_t j = 0; j < 32; j++) {
buf1_align[len+j] = j;
buf2_align[len+j] = j+1;
}
test_cmp_func(buf1_align, buf2_align, len);
if (len > 0) {
// Change the lengths of the buffers and verify that there are
// miscompares.
for (size_t len2 = len+1; len2 < len+32; len2++) {
test_miscmp_func(buf1_align, buf2_align, len, len2);
test_miscmp_func(buf1_align, buf2_align, len2, len);
}
}
}
}
delete buf1;
delete buf2;
}
void RunSingleBufferAlignTest(
size_t max_test_size, void (*test_func)(uint8_t*, size_t),
size_t (*set_incr)(size_t)) {
if (!set_incr) {
set_incr = SetIncrement;
}
// Allocate one large buffer with lots of extra space so that we can
// guarantee that the all possible alignments will fit.
uint8_t *buf = new uint8_t[3*max_test_size];
uint8_t *buf_align;
for (size_t i = 0; i < g_single_aligns_len; i++) {
size_t incr = 1;
for (size_t len = 0; len <= max_test_size; len += incr) {
incr = set_incr(len);
buf_align = reinterpret_cast<uint8_t*>(GetAlignedPtr(
buf+FENCEPOST_LENGTH, g_single_aligns[i][0], g_single_aligns[i][1]));
SetFencepost(&buf_align[-FENCEPOST_LENGTH]);
SetFencepost(&buf_align[len]);
test_func(buf_align, len);
VerifyFencepost(&buf_align[-FENCEPOST_LENGTH]);
VerifyFencepost(&buf_align[len]);
}
}
delete buf;
}
void RunSrcDstBufferAlignTest(
size_t max_test_size, void (*test_func)(uint8_t*, uint8_t*, size_t),
size_t (*set_incr)(size_t)) {
if (!set_incr) {
set_incr = SetIncrement;
}
// Allocate two large buffers for all of the testing.
uint8_t* src = new uint8_t[3*max_test_size];
uint8_t* dst = new uint8_t[3*max_test_size];
uint8_t* src_align;
uint8_t* dst_align;
for (size_t i = 0; i < g_double_aligns_len; i++) {
size_t incr = 1;
for (size_t len = 0; len <= max_test_size; len += incr) {
incr = set_incr(len);
src_align =
reinterpret_cast<uint8_t*>(GetAlignedPtr(
src+FENCEPOST_LENGTH, g_double_aligns[i][0], g_double_aligns[i][1]));
dst_align =
reinterpret_cast<uint8_t*>(GetAlignedPtr(
dst+FENCEPOST_LENGTH, g_double_aligns[i][2], g_double_aligns[i][3]));
SetFencepost(&dst_align[-FENCEPOST_LENGTH]);
SetFencepost(&dst_align[len]);
test_func(src_align, dst_align, len);
VerifyFencepost(&dst_align[-FENCEPOST_LENGTH]);
VerifyFencepost(&dst_align[len]);
}
}
delete src;
delete dst;
}
char* GetAlignedPtrFilled(std::vector<char>* buf, size_t alignment, size_t nbytes, char fill_byte) {
char* buf_aligned = GetAlignedPtr(buf, alignment, nbytes);
memset(buf_aligned, fill_byte, nbytes);
return buf_aligned;
}
