Run containers attempt 3

fuzz/fuzz_targets/arbitrary_ops/mod.rs

@@ -51,8 +51,19 @@ pub enum MutableBitmapOperation {
     RemoveRange(RangeInclusive<Num>),
     Clear,
     Extend(Vec<Num>),
+    SwapSerialization,
+    Optimize,
+    RemoveRunCompression,
     // Probably turn it into a bitmap
     MakeBitmap { key: u16 },
+    // Probably turn it into a Range
+    MakeRange { key: u16 },
+}
+
+#[derive(Arbitrary, Debug, Copy, Clone)]
+pub enum RangeOperations {
+    Optimized,
+    Removed,
 }
 
 #[derive(Arbitrary, Debug)]
@@ -67,11 +78,11 @@ pub enum ReadBitmapOperation {
     Maximum,
     Rank(Num),
     Select(Num),
-    Statistics,
+    Statistics(RangeOperations),
     Clone,
     Debug,
-    SerializedSize,
-    Serialize,
+    SerializedSize(RangeOperations),
+    Serialize(RangeOperations),
 }
 
 #[derive(Arbitrary, Debug)]
@@ -85,7 +96,7 @@ pub enum BitmapBinaryOperation {
 }
 
 impl ReadBitmapOperation {
-    pub fn apply(&self, x: &mut croaring::Bitmap, y: &roaring::RoaringBitmap) {
+    pub fn apply(&self, x: &mut croaring::Bitmap, y: &mut roaring::RoaringBitmap) {
         match *self {
             ReadBitmapOperation::ContainsRange(ref range) => {
                 let range = range.start().0..=range.end().0;
@@ -139,9 +150,19 @@ impl ReadBitmapOperation {
                 let actual = y.select(n);
                 assert_eq!(expected, actual);
             }
-            ReadBitmapOperation::Statistics => {
-                // roaring-rs doesn't support range containers (yet)
-                x.remove_run_compression();
+            ReadBitmapOperation::Statistics(ranges) => {
+                match ranges {
+                    RangeOperations::Optimized => {
+                        x.remove_run_compression();
+                        y.remove_run_compression();
+                        assert_eq!(x.run_optimize(), y.optimize());
+                    }
+                    RangeOperations::Removed => {
+                        x.run_optimize();
+                        y.optimize();
+                        assert_eq!(x.remove_run_compression(), y.remove_run_compression());
+                    }
+                }
                 let expected = x.statistics();
                 let actual = y.statistics();
                 // Convert to the same statistics struct
@@ -174,16 +195,36 @@ impl ReadBitmapOperation {
                 use std::io::Write;
                 write!(std::io::sink(), "{:?}", y).unwrap();
             }
-            ReadBitmapOperation::SerializedSize => {
-                // roaring-rs doesn't support range containers (yet)
-                x.remove_run_compression();
+            ReadBitmapOperation::SerializedSize(ranges) => {
+                match ranges {
+                    RangeOperations::Optimized => {
+                        x.remove_run_compression();
+                        y.remove_run_compression();
+                        assert_eq!(x.run_optimize(), y.optimize());
+                    }
+                    RangeOperations::Removed => {
+                        x.run_optimize();
+                        y.optimize();
+                        assert_eq!(x.remove_run_compression(), y.remove_run_compression());
+                    }
+                }
                 let expected = x.get_serialized_size_in_bytes::<croaring::Portable>();
                 let actual = y.serialized_size();
                 assert_eq!(expected, actual);
             }
-            ReadBitmapOperation::Serialize => {
-                // roaring-rs doesn't support range containers (yet)
-                x.remove_run_compression();
+            ReadBitmapOperation::Serialize(ranges) => {
+                match ranges {
+                    RangeOperations::Optimized => {
+                        x.remove_run_compression();
+                        y.remove_run_compression();
+                        assert_eq!(x.run_optimize(), y.optimize());
+                    }
+                    RangeOperations::Removed => {
+                        x.run_optimize();
+                        y.optimize();
+                        assert_eq!(x.remove_run_compression(), y.remove_run_compression());
+                    }
+                }
                 let expected = x.serialize::<croaring::Portable>();
                 let mut actual = Vec::new();
                 y.serialize_into(&mut actual).unwrap();
@@ -230,12 +271,35 @@ impl MutableBitmapOperation {
                 x.clear();
                 y.clear();
             }
+            MutableBitmapOperation::Optimize => {
+                x.remove_run_compression();
+                y.remove_run_compression();
+                assert_eq!(x.run_optimize(), y.optimize());
+            }
+            MutableBitmapOperation::RemoveRunCompression => {
+                x.run_optimize();
+                y.optimize();
+                assert_eq!(x.remove_run_compression(), y.remove_run_compression());
+            }
             MutableBitmapOperation::Extend(ref items) => {
                 // Safety - Num is repr(transparent) over u32
                 let items: &[u32] = unsafe { mem::transmute(&items[..]) };
                 x.add_many(items);
                 y.extend(items);
             }
+            MutableBitmapOperation::SwapSerialization => {
+                let x_serialized = x.serialize::<croaring::Portable>();
+                let mut y_serialized = Vec::new();
+                y.serialize_into(&mut y_serialized).unwrap();
+
+                let new_x =
+                    croaring::Bitmap::try_deserialize::<croaring::Portable>(&y_serialized).unwrap();
+                let new_y = roaring::RoaringBitmap::deserialize_from(&x_serialized[..]).unwrap();
+                assert_eq!(new_x, *x);
+                assert_eq!(new_y, *y);
+                *x = new_x;
+                *y = new_y;
+            }
             MutableBitmapOperation::MakeBitmap { key } => {
                 let key = u32::from(key);
                 let start = key * 0x1_0000;
@@ -245,6 +309,13 @@ impl MutableBitmapOperation {
                     y.insert(i);
                 }
             }
+            MutableBitmapOperation::MakeRange { key } => {
+                let key = u32::from(key);
+                let start = key * 0x1_0000;
+                let end = start + 9 * 1024;
+                x.add_range(start..=end);
+                y.insert_range(start..=end);
+            }
         }
     }
 }

roaring/src/bitmap/arbitrary.rs

@@ -1,7 +1,7 @@
 #[cfg(test)]
 mod test {
-    use crate::bitmap::container::Container;
-    use crate::bitmap::store::{ArrayStore, BitmapStore, Store};
+    use crate::bitmap::container::{Container, RUN_MAX_SIZE};
+    use crate::bitmap::store::{ArrayStore, BitmapStore, IntervalStore, Store};
     use crate::RoaringBitmap;
     use core::fmt::{Debug, Formatter};
     use proptest::bits::{BitSetLike, SampledBitSetStrategy};
@@ -68,6 +68,47 @@ mod test {
         }
     }
 
+    impl BitSetLike for IntervalStore {
+        fn new_bitset(max: usize) -> Self {
+            assert!(max <= IntervalStore::MAX + 1);
+            IntervalStore::new()
+        }
+
+        fn len(&self) -> usize {
+            IntervalStore::MAX + 1
+        }
+
+        fn test(&self, bit: usize) -> bool {
+            assert!(bit <= IntervalStore::MAX);
+            self.contains(bit as u16)
+        }
+
+        fn set(&mut self, bit: usize) {
+            assert!(bit <= IntervalStore::MAX);
+            self.insert(bit as u16);
+        }
+
+        fn clear(&mut self, bit: usize) {
+            assert!(bit <= IntervalStore::MAX);
+            self.remove(bit as u16);
+        }
+
+        fn count(&self) -> usize {
+            self.len() as usize
+        }
+    }
+
+    impl IntervalStore {
+        const MAX: usize = u16::MAX as usize;
+
+        pub fn sampled(
+            size: impl Into<SizeRange>,
+            bits: impl Into<SizeRange>,
+        ) -> SampledBitSetStrategy<Self> {
+            SampledBitSetStrategy::new(size.into(), bits.into())
+        }
+    }
+
     impl Debug for ArrayStore {
         fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
             if self.len() < 16 {
@@ -130,6 +171,7 @@ mod test {
             match self {
                 Store::Array(a) => write!(f, "Store({a:?})"),
                 Store::Bitmap(b) => write!(f, "Store({b:?})"),
+                Store::Run(c) => write!(f, "Store({c:?})"),
             }
         }
     }
@@ -140,6 +182,8 @@ mod test {
                 ArrayStore::sampled(1..=4096, ..=u16::MAX as usize).prop_map(Store::Array),
                 BitmapStore::sampled(4097..u16::MAX as usize, ..=u16::MAX as usize)
                     .prop_map(Store::Bitmap),
+                IntervalStore::sampled(1..=RUN_MAX_SIZE as usize, ..=u16::MAX as usize)
+                    .prop_map(Store::Run),
             ]
         }
     }