db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-06-25 00:16:54 +02:00
Code Issues Releases Activity

Refactor C page checksum unit test to compile with -Wstrict-aliasing.

Browse Source
This commit is contained in:
David Steele
2017-11-20 08:58:47 -05:00
parent 5d741ea9a9
commit deae0b8cd7
2 changed files with 36 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
test/src/module/postgres/pageChecksumTest.c
View File

@ -8,7 +8,13 @@ Page data for testing -- use 8192 for page size since this is the most common va
#define TEST_PAGE_SIZE 8192
#define TEST_PAGE_TOTAL 16
static unsigned char testPageBuffer[TEST_PAGE_TOTAL][TEST_PAGE_SIZE];
// GCC doesn't like this elements of this array being used as both char * and struct * so wrap it in a function to disable the
// optimizations that cause warnings
unsigned char *testPage(int pageIdx)
{
static unsigned char testPageBuffer[TEST_PAGE_TOTAL][TEST_PAGE_SIZE];
return testPageBuffer[pageIdx];
}
/***********************************************************************************************************************************
Test Run
@ -19,42 +25,42 @@ void testRun()
if (testBegin("pageChecksum()"))
{
// Checksum for 0x00 fill, page 0x00
memset(testPageBuffer[0], 0, TEST_PAGE_SIZE);
TEST_RESULT_U16_HEX(pageChecksum(testPageBuffer[0], 0, TEST_PAGE_SIZE), 0xC6AA, "check for 0x00 filled page, block 0");
memset(testPage(0), 0, TEST_PAGE_SIZE);
TEST_RESULT_U16_HEX(pageChecksum(testPage(0), 0, TEST_PAGE_SIZE), 0xC6AA, "check for 0x00 filled page, block 0");
// Checksum for 0xFF fill, page 0x00
memset(testPageBuffer[0], 0xFF, TEST_PAGE_SIZE);
TEST_RESULT_U16_HEX(pageChecksum(testPageBuffer[0], 0, TEST_PAGE_SIZE), 0x0E1C, "check for 0xFF filled page, block 0");
memset(testPage(0), 0xFF, TEST_PAGE_SIZE);
TEST_RESULT_U16_HEX(pageChecksum(testPage(0), 0, TEST_PAGE_SIZE), 0x0E1C, "check for 0xFF filled page, block 0");
// Checksum for 0xFF fill, page 0xFF
memset(testPageBuffer[0], 0xFF, TEST_PAGE_SIZE);
TEST_RESULT_U16_HEX(pageChecksum(testPageBuffer[0], 999, TEST_PAGE_SIZE), 0x0EC3, "check for 0xFF filled page, block 999");
memset(testPage(0), 0xFF, TEST_PAGE_SIZE);
TEST_RESULT_U16_HEX(pageChecksum(testPage(0), 999, TEST_PAGE_SIZE), 0x0EC3, "check for 0xFF filled page, block 999");
}
// -----------------------------------------------------------------------------------------------------------------------------
if (testBegin("pageChecksumTest()"))
{
// Zero the pages
memset(testPageBuffer, 0, TEST_PAGE_TOTAL * TEST_PAGE_SIZE);
memset(testPage(0), 0, TEST_PAGE_TOTAL * TEST_PAGE_SIZE);
// Pages with pd_upper = 0 should always return true no matter the block no
TEST_RESULT_BOOL(pageChecksumTest(testPageBuffer[0], 0, TEST_PAGE_SIZE, 0, 0), true, "pd_upper is 0, block 0");
TEST_RESULT_BOOL(pageChecksumTest(testPageBuffer[1], 999, TEST_PAGE_SIZE, 0, 0), true, "pd_upper is 0, block 999");
TEST_RESULT_BOOL(pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0, 0), true, "pd_upper is 0, block 0");
TEST_RESULT_BOOL(pageChecksumTest(testPage(1), 999, TEST_PAGE_SIZE, 0, 0), true, "pd_upper is 0, block 999");
// Update pd_upper and check for failure no matter the block no
((PageHeader)testPageBuffer[0])->pd_upper = 0x00FF;
TEST_RESULT_BOOL(pageChecksumTest(testPageBuffer[0], 0, TEST_PAGE_SIZE, 0xFFFF, 0xFFFF), false, "badchecksum, page 0");
((PageHeader)testPage(0))->pd_upper = 0x00FF;
TEST_RESULT_BOOL(pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0xFFFF, 0xFFFF), false, "badchecksum, page 0");
TEST_RESULT_BOOL(
pageChecksumTest(testPageBuffer[0], 9999, TEST_PAGE_SIZE, 0xFFFF, 0xFFFF), false, "badchecksum, page 9999");
pageChecksumTest(testPage(0), 9999, TEST_PAGE_SIZE, 0xFFFF, 0xFFFF), false, "badchecksum, page 9999");
// Update LSNs and check that page checksums past the ignore limits are successful
((PageHeader)testPageBuffer[0])->pd_lsn.walid = 0x8888;
((PageHeader)testPageBuffer[0])->pd_lsn.xrecoff = 0x8888;
((PageHeader)testPage(0))->pd_lsn.walid = 0x8888;
((PageHeader)testPage(0))->pd_lsn.xrecoff = 0x8888;
TEST_RESULT_BOOL(
pageChecksumTest(testPageBuffer[0], 0, TEST_PAGE_SIZE, 0x8888, 0x8888), true, "bad checksum past ignore limit");
pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0x8888, 0x8888), true, "bad checksum past ignore limit");
TEST_RESULT_BOOL(
pageChecksumTest(testPageBuffer[0], 0, TEST_PAGE_SIZE, 0x8889, 0x8889), false, "bad checksum before ignore limit");
pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0x8889, 0x8889), false, "bad checksum before ignore limit");
}
// -----------------------------------------------------------------------------------------------------------------------------
@ -62,20 +68,20 @@ void testRun()
{
// Check that assertion fails if page buffer and page size are not divisible
TEST_ERROR(
pageChecksumBufferTest(testPageBuffer[0], TEST_PAGE_TOTAL * TEST_PAGE_SIZE - 1, 0, TEST_PAGE_SIZE, 0, 0),
pageChecksumBufferTest(testPage(0), TEST_PAGE_TOTAL * TEST_PAGE_SIZE - 1, 0, TEST_PAGE_SIZE, 0, 0),
AssertError, "buffer size 131071, page size 8192 are not divisible");
// Create pages that will pass the test (starting with block 0)
for (int pageIdx = 0; pageIdx < TEST_PAGE_TOTAL; pageIdx++)
{
// Don't fill with zero because zeroes will succeed on the pd_upper check
memset(testPageBuffer[pageIdx], 0x77, TEST_PAGE_SIZE);
memset(testPage(pageIdx), 0x77, TEST_PAGE_SIZE);
((PageHeader)testPageBuffer[pageIdx])->pd_checksum = pageChecksum(testPageBuffer[pageIdx], pageIdx, TEST_PAGE_SIZE);
((PageHeader)testPage(pageIdx))->pd_checksum = pageChecksum(testPage(pageIdx), pageIdx, TEST_PAGE_SIZE);
}
TEST_RESULT_BOOL(
pageChecksumBufferTest(testPageBuffer[0], TEST_PAGE_TOTAL * TEST_PAGE_SIZE, 0, TEST_PAGE_SIZE, 0xFFFFFFFF, 0xFFFFFFFF),
pageChecksumBufferTest(testPage(0), TEST_PAGE_TOTAL * TEST_PAGE_SIZE, 0, TEST_PAGE_SIZE, 0xFFFFFFFF, 0xFFFFFFFF),
true, "valid page buffer starting at block 0");
// Create pages that will pass the test (beginning with block <> 0)
@ -83,23 +89,23 @@ void testRun()
for (int pageIdx = 0; pageIdx < TEST_PAGE_TOTAL; pageIdx++)
{
((PageHeader)testPageBuffer[pageIdx])->pd_checksum = pageChecksum(
testPageBuffer[pageIdx], pageIdx + blockBegin, TEST_PAGE_SIZE);
((PageHeader)testPage(pageIdx))->pd_checksum = pageChecksum(
testPage(pageIdx), pageIdx + blockBegin, TEST_PAGE_SIZE);
}
TEST_RESULT_BOOL(
pageChecksumBufferTest(
testPageBuffer[0], TEST_PAGE_TOTAL * TEST_PAGE_SIZE, blockBegin, TEST_PAGE_SIZE, 0xFFFFFFFF, 0xFFFFFFFF),
testPage(0), TEST_PAGE_TOTAL * TEST_PAGE_SIZE, blockBegin, TEST_PAGE_SIZE, 0xFFFFFFFF, 0xFFFFFFFF),
true, "valid page buffer starting at block 999");
// Break the checksum for a page and make sure it is found
int pageInvalid = 7;
assert(pageInvalid >= 0 && pageInvalid < TEST_PAGE_TOTAL);
((PageHeader)testPageBuffer[pageInvalid])->pd_checksum = 0xEEEE;
((PageHeader)testPage(pageInvalid))->pd_checksum = 0xEEEE;
TEST_RESULT_BOOL(
pageChecksumBufferTest(
testPageBuffer[0], TEST_PAGE_TOTAL * TEST_PAGE_SIZE, blockBegin, TEST_PAGE_SIZE, 0xFFFFFFFF, 0xFFFFFFFF),
testPage(0), TEST_PAGE_TOTAL * TEST_PAGE_SIZE, blockBegin, TEST_PAGE_SIZE, 0xFFFFFFFF, 0xFFFFFFFF),
false, "invalid page buffer");
}
}