fix roaring64 iterator state after reading past end (#731)

Set saturated_forward flag when iterator reaches end in
`roaring64_iterator_read` to ensure iterator can move backwards. Add
test coverage to validate.

Author: Dr-Emann

microbenchmarks/synthetic_bench.cpp

@@ -1,7 +1,7 @@
+#include <array>
 #include <benchmark/benchmark.h>
 #include <random>
 #include <set>
-#include <array>
 
 #include "performancecounters/event_counter.h"
 #include "roaring/roaring64.h"

src/roaring.c

@@ -1596,7 +1596,7 @@ roaring_bitmap_t *roaring_bitmap_deserialize_safe(const void *buf,
         for (uint32_t i = 0; i < card; i++) {
             // elems may not be aligned, read with memcpy
             uint32_t elem;
-            memcpy((char*)&elem, (char*)(elems + i), sizeof(elem));
+            memcpy((char *)&elem, (char *)(elems + i), sizeof(elem));
             roaring_bitmap_add_bulk(bitmap, &context, elem);
         }
         return bitmap;
@@ -3016,7 +3016,7 @@ void roaring_bitmap_frozen_serialize(const roaring_bitmap_t *rb, char *buf) {
     uint16_t *key_zone = (uint16_t *)arena_alloc(&buf, 2 * ra->size);
     uint16_t *count_zone = (uint16_t *)arena_alloc(&buf, 2 * ra->size);
     uint8_t *typecode_zone = (uint8_t *)arena_alloc(&buf, ra->size);
-    char *header_zone = (char*)arena_alloc(&buf, 4);
+    char *header_zone = (char *)arena_alloc(&buf, 4);
 
     for (int32_t i = 0; i < ra->size; i++) {
         uint16_t count;

src/roaring64.c

@@ -2707,6 +2707,8 @@ uint64_t roaring64_iterator_read(roaring64_iterator_t *it, uint64_t *buf,
         it->has_value = art_iterator_next(&it->art_it);
         if (it->has_value) {
             roaring64_iterator_init_at_leaf_first(it);
+        } else {
+            it->saturated_forward = true;
         }
     }
     return consumed;

tests/roaring64_unit.cpp

@@ -1974,6 +1974,32 @@ DEFINE_TEST(test_stats) {
     roaring64_bitmap_free(r1);
 }
 
+DEFINE_TEST(test_iterator_read_past_end_can_go_previous) {
+    roaring64_bitmap_t* bitmap = roaring64_bitmap_create();
+    assert_non_null(bitmap);
+
+    roaring64_bitmap_add(bitmap, 10);
+    assert_r64_valid(bitmap);
+
+    roaring64_iterator_t* iter = roaring64_iterator_create(bitmap);
+    assert_non_null(iter);
+
+    uint64_t buffer[100];
+    uint64_t actual_read1 = roaring64_iterator_read(
+        iter, buffer, sizeof(buffer) / sizeof(buffer[0]));
+    assert_int_equal(actual_read1, 1);  // Only one value should be present
+
+    // Should now be one past the end, but should be able to move backwards
+    assert_false(roaring64_iterator_has_value(iter));
+    bool prev_result = roaring64_iterator_previous(iter);
+    assert_true(prev_result);
+    assert_true(roaring64_iterator_has_value(iter));
+    assert_int_equal(roaring64_iterator_value(iter), 10);
+
+    roaring64_iterator_free(iter);
+    roaring64_bitmap_free(bitmap);
+}
+
 }  // namespace
 
 int main() {
@@ -2038,6 +2064,7 @@ int main() {
         cmocka_unit_test(test_iterator_move_equalorlarger),
         cmocka_unit_test(test_iterator_read),
         cmocka_unit_test(test_stats),
+        cmocka_unit_test(test_iterator_read_past_end_can_go_previous),
     };
     return cmocka_run_group_tests(tests, NULL, NULL);
 }