From ee776e95f801f0fe3ae9023f7de60407e5c79f85 Mon Sep 17 00:00:00 2001 From: Natalia Portillo Date: Wed, 6 Oct 2021 04:28:26 +0100 Subject: [PATCH] Add tests with a misaligned buffer. --- tests/adler32.cpp | 89 +++++++++++++++++++++++++++++++++++++++++++ tests/crc16.cpp | 23 ++++++++++- tests/crc16_ccitt.cpp | 23 ++++++++++- tests/crc32.cpp | 73 ++++++++++++++++++++++++++++++++++- tests/crc64.cpp | 47 ++++++++++++++++++++++- tests/fletcher16.cpp | 23 ++++++++++- tests/fletcher32.cpp | 23 ++++++++++- tests/spamsum.cpp | 26 ++++++++++++- 8 files changed, 320 insertions(+), 7 deletions(-) diff --git a/tests/adler32.cpp b/tests/adler32.cpp index 01618f9..7065f82 100644 --- a/tests/adler32.cpp +++ b/tests/adler32.cpp @@ -4,6 +4,7 @@ #include #include +#include #include "../library.h" #include "../adler32.h" @@ -16,6 +17,7 @@ #define EXPECTED_ADLER32_2352BYTES 0xECD1738B static const uint8_t* buffer; +static const uint8_t* buffer_misaligned; class adler32Fixture : public ::testing::Test { @@ -39,10 +41,14 @@ class adler32Fixture : public ::testing::Test buffer = (const uint8_t*)malloc(1048576); fread((void*)buffer, 1, 1048576, file); fclose(file); + + buffer_misaligned = (const uint8_t*)malloc(1048577); + memcpy((void*)(buffer_misaligned + 1), buffer, 1048576); } void TearDown() { free((void*)buffer); + free((void*)buffer_misaligned); } ~adler32Fixture() @@ -82,6 +88,35 @@ TEST_F(adler32Fixture, adler32_slicing) EXPECT_EQ(adler32, EXPECTED_ADLER32); } +TEST_F(adler32Fixture, adler32_auto_misaligned) +{ + adler32_ctx* ctx = adler32_init(); + uint32_t adler32; + + EXPECT_NE(ctx, nullptr); + + adler32_update(ctx, buffer_misaligned+1, 1048576); + adler32_final(ctx, &adler32); + + EXPECT_EQ(adler32, EXPECTED_ADLER32); +} + +TEST_F(adler32Fixture, adler32_slicing_misaligned) +{ + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_slicing(&sum1, &sum2, buffer_misaligned+1, 1048576); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32); +} + TEST_F(adler32Fixture, adler32_auto_15bytes) { adler32_ctx* ctx = adler32_init(); @@ -217,6 +252,24 @@ TEST_F(adler32Fixture, adler32_neon) EXPECT_EQ(adler32, EXPECTED_ADLER32); } +TEST_F(adler32Fixture, adler32_neon_misaligned) +{ + if(!have_neon()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_neon(&sum1, &sum2, buffer_misaligned+1, 1048576); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32); +} + TEST_F(adler32Fixture, adler32_neon_15bytes) { if(!have_neon()) return; @@ -329,6 +382,42 @@ TEST_F(adler32Fixture, adler32_ssse3) EXPECT_EQ(adler32, EXPECTED_ADLER32); } +TEST_F(adler32Fixture, adler32_avx2_misaligned) +{ + if(!have_avx2()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_avx2(&sum1, &sum2, buffer_misaligned+1, 1048576); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32); +} + +TEST_F(adler32Fixture, adler32_ssse3_misaligned) +{ + if(!have_ssse3()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_ssse3(&sum1, &sum2, buffer_misaligned+1, 1048576); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32); +} + TEST_F(adler32Fixture, adler32_avx2_15bytes) { if(!have_avx2()) return; diff --git a/tests/crc16.cpp b/tests/crc16.cpp index e3408ff..788a333 100644 --- a/tests/crc16.cpp +++ b/tests/crc16.cpp @@ -4,6 +4,7 @@ #include #include +#include #include "../library.h" #include "../crc16.h" @@ -16,6 +17,7 @@ #define EXPECTED_CRC16_2352BYTES 0x23F4 static const uint8_t* buffer; +static const uint8_t* buffer_misaligned; class crc16Fixture : public ::testing::Test { @@ -39,9 +41,15 @@ class crc16Fixture : public ::testing::Test buffer = (const uint8_t*)malloc(1048576); fread((void*)buffer, 1, 1048576, file); fclose(file); + + buffer_misaligned = (const uint8_t*)malloc(1048577); + memcpy((void*)(buffer_misaligned + 1), buffer, 1048576); } - void TearDown() { free((void*)buffer); } + void TearDown() { + free((void*)buffer); + free((void*)buffer_misaligned); + } ~crc16Fixture() { @@ -64,6 +72,19 @@ TEST_F(crc16Fixture, crc16_auto) EXPECT_EQ(crc, EXPECTED_CRC16); } +TEST_F(crc16Fixture, crc16_auto_misaligned) +{ + crc16_ctx* ctx = crc16_init(); + uint16_t crc; + + EXPECT_NE(ctx, nullptr); + + crc16_update(ctx, buffer_misaligned+1, 1048576); + crc16_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC16); +} + TEST_F(crc16Fixture, crc16_auto_15bytes) { crc16_ctx* ctx = crc16_init(); diff --git a/tests/crc16_ccitt.cpp b/tests/crc16_ccitt.cpp index 842f572..3d4df79 100644 --- a/tests/crc16_ccitt.cpp +++ b/tests/crc16_ccitt.cpp @@ -4,6 +4,7 @@ #include #include +#include #include "../library.h" #include "../crc16_ccitt.h" @@ -16,6 +17,7 @@ #define EXPECTED_CRC16_CCITT_2352BYTES 0x1946 static const uint8_t* buffer; +static const uint8_t* buffer_misaligned; class crc16_ccittFixture : public ::testing::Test { @@ -39,9 +41,15 @@ class crc16_ccittFixture : public ::testing::Test buffer = (const uint8_t*)malloc(1048576); fread((void*)buffer, 1, 1048576, file); fclose(file); + + buffer_misaligned = (const uint8_t*)malloc(1048577); + memcpy((void*)(buffer_misaligned + 1), buffer, 1048576); } - void TearDown() { free((void*)buffer); } + void TearDown() { + free((void*)buffer); + free((void*)buffer_misaligned); + } ~crc16_ccittFixture() { @@ -64,6 +72,19 @@ TEST_F(crc16_ccittFixture, crc16_ccitt_auto) EXPECT_EQ(crc, EXPECTED_CRC16_CCITT); } +TEST_F(crc16_ccittFixture, crc16_ccitt_auto_misaligned) +{ + crc16_ccitt_ctx* ctx = crc16_ccitt_init(); + uint16_t crc; + + EXPECT_NE(ctx, nullptr); + + crc16_ccitt_update(ctx, buffer_misaligned+1, 1048576); + crc16_ccitt_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC16_CCITT); +} + TEST_F(crc16_ccittFixture, crc16_ccitt_auto_15bytes) { crc16_ccitt_ctx* ctx = crc16_ccitt_init(); diff --git a/tests/crc32.cpp b/tests/crc32.cpp index 98cc41a..d4fef34 100644 --- a/tests/crc32.cpp +++ b/tests/crc32.cpp @@ -4,6 +4,7 @@ #include #include +#include #include "../library.h" #include "../crc32.h" @@ -16,6 +17,7 @@ #define EXPECTED_CRC32_2352BYTES 0x08ba93ea static const uint8_t* buffer; +static const uint8_t* buffer_misaligned; class crc32Fixture : public ::testing::Test { @@ -39,9 +41,15 @@ class crc32Fixture : public ::testing::Test buffer = (const uint8_t*)malloc(1048576); fread((void*)buffer, 1, 1048576, file); fclose(file); + + buffer_misaligned = (const uint8_t*)malloc(1048577); + memcpy((void*)(buffer_misaligned + 1), buffer, 1048576); } - void TearDown() { free((void*)buffer); } + void TearDown() { + free((void*)buffer); + free((void*)buffer_misaligned); + } ~crc32Fixture() { @@ -75,6 +83,30 @@ TEST_F(crc32Fixture, crc32_slicing) EXPECT_EQ(crc, EXPECTED_CRC32); } +TEST_F(crc32Fixture, crc32_auto_misaligned) +{ + crc32_ctx* ctx = crc32_init(); + uint32_t crc; + + EXPECT_NE(ctx, nullptr); + + crc32_update(ctx, buffer_misaligned+1, 1048576); + crc32_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC32); +} + +TEST_F(crc32Fixture, crc32_slicing_misaligned) +{ + uint32_t crc = CRC32_ISO_SEED; + + crc32_slicing(&crc, buffer_misaligned+1, 1048576); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32); +} + TEST_F(crc32Fixture, crc32_auto_15bytes) { crc32_ctx* ctx = crc32_init(); @@ -186,6 +218,19 @@ TEST_F(crc32Fixture, crc32_clmul) EXPECT_EQ(crc, EXPECTED_CRC32); } +TEST_F(crc32Fixture, crc32_clmul_misaligned) +{ + if(!have_clmul()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = ~crc32_clmul(buffer_misaligned+1, 1048576, ~crc); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32); +} + TEST_F(crc32Fixture, crc32_clmul_15bytes) { if(!have_clmul()) return; @@ -254,6 +299,19 @@ TEST_F(crc32Fixture, crc32_arm_crc32) EXPECT_EQ(crc, EXPECTED_CRC32); } +TEST_F(crc32Fixture, crc32_arm_crc32_misaligned) +{ + if(!have_arm_crc32()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = armv8_crc32_little(crc, buffer_misaligned+1, 1048576); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32); +} + TEST_F(crc32Fixture, crc32_arm_crc32_15bytes) { if(!have_arm_crc32()) return; @@ -320,6 +378,19 @@ TEST_F(crc32Fixture, crc32_vmull) EXPECT_EQ(crc, EXPECTED_CRC32); } +TEST_F(crc32Fixture, crc32_vmull_misaligned) +{ + if(!have_neon()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = ~crc32_vmull(buffer_misaligned+1, 1048576, ~crc); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32); +} + TEST_F(crc32Fixture, crc32_vmull_15bytes) { if(!have_neon()) return; diff --git a/tests/crc64.cpp b/tests/crc64.cpp index 951415c..473704b 100644 --- a/tests/crc64.cpp +++ b/tests/crc64.cpp @@ -4,6 +4,7 @@ #include #include +#include #include "../library.h" #include "../crc64.h" @@ -16,6 +17,7 @@ #define EXPECTED_CRC64_2352BYTES 0x126435DB43477623 static const uint8_t* buffer; +static const uint8_t* buffer_misaligned; class crc64Fixture : public ::testing::Test { @@ -39,9 +41,15 @@ class crc64Fixture : public ::testing::Test buffer = (const uint8_t*)malloc(1048576); fread((void*)buffer, 1, 1048576, file); fclose(file); + + buffer_misaligned = (const uint8_t*)malloc(1048577); + memcpy((void*)(buffer_misaligned + 1), buffer, 1048576); } - void TearDown() { free((void*)buffer); } + void TearDown() { + free((void*)buffer); + free((void*)buffer_misaligned); + } ~crc64Fixture() { @@ -75,6 +83,30 @@ TEST_F(crc64Fixture, crc64_slicing) EXPECT_EQ(crc, EXPECTED_CRC64); } +TEST_F(crc64Fixture, crc64_auto_misaligned) +{ + crc64_ctx* ctx = crc64_init(); + uint64_t crc; + + EXPECT_NE(ctx, nullptr); + + crc64_update(ctx, buffer_misaligned+1, 1048576); + crc64_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC64); +} + +TEST_F(crc64Fixture, crc64_slicing_misaligned) +{ + uint64_t crc = CRC64_ECMA_SEED; + + crc64_slicing(&crc, buffer_misaligned+1, 1048576); + + crc ^= CRC64_ECMA_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC64); +} + TEST_F(crc64Fixture, crc64_auto_15bytes) { crc64_ctx* ctx = crc64_init(); @@ -186,6 +218,19 @@ TEST_F(crc64Fixture, crc64_clmul) EXPECT_EQ(crc, EXPECTED_CRC64); } +TEST_F(crc64Fixture, crc64_clmul_misaligned) +{ + if(!have_clmul()) return; + + uint64_t crc = CRC64_ECMA_SEED; + + crc = ~crc64_clmul(~crc, buffer_misaligned+1, 1048576); + + crc ^= CRC64_ECMA_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC64); +} + TEST_F(crc64Fixture, crc64_clmul_15bytes) { if(!have_clmul()) return; diff --git a/tests/fletcher16.cpp b/tests/fletcher16.cpp index 2f14f52..1331788 100644 --- a/tests/fletcher16.cpp +++ b/tests/fletcher16.cpp @@ -4,6 +4,7 @@ #include #include +#include #include "../library.h" #include "../fletcher16.h" @@ -16,6 +17,7 @@ #define EXPECTED_FLETCHER16_2352BYTES 0x0AC5 static const uint8_t* buffer; +static const uint8_t* buffer_misaligned; class fletcher16Fixture : public ::testing::Test { @@ -39,9 +41,15 @@ class fletcher16Fixture : public ::testing::Test buffer = (const uint8_t*)malloc(1048576); fread((void*)buffer, 1, 1048576, file); fclose(file); + + buffer_misaligned = (const uint8_t*)malloc(1048577); + memcpy((void*)(buffer_misaligned + 1), buffer, 1048576); } - void TearDown() { free((void*)buffer); } + void TearDown() { + free((void*)buffer); + free((void*)buffer_misaligned); + } ~fletcher16Fixture() { @@ -64,6 +72,19 @@ TEST_F(fletcher16Fixture, fletcher16_auto) EXPECT_EQ(fletcher, EXPECTED_FLETCHER16); } +TEST_F(fletcher16Fixture, fletcher16_auto_misaligned) +{ + fletcher16_ctx* ctx = fletcher16_init(); + uint16_t fletcher; + + EXPECT_NE(ctx, nullptr); + + fletcher16_update(ctx, buffer_misaligned+1, 1048576); + fletcher16_final(ctx, &fletcher); + + EXPECT_EQ(fletcher, EXPECTED_FLETCHER16); +} + TEST_F(fletcher16Fixture, fletcher16_auto_15bytes) { fletcher16_ctx* ctx = fletcher16_init(); diff --git a/tests/fletcher32.cpp b/tests/fletcher32.cpp index 72470ab..8446d15 100644 --- a/tests/fletcher32.cpp +++ b/tests/fletcher32.cpp @@ -4,6 +4,7 @@ #include #include +#include #include "../library.h" #include "../fletcher32.h" @@ -16,6 +17,7 @@ #define EXPECTED_FLETCHER32_2352BYTES 0xCB3E7352 static const uint8_t* buffer; +static const uint8_t* buffer_misaligned; class fletcher32Fixture : public ::testing::Test { @@ -39,9 +41,15 @@ class fletcher32Fixture : public ::testing::Test buffer = (const uint8_t*)malloc(1048576); fread((void*)buffer, 1, 1048576, file); fclose(file); + + buffer_misaligned = (const uint8_t*)malloc(1048577); + memcpy((void*)(buffer_misaligned + 1), buffer, 1048576); } - void TearDown() { free((void*)buffer); } + void TearDown() { + free((void*)buffer); + free((void*)buffer_misaligned); + } ~fletcher32Fixture() { @@ -64,6 +72,19 @@ TEST_F(fletcher32Fixture, fletcher32_auto) EXPECT_EQ(fletcher, EXPECTED_FLETCHER32); } +TEST_F(fletcher32Fixture, fletcher32_auto_misaligned) +{ + fletcher32_ctx* ctx = fletcher32_init(); + uint32_t fletcher; + + EXPECT_NE(ctx, nullptr); + + fletcher32_update(ctx, buffer_misaligned+1, 1048576); + fletcher32_final(ctx, &fletcher); + + EXPECT_EQ(fletcher, EXPECTED_FLETCHER32); +} + TEST_F(fletcher32Fixture, fletcher32_auto_15bytes) { fletcher32_ctx* ctx = fletcher32_init(); diff --git a/tests/spamsum.cpp b/tests/spamsum.cpp index 103be57..d982230 100644 --- a/tests/spamsum.cpp +++ b/tests/spamsum.cpp @@ -4,6 +4,7 @@ #include #include +#include #include "../library.h" #include "../spamsum.h" @@ -16,6 +17,7 @@ #define EXPECTED_SPAMSUM_2352BYTES "48:pasCLoANDXmjCz1p2OpPm+Gek3xmZfJJ5DD4BacmmlodQMQa/58Z:csK1Nxz7XFGeJS/flHMQu2Z" static const uint8_t* buffer; +static const uint8_t* buffer_misaligned; class spamsumFixture : public ::testing::Test { @@ -39,9 +41,15 @@ class spamsumFixture : public ::testing::Test buffer = (const uint8_t*)malloc(1048576); fread((void*)buffer, 1, 1048576, file); fclose(file); + + buffer_misaligned = (const uint8_t*)malloc(1048577); + memcpy((void*)(buffer_misaligned + 1), buffer, 1048576); } - void TearDown() { free((void*)buffer); } + void TearDown() { + free((void*)buffer); + free((void*)buffer_misaligned); + } ~spamsumFixture() { @@ -67,6 +75,22 @@ TEST_F(spamsumFixture, spamsum_auto) free((void*)spamsum); } +TEST_F(spamsumFixture, spamsum_auto_misaligned) +{ + spamsum_ctx* ctx = spamsum_init(); + const char* spamsum = (const char*)malloc(FUZZY_MAX_RESULT); + + EXPECT_NE(ctx, nullptr); + EXPECT_NE(spamsum, nullptr); + + spamsum_update(ctx, buffer_misaligned+1, 1048576); + spamsum_final(ctx, (uint8_t*)spamsum); + + EXPECT_STREQ(spamsum, EXPECTED_SPAMSUM); + + free((void*)spamsum); +} + TEST_F(spamsumFixture, spamsum_auto_15bytes) { spamsum_ctx* ctx = spamsum_init();