Update

Author: lemire

include/binaryfusefilter.h

@@ -762,7 +762,7 @@ static inline void binary_fuse16_serialize(const binary_fuse16_t *filter, char *
   buffer += sizeof(filter->SegmentCountLength);
   memcpy(buffer, &filter->ArrayLength, sizeof(filter->ArrayLength));
   buffer += sizeof(filter->ArrayLength);
-  memcpy(buffer, filter->Fingerprints, sizeof(filter->ArrayLength) * sizeof(uint16_t));
+  memcpy(buffer, filter->Fingerprints, filter->ArrayLength * sizeof(uint16_t));
 }
 
 // serialize a filter to a buffer, the buffer should have a capacity of at least
@@ -779,7 +779,7 @@ static inline void binary_fuse8_serialize(const binary_fuse8_t *filter, char *bu
   buffer += sizeof(filter->SegmentCountLength);
   memcpy(buffer, &filter->ArrayLength, sizeof(filter->ArrayLength));
   buffer += sizeof(filter->ArrayLength);
-  memcpy(buffer, filter->Fingerprints, sizeof(filter->ArrayLength) * sizeof(uint8_t));
+  memcpy(buffer, filter->Fingerprints, filter->ArrayLength * sizeof(uint8_t));
 }
 
 // deserialize a filter from a buffer, returns true on success, false on failure.
@@ -803,7 +803,7 @@ static inline bool binary_fuse16_deserialize(binary_fuse16_t * filter, const cha
   if(filter->Fingerprints == NULL) {
     return false;
   }
-  memcpy(filter->Fingerprints, buffer, sizeof(filter->ArrayLength) * sizeof(uint16_t));
+  memcpy(filter->Fingerprints, buffer, filter->ArrayLength * sizeof(uint16_t));
   return true;
 }
 
@@ -829,7 +829,7 @@ static inline bool binary_fuse8_deserialize(binary_fuse8_t * filter, const char
   if(filter->Fingerprints == NULL) {
     return false;
   }
-  memcpy(filter->Fingerprints, buffer, sizeof(filter->ArrayLength) * sizeof(uint8_t));
+  memcpy(filter->Fingerprints, buffer, filter->ArrayLength * sizeof(uint8_t));
   return true;
 }
 

include/xorfilter.h

@@ -1297,7 +1297,7 @@ static inline void xor16_serialize(const xor16_t *filter, char *buffer) {
   buffer += sizeof(filter->seed);
   memcpy(buffer, &filter->blockLength, sizeof(filter->blockLength));
   buffer += sizeof(filter->blockLength);
-  memcpy(buffer, filter->fingerprints, sizeof(filter->blockLength) * 3 * sizeof(uint16_t));
+  memcpy(buffer, filter->fingerprints, filter->blockLength * 3 * sizeof(uint16_t));
 }
 
 // serialize a filter to a buffer, the buffer should have a capacity of at least
@@ -1308,7 +1308,7 @@ static inline void xor8_serialize(const xor8_t *filter, char *buffer) {
   buffer += sizeof(filter->seed);
   memcpy(buffer, &filter->blockLength, sizeof(filter->blockLength));
   buffer += sizeof(filter->blockLength);
-  memcpy(buffer, filter->fingerprints, sizeof(filter->blockLength) * 3 * sizeof(uint8_t));
+  memcpy(buffer, filter->fingerprints, filter->blockLength * 3 * sizeof(uint8_t));
 }
 
 // deserialize a filter from a buffer, returns true on success, false on failure.
@@ -1325,7 +1325,7 @@ static inline bool xor16_deserialize(xor16_t * filter, const char *buffer) {
   if(filter->fingerprints == NULL) {
     return false;
   }
-  memcpy(filter->fingerprints, buffer, sizeof(filter->blockLength) * 3 * sizeof(uint16_t));
+  memcpy(filter->fingerprints, buffer, filter->blockLength * 3 * sizeof(uint16_t));
   return true;
 }
 
@@ -1344,7 +1344,7 @@ static inline bool xor8_deserialize(xor8_t * filter, const char *buffer) {
   if(filter->fingerprints == NULL) {
     return false;
   }
-  memcpy(filter->fingerprints, buffer, sizeof(filter->blockLength) * 3 * sizeof(uint8_t));
+  memcpy(filter->fingerprints, buffer, filter->blockLength * 3 * sizeof(uint8_t));
   return true;
 }
 

tests/unit.c

@@ -69,6 +69,12 @@ bool testxor8(size_t size) {
   xor8_free(&filter);
   xor8_deserialize(&filter, buffer);
   free(buffer);
+  for (size_t i = 0; i < size; i++) {
+    if (!xor8_contain(big_set[i], &filter)) {
+      printf("bug!\n");
+      return false;
+    }
+  }
 
   size_t random_matches = 0;
   size_t trials = 10000000;
@@ -115,6 +121,12 @@ bool testxor16(size_t size) {
   xor16_free(&filter);
   xor16_deserialize(&filter, buffer);
   free(buffer);
+  for (size_t i = 0; i < size; i++) {
+    if (!xor16_contain(big_set[i], &filter)) {
+      printf("bug!\n");
+      return false;
+    }
+  }
 
   size_t random_matches = 0;
   size_t trials = 10000000;
@@ -162,6 +174,12 @@ bool testbufferedxor16(size_t size) {
   xor16_free(&filter);
   xor16_deserialize(&filter, buffer);
   free(buffer);
+  for (size_t i = 0; i < size; i++) {
+    if (!xor16_contain(big_set[i], &filter)) {
+      printf("bug!\n");
+      return false;
+    }
+  }
 
   size_t random_matches = 0;
   size_t trials = 10000000;
@@ -208,6 +226,12 @@ bool testbinaryfuse8(size_t size) {
   binary_fuse8_free(&filter);
   binary_fuse8_deserialize(&filter, buffer);
   free(buffer);
+  for (size_t i = 0; i < size; i++) {
+    if (!binary_fuse8_contain(big_set[i], &filter)) {
+      printf("bug!\n");
+      return false;
+    }
+  }
 
   size_t random_matches = 0;
   size_t trials = 10000000;
@@ -256,6 +280,12 @@ bool testbinaryfuse16(size_t size) {
   binary_fuse16_free(&filter);
   binary_fuse16_deserialize(&filter, buffer);
   free(buffer);
+  for (size_t i = 0; i < size; i++) {
+    if (!binary_fuse16_contain(big_set[i], &filter)) {
+      printf("bug!\n");
+      return false;
+    }
+  }
 
   size_t random_matches = 0;
   size_t trials = 10000000;