Add more tests.

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

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);
+}

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);
+}

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

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

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);
+}

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);
+}

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);
 }