diff --git a/tests/adler32.cpp b/tests/adler32.cpp index 72342cd..01618f9 100644 --- a/tests/adler32.cpp +++ b/tests/adler32.cpp @@ -10,6 +10,10 @@ #include "gtest/gtest.h" #define EXPECTED_ADLER32 0x3728d186 +#define EXPECTED_ADLER32_15BYTES 0x34DC067D +#define EXPECTED_ADLER32_31BYTES 0xD8F10EAA +#define EXPECTED_ADLER32_63BYTES 0xD8AC2081 +#define EXPECTED_ADLER32_2352BYTES 0xECD1738B static const uint8_t* buffer; @@ -37,7 +41,9 @@ class adler32Fixture : public ::testing::Test fclose(file); } - void TearDown() { free((void*)buffer); } + void TearDown() { + free((void*)buffer); + } ~adler32Fixture() { @@ -76,6 +82,122 @@ TEST_F(adler32Fixture, adler32_slicing) EXPECT_EQ(adler32, EXPECTED_ADLER32); } +TEST_F(adler32Fixture, adler32_auto_15bytes) +{ + adler32_ctx* ctx = adler32_init(); + uint32_t adler32; + + EXPECT_NE(ctx, nullptr); + + adler32_update(ctx, buffer, 15); + adler32_final(ctx, &adler32); + + EXPECT_EQ(adler32, EXPECTED_ADLER32_15BYTES); +} + +TEST_F(adler32Fixture, adler32_slicing_15bytes) +{ + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_slicing(&sum1, &sum2, buffer, 15); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_15BYTES); +} + +TEST_F(adler32Fixture, adler32_auto_31bytes) +{ + adler32_ctx* ctx = adler32_init(); + uint32_t adler32; + + EXPECT_NE(ctx, nullptr); + + adler32_update(ctx, buffer, 31); + adler32_final(ctx, &adler32); + + EXPECT_EQ(adler32, EXPECTED_ADLER32_31BYTES); +} + +TEST_F(adler32Fixture, adler32_slicing_31bytes) +{ + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_slicing(&sum1, &sum2, buffer, 31); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_31BYTES); +} + +TEST_F(adler32Fixture, adler32_auto_63bytes) +{ + adler32_ctx* ctx = adler32_init(); + uint32_t adler32; + + EXPECT_NE(ctx, nullptr); + + adler32_update(ctx, buffer, 63); + adler32_final(ctx, &adler32); + + EXPECT_EQ(adler32, EXPECTED_ADLER32_63BYTES); +} + +TEST_F(adler32Fixture, adler32_slicing_63bytes) +{ + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_slicing(&sum1, &sum2, buffer, 63); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_63BYTES); +} + +TEST_F(adler32Fixture, adler32_auto_2352bytes) +{ + adler32_ctx* ctx = adler32_init(); + uint32_t adler32; + + EXPECT_NE(ctx, nullptr); + + adler32_update(ctx, buffer, 2352); + adler32_final(ctx, &adler32); + + EXPECT_EQ(adler32, EXPECTED_ADLER32_2352BYTES); +} + +TEST_F(adler32Fixture, adler32_slicing_2352bytes) +{ + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_slicing(&sum1, &sum2, buffer, 2352); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_2352BYTES); +} + #if defined(__aarch64__) || defined(_M_ARM64) || defined(__arm__) || defined(_M_ARM) TEST_F(adler32Fixture, adler32_neon) { @@ -94,6 +216,78 @@ TEST_F(adler32Fixture, adler32_neon) EXPECT_EQ(adler32, EXPECTED_ADLER32); } + +TEST_F(adler32Fixture, adler32_neon_15bytes) +{ + if(!have_neon()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_neon(&sum1, &sum2, buffer, 15); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_15BYTES); +} + +TEST_F(adler32Fixture, adler32_neon_31bytes) +{ + if(!have_neon()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_neon(&sum1, &sum2, buffer, 31); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_31BYTES); +} + +TEST_F(adler32Fixture, adler32_neon_63bytes) +{ + if(!have_neon()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_neon(&sum1, &sum2, buffer, 63); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_63BYTES); +} + +TEST_F(adler32Fixture, adler32_neon_2352bytes) +{ + if(!have_neon()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_neon(&sum1, &sum2, buffer, 2352); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_2352BYTES); +} #endif #if defined(__x86_64__) || defined(__amd64) || defined(_M_AMD64) || defined(_M_X64) || defined(__I386__) || \ @@ -134,4 +328,148 @@ TEST_F(adler32Fixture, adler32_ssse3) EXPECT_EQ(adler32, EXPECTED_ADLER32); } + +TEST_F(adler32Fixture, adler32_avx2_15bytes) +{ + if(!have_avx2()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_avx2(&sum1, &sum2, buffer, 15); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_15BYTES); +} + +TEST_F(adler32Fixture, adler32_ssse3_15bytes) +{ + if(!have_ssse3()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_ssse3(&sum1, &sum2, buffer, 15); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_15BYTES); +} + +TEST_F(adler32Fixture, adler32_avx2_31bytes) +{ + if(!have_avx2()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_avx2(&sum1, &sum2, buffer, 31); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_31BYTES); +} + +TEST_F(adler32Fixture, adler32_ssse3_31bytes) +{ + if(!have_ssse3()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_ssse3(&sum1, &sum2, buffer, 31); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_31BYTES); +} + +TEST_F(adler32Fixture, adler32_avx2_63bytes) +{ + if(!have_avx2()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_avx2(&sum1, &sum2, buffer, 63); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_63BYTES); +} + +TEST_F(adler32Fixture, adler32_ssse3_63bytes) +{ + if(!have_ssse3()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_ssse3(&sum1, &sum2, buffer, 63); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_63BYTES); +} + +TEST_F(adler32Fixture, adler32_avx2_2352bytes) +{ + if(!have_avx2()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_avx2(&sum1, &sum2, buffer, 2352); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_2352BYTES); +} + +TEST_F(adler32Fixture, adler32_ssse3_2352bytes) +{ + if(!have_ssse3()) return; + + uint16_t sum1; + uint16_t sum2; + uint32_t adler32; + + sum1 = 1; + sum2 = 0; + + adler32_ssse3(&sum1, &sum2, buffer, 2352); + + adler32 = (sum2 << 16) | sum1; + + EXPECT_EQ(adler32, EXPECTED_ADLER32_2352BYTES); +} #endif diff --git a/tests/crc16.cpp b/tests/crc16.cpp index 1275adf..e3408ff 100644 --- a/tests/crc16.cpp +++ b/tests/crc16.cpp @@ -10,6 +10,10 @@ #include "gtest/gtest.h" #define EXPECTED_CRC16 0x2d6d +#define EXPECTED_CRC16_15BYTES 0x72a6 +#define EXPECTED_CRC16_31BYTES 0xF49E +#define EXPECTED_CRC16_63BYTES 0xFBD9 +#define EXPECTED_CRC16_2352BYTES 0x23F4 static const uint8_t* buffer; @@ -59,3 +63,55 @@ TEST_F(crc16Fixture, crc16_auto) EXPECT_EQ(crc, EXPECTED_CRC16); } + +TEST_F(crc16Fixture, crc16_auto_15bytes) +{ + crc16_ctx* ctx = crc16_init(); + uint16_t crc; + + EXPECT_NE(ctx, nullptr); + + crc16_update(ctx, buffer, 15); + crc16_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC16_15BYTES); +} + +TEST_F(crc16Fixture, crc16_auto_31bytes) +{ + crc16_ctx* ctx = crc16_init(); + uint16_t crc; + + EXPECT_NE(ctx, nullptr); + + crc16_update(ctx, buffer, 31); + crc16_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC16_31BYTES); +} + +TEST_F(crc16Fixture, crc16_auto_63bytes) +{ + crc16_ctx* ctx = crc16_init(); + uint16_t crc; + + EXPECT_NE(ctx, nullptr); + + crc16_update(ctx, buffer, 63); + crc16_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC16_63BYTES); +} + +TEST_F(crc16Fixture, crc16_auto_2352bytes) +{ + crc16_ctx* ctx = crc16_init(); + uint16_t crc; + + EXPECT_NE(ctx, nullptr); + + crc16_update(ctx, buffer, 2352); + crc16_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC16_2352BYTES); +} diff --git a/tests/crc16_ccitt.cpp b/tests/crc16_ccitt.cpp index dd0d032..842f572 100644 --- a/tests/crc16_ccitt.cpp +++ b/tests/crc16_ccitt.cpp @@ -10,6 +10,10 @@ #include "gtest/gtest.h" #define EXPECTED_CRC16_CCITT 0x3640 +#define EXPECTED_CRC16_CCITT_15BYTES 0x166e +#define EXPECTED_CRC16_CCITT_31BYTES 0xd016 +#define EXPECTED_CRC16_CCITT_63BYTES 0x73c4 +#define EXPECTED_CRC16_CCITT_2352BYTES 0x1946 static const uint8_t* buffer; @@ -59,3 +63,55 @@ TEST_F(crc16_ccittFixture, crc16_ccitt_auto) EXPECT_EQ(crc, EXPECTED_CRC16_CCITT); } + +TEST_F(crc16_ccittFixture, crc16_ccitt_auto_15bytes) +{ + crc16_ccitt_ctx* ctx = crc16_ccitt_init(); + uint16_t crc; + + EXPECT_NE(ctx, nullptr); + + crc16_ccitt_update(ctx, buffer, 15); + crc16_ccitt_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC16_CCITT_15BYTES); +} + +TEST_F(crc16_ccittFixture, crc16_ccitt_auto_31bytes) +{ + crc16_ccitt_ctx* ctx = crc16_ccitt_init(); + uint16_t crc; + + EXPECT_NE(ctx, nullptr); + + crc16_ccitt_update(ctx, buffer, 31); + crc16_ccitt_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC16_CCITT_31BYTES); +} + +TEST_F(crc16_ccittFixture, crc16_ccitt_auto_63bytes) +{ + crc16_ccitt_ctx* ctx = crc16_ccitt_init(); + uint16_t crc; + + EXPECT_NE(ctx, nullptr); + + crc16_ccitt_update(ctx, buffer, 63); + crc16_ccitt_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC16_CCITT_63BYTES); +} + +TEST_F(crc16_ccittFixture, crc16_ccitt_auto_2352bytes) +{ + crc16_ccitt_ctx* ctx = crc16_ccitt_init(); + uint16_t crc; + + EXPECT_NE(ctx, nullptr); + + crc16_ccitt_update(ctx, buffer, 2352); + crc16_ccitt_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC16_CCITT_2352BYTES); +} diff --git a/tests/crc32.cpp b/tests/crc32.cpp index 13049e1..98cc41a 100644 --- a/tests/crc32.cpp +++ b/tests/crc32.cpp @@ -10,6 +10,10 @@ #include "gtest/gtest.h" #define EXPECTED_CRC32 0x2B6E6854 +#define EXPECTED_CRC32_15BYTES 0xad6da727 +#define EXPECTED_CRC32_31BYTES 0xa2ad2faa +#define EXPECTED_CRC32_63BYTES 0xbff6a341 +#define EXPECTED_CRC32_2352BYTES 0x08ba93ea static const uint8_t* buffer; @@ -71,6 +75,102 @@ TEST_F(crc32Fixture, crc32_slicing) EXPECT_EQ(crc, EXPECTED_CRC32); } +TEST_F(crc32Fixture, crc32_auto_15bytes) +{ + crc32_ctx* ctx = crc32_init(); + uint32_t crc; + + EXPECT_NE(ctx, nullptr); + + crc32_update(ctx, buffer, 15); + crc32_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC32_15BYTES); +} + +TEST_F(crc32Fixture, crc32_slicing_15bytes) +{ + uint32_t crc = CRC32_ISO_SEED; + + crc32_slicing(&crc, buffer, 15); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_15BYTES); +} + +TEST_F(crc32Fixture, crc32_auto_31bytes) +{ + crc32_ctx* ctx = crc32_init(); + uint32_t crc; + + EXPECT_NE(ctx, nullptr); + + crc32_update(ctx, buffer, 31); + crc32_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC32_31BYTES); +} + +TEST_F(crc32Fixture, crc32_slicing_31bytes) +{ + uint32_t crc = CRC32_ISO_SEED; + + crc32_slicing(&crc, buffer, 31); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_31BYTES); +} + +TEST_F(crc32Fixture, crc32_auto_63bytes) +{ + crc32_ctx* ctx = crc32_init(); + uint32_t crc; + + EXPECT_NE(ctx, nullptr); + + crc32_update(ctx, buffer, 63); + crc32_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC32_63BYTES); +} + +TEST_F(crc32Fixture, crc32_slicing_63bytes) +{ + uint32_t crc = CRC32_ISO_SEED; + + crc32_slicing(&crc, buffer, 63); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_63BYTES); +} + +TEST_F(crc32Fixture, crc32_auto_2352bytes) +{ + crc32_ctx* ctx = crc32_init(); + uint32_t crc; + + EXPECT_NE(ctx, nullptr); + + crc32_update(ctx, buffer, 2352); + crc32_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC32_2352BYTES); +} + +TEST_F(crc32Fixture, crc32_slicing_2352bytes) +{ + uint32_t crc = CRC32_ISO_SEED; + + crc32_slicing(&crc, buffer, 2352); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_2352BYTES); +} + #if defined(__x86_64__) || defined(__amd64) || defined(_M_AMD64) || defined(_M_X64) || defined(__I386__) || \ defined(__i386__) || defined(__THW_INTEL) || defined(_M_IX86) TEST_F(crc32Fixture, crc32_clmul) @@ -85,6 +185,58 @@ TEST_F(crc32Fixture, crc32_clmul) EXPECT_EQ(crc, EXPECTED_CRC32); } + +TEST_F(crc32Fixture, crc32_clmul_15bytes) +{ + if(!have_clmul()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = ~crc32_clmul(buffer, 15, ~crc); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_15BYTES); +} + +TEST_F(crc32Fixture, crc32_clmul_31bytes) +{ + if(!have_clmul()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = ~crc32_clmul(buffer, 31, ~crc); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_31BYTES); +} + +TEST_F(crc32Fixture, crc32_clmul_63bytes) +{ + if(!have_clmul()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = ~crc32_clmul(buffer, 63, ~crc); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_63BYTES); +} + +TEST_F(crc32Fixture, crc32_clmul_2352bytes) +{ + if(!have_clmul()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = ~crc32_clmul(buffer, 2352, ~crc); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_2352BYTES); +} #endif #if defined(__aarch64__) || defined(_M_ARM64) || defined(__arm__) || defined(_M_ARM) @@ -101,6 +253,58 @@ TEST_F(crc32Fixture, crc32_arm_crc32) EXPECT_EQ(crc, EXPECTED_CRC32); } + +TEST_F(crc32Fixture, crc32_arm_crc32_15bytes) +{ + if(!have_arm_crc32()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = armv8_crc32_little(crc, buffer, 15); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_15BYTES); +} + +TEST_F(crc32Fixture, crc32_arm_crc32_31bytes) +{ + if(!have_arm_crc32()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = armv8_crc32_little(crc, buffer, 31); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_31BYTES); +} + +TEST_F(crc32Fixture, crc32_arm_crc32_63bytes) +{ + if(!have_arm_crc32()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = armv8_crc32_little(crc, buffer, 63); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_63BYTES); +} + +TEST_F(crc32Fixture, crc32_arm_crc32_2352bytes) +{ + if(!have_arm_crc32()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = armv8_crc32_little(crc, buffer, 2352); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_2352BYTES); +} #endif TEST_F(crc32Fixture, crc32_vmull) @@ -115,4 +319,56 @@ TEST_F(crc32Fixture, crc32_vmull) EXPECT_EQ(crc, EXPECTED_CRC32); } + +TEST_F(crc32Fixture, crc32_vmull_15bytes) +{ + if(!have_neon()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = ~crc32_vmull(buffer, 15, ~crc); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_15BYTES); +} + +TEST_F(crc32Fixture, crc32_vmull_31bytes) +{ + if(!have_neon()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = ~crc32_vmull(buffer, 31, ~crc); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_31BYTES); +} + +TEST_F(crc32Fixture, crc32_vmull_63bytes) +{ + if(!have_neon()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = ~crc32_vmull(buffer, 63, ~crc); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_63BYTES); +} + +TEST_F(crc32Fixture, crc32_vmull_2352bytes) +{ + if(!have_neon()) return; + + uint32_t crc = CRC32_ISO_SEED; + + crc = ~crc32_vmull(buffer, 2352, ~crc); + + crc ^= CRC32_ISO_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC32_2352BYTES); +} #endif diff --git a/tests/crc64.cpp b/tests/crc64.cpp index 9c22c16..951415c 100644 --- a/tests/crc64.cpp +++ b/tests/crc64.cpp @@ -10,6 +10,10 @@ #include "gtest/gtest.h" #define EXPECTED_CRC64 0xbf09992cc5ede38e +#define EXPECTED_CRC64_15BYTES 0x797F3766FD93975B +#define EXPECTED_CRC64_31BYTES 0xCD9201905A7937FD +#define EXPECTED_CRC64_63BYTES 0x29F331FC90702BF4 +#define EXPECTED_CRC64_2352BYTES 0x126435DB43477623 static const uint8_t* buffer; @@ -71,6 +75,102 @@ TEST_F(crc64Fixture, crc64_slicing) EXPECT_EQ(crc, EXPECTED_CRC64); } +TEST_F(crc64Fixture, crc64_auto_15bytes) +{ + crc64_ctx* ctx = crc64_init(); + uint64_t crc; + + EXPECT_NE(ctx, nullptr); + + crc64_update(ctx, buffer, 15); + crc64_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC64_15BYTES); +} + +TEST_F(crc64Fixture, crc64_slicing_15bytes) +{ + uint64_t crc = CRC64_ECMA_SEED; + + crc64_slicing(&crc, buffer, 15); + + crc ^= CRC64_ECMA_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC64_15BYTES); +} + +TEST_F(crc64Fixture, crc64_auto_31bytes) +{ + crc64_ctx* ctx = crc64_init(); + uint64_t crc; + + EXPECT_NE(ctx, nullptr); + + crc64_update(ctx, buffer, 31); + crc64_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC64_31BYTES); +} + +TEST_F(crc64Fixture, crc64_slicing_31bytes) +{ + uint64_t crc = CRC64_ECMA_SEED; + + crc64_slicing(&crc, buffer, 31); + + crc ^= CRC64_ECMA_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC64_31BYTES); +} + +TEST_F(crc64Fixture, crc64_auto_63bytes) +{ + crc64_ctx* ctx = crc64_init(); + uint64_t crc; + + EXPECT_NE(ctx, nullptr); + + crc64_update(ctx, buffer, 63); + crc64_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC64_63BYTES); +} + +TEST_F(crc64Fixture, crc64_slicing_63bytes) +{ + uint64_t crc = CRC64_ECMA_SEED; + + crc64_slicing(&crc, buffer, 63); + + crc ^= CRC64_ECMA_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC64_63BYTES); +} + +TEST_F(crc64Fixture, crc64_auto_2352bytes) +{ + crc64_ctx* ctx = crc64_init(); + uint64_t crc; + + EXPECT_NE(ctx, nullptr); + + crc64_update(ctx, buffer, 2352); + crc64_final(ctx, &crc); + + EXPECT_EQ(crc, EXPECTED_CRC64_2352BYTES); +} + +TEST_F(crc64Fixture, crc64_slicing_2352bytes) +{ + uint64_t crc = CRC64_ECMA_SEED; + + crc64_slicing(&crc, buffer, 2352); + + crc ^= CRC64_ECMA_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC64_2352BYTES); +} + #if defined(__x86_64__) || defined(__amd64) || defined(_M_AMD64) || defined(_M_X64) || defined(__I386__) || \ defined(__i386__) || defined(__THW_INTEL) || defined(_M_IX86) TEST_F(crc64Fixture, crc64_clmul) @@ -85,4 +185,56 @@ TEST_F(crc64Fixture, crc64_clmul) EXPECT_EQ(crc, EXPECTED_CRC64); } + +TEST_F(crc64Fixture, crc64_clmul_15bytes) +{ + if(!have_clmul()) return; + + uint64_t crc = CRC64_ECMA_SEED; + + crc = ~crc64_clmul(~crc, buffer, 15); + + crc ^= CRC64_ECMA_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC64_15BYTES); +} + +TEST_F(crc64Fixture, crc64_clmul_31bytes) +{ + if(!have_clmul()) return; + + uint64_t crc = CRC64_ECMA_SEED; + + crc = ~crc64_clmul(~crc, buffer, 31); + + crc ^= CRC64_ECMA_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC64_31BYTES); +} + +TEST_F(crc64Fixture, crc64_clmul_63bytes) +{ + if(!have_clmul()) return; + + uint64_t crc = CRC64_ECMA_SEED; + + crc = ~crc64_clmul(~crc, buffer, 63); + + crc ^= CRC64_ECMA_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC64_63BYTES); +} + +TEST_F(crc64Fixture, crc64_clmul_2352bytes) +{ + if(!have_clmul()) return; + + uint64_t crc = CRC64_ECMA_SEED; + + crc = ~crc64_clmul(~crc, buffer, 2352); + + crc ^= CRC64_ECMA_SEED; + + EXPECT_EQ(crc, EXPECTED_CRC64_2352BYTES); +} #endif diff --git a/tests/fletcher16.cpp b/tests/fletcher16.cpp index 42ba8e4..2f14f52 100644 --- a/tests/fletcher16.cpp +++ b/tests/fletcher16.cpp @@ -10,6 +10,10 @@ #include "gtest/gtest.h" #define EXPECTED_FLETCHER16 0x3357 +#define EXPECTED_FLETCHER16_15BYTES 0x0282 +#define EXPECTED_FLETCHER16_31BYTES 0xABB7 +#define EXPECTED_FLETCHER16_63BYTES 0x1CA0 +#define EXPECTED_FLETCHER16_2352BYTES 0x0AC5 static const uint8_t* buffer; @@ -59,3 +63,55 @@ TEST_F(fletcher16Fixture, fletcher16_auto) EXPECT_EQ(fletcher, EXPECTED_FLETCHER16); } + +TEST_F(fletcher16Fixture, fletcher16_auto_15bytes) +{ + fletcher16_ctx* ctx = fletcher16_init(); + uint16_t fletcher; + + EXPECT_NE(ctx, nullptr); + + fletcher16_update(ctx, buffer, 15); + fletcher16_final(ctx, &fletcher); + + EXPECT_EQ(fletcher, EXPECTED_FLETCHER16_15BYTES); +} + +TEST_F(fletcher16Fixture, fletcher16_auto_31bytes) +{ + fletcher16_ctx* ctx = fletcher16_init(); + uint16_t fletcher; + + EXPECT_NE(ctx, nullptr); + + fletcher16_update(ctx, buffer, 31); + fletcher16_final(ctx, &fletcher); + + EXPECT_EQ(fletcher, EXPECTED_FLETCHER16_31BYTES); +} + +TEST_F(fletcher16Fixture, fletcher16_auto_63bytes) +{ + fletcher16_ctx* ctx = fletcher16_init(); + uint16_t fletcher; + + EXPECT_NE(ctx, nullptr); + + fletcher16_update(ctx, buffer, 63); + fletcher16_final(ctx, &fletcher); + + EXPECT_EQ(fletcher, EXPECTED_FLETCHER16_63BYTES); +} + +TEST_F(fletcher16Fixture, fletcher16_auto_2352bytes) +{ + fletcher16_ctx* ctx = fletcher16_init(); + uint16_t fletcher; + + EXPECT_NE(ctx, nullptr); + + fletcher16_update(ctx, buffer, 2352); + fletcher16_final(ctx, &fletcher); + + EXPECT_EQ(fletcher, EXPECTED_FLETCHER16_2352BYTES); +} diff --git a/tests/fletcher32.cpp b/tests/fletcher32.cpp index e2daa18..72470ab 100644 --- a/tests/fletcher32.cpp +++ b/tests/fletcher32.cpp @@ -10,6 +10,10 @@ #include "gtest/gtest.h" #define EXPECTED_FLETCHER32 0x211261f5 +#define EXPECTED_FLETCHER32_15BYTES 0x34CD067C +#define EXPECTED_FLETCHER32_31BYTES 0xD8D20EA9 +#define EXPECTED_FLETCHER32_63BYTES 0xD8432080 +#define EXPECTED_FLETCHER32_2352BYTES 0xCB3E7352 static const uint8_t* buffer; @@ -59,3 +63,55 @@ TEST_F(fletcher32Fixture, fletcher32_auto) EXPECT_EQ(fletcher, EXPECTED_FLETCHER32); } + +TEST_F(fletcher32Fixture, fletcher32_auto_15bytes) +{ + fletcher32_ctx* ctx = fletcher32_init(); + uint32_t fletcher; + + EXPECT_NE(ctx, nullptr); + + fletcher32_update(ctx, buffer, 15); + fletcher32_final(ctx, &fletcher); + + EXPECT_EQ(fletcher, EXPECTED_FLETCHER32_15BYTES); +} + +TEST_F(fletcher32Fixture, fletcher32_auto_31bytes) +{ + fletcher32_ctx* ctx = fletcher32_init(); + uint32_t fletcher; + + EXPECT_NE(ctx, nullptr); + + fletcher32_update(ctx, buffer, 31); + fletcher32_final(ctx, &fletcher); + + EXPECT_EQ(fletcher, EXPECTED_FLETCHER32_31BYTES); +} + +TEST_F(fletcher32Fixture, fletcher32_auto_63bytes) +{ + fletcher32_ctx* ctx = fletcher32_init(); + uint32_t fletcher; + + EXPECT_NE(ctx, nullptr); + + fletcher32_update(ctx, buffer, 63); + fletcher32_final(ctx, &fletcher); + + EXPECT_EQ(fletcher, EXPECTED_FLETCHER32_63BYTES); +} + +TEST_F(fletcher32Fixture, fletcher32_auto_2352bytes) +{ + fletcher32_ctx* ctx = fletcher32_init(); + uint32_t fletcher; + + EXPECT_NE(ctx, nullptr); + + fletcher32_update(ctx, buffer, 2352); + fletcher32_final(ctx, &fletcher); + + EXPECT_EQ(fletcher, EXPECTED_FLETCHER32_2352BYTES); +} diff --git a/tests/spamsum.cpp b/tests/spamsum.cpp index 32774db..103be57 100644 --- a/tests/spamsum.cpp +++ b/tests/spamsum.cpp @@ -10,6 +10,10 @@ #include "gtest/gtest.h" #define EXPECTED_SPAMSUM "24576:3dvzuAsHTQ16pc7O1Q/gS9qze+Swwn9s6IX:8/TQQpaVqze+JN6IX" +#define EXPECTED_SPAMSUM_15BYTES "3:Ac4E9t:Ac4E9t" +#define EXPECTED_SPAMSUM_31BYTES "3:Ac4E9E5+S09qn:Ac4E9EgSsq" +#define EXPECTED_SPAMSUM_63BYTES "3:Ac4E9E5+S09q2kABV9:Ac4E9EgSs7kW9" +#define EXPECTED_SPAMSUM_2352BYTES "48:pasCLoANDXmjCz1p2OpPm+Gek3xmZfJJ5DD4BacmmlodQMQa/58Z:csK1Nxz7XFGeJS/flHMQu2Z" static const uint8_t* buffer; @@ -59,4 +63,70 @@ TEST_F(spamsumFixture, spamsum_auto) 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(); + const char* spamsum = (const char*)malloc(FUZZY_MAX_RESULT); + + EXPECT_NE(ctx, nullptr); + EXPECT_NE(spamsum, nullptr); + + spamsum_update(ctx, buffer, 15); + spamsum_final(ctx, (uint8_t*)spamsum); + + EXPECT_STREQ(spamsum, EXPECTED_SPAMSUM_15BYTES); + + free((void*)spamsum); +} + +TEST_F(spamsumFixture, spamsum_auto_31bytes) +{ + 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, 31); + spamsum_final(ctx, (uint8_t*)spamsum); + + EXPECT_STREQ(spamsum, EXPECTED_SPAMSUM_31BYTES); + + free((void*)spamsum); +} + +TEST_F(spamsumFixture, spamsum_auto_63bytes) +{ + 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, 63); + spamsum_final(ctx, (uint8_t*)spamsum); + + EXPECT_STREQ(spamsum, EXPECTED_SPAMSUM_63BYTES); + + free((void*)spamsum); +} + +TEST_F(spamsumFixture, spamsum_auto_2352bytes) +{ + 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, 2352); + spamsum_final(ctx, (uint8_t*)spamsum); + + EXPECT_STREQ(spamsum, EXPECTED_SPAMSUM_2352BYTES); + + free((void*)spamsum); }