chore: add proptest for newly introduced bitmap functions

This commit introduced [proptests](https://docs.rs/proptest) for newly introduced:

- bitmap_contains
- bitmap_min
- bitmap_max
- bitmap_has_any
- bitmap_has_all

Each compares the result against RoaringTreemap as ground truth.

Strategy design inspired by roaring as:

- Store (random bits)
- Container (50% Array, 50% Bitmap)
- Bitmap (0 to 16 containers)
- Tree (0 to 16 Bitmaps)
- Serialization (80% Hybrid, 10% Legacy, 10% Empty)

Author: harry-hao

Cargo.lock

@@ -34,6 +34,7 @@ wkt = { workspace = true }
 [dev-dependencies]
 aho-corasick = { workspace = true }
 anyhow = { workspace = true }
+proptest = { workspace = true }
 rand = { workspace = true }
 rmp-serde = { workspace = true }
 

src/common/io/Cargo.toml

@@ -2131,4 +2131,197 @@ mod tests {
             assert_eq!(actual, expected, "bitmap_has_all: fixture={name}");
         });
     }
+
+    /// proptests for bitmap functions:
+    ///
+    ///  - [x] bitmap_contains
+    ///  - [x] bitmap_min
+    ///  - [x] bitmap_max
+    ///  - [x] bitmap_has_any
+    ///  - [x] bitmap_has_all
+    ///
+    /// According to comment in src/common/column/tests/it/bitmap/assign_ops.rs,
+    /// following prop tests are ignored when using `miri`.
+    #[cfg_attr(miri, ignore)]
+    mod proptests {
+        use proptest::bits::BitSetLike;
+        use proptest::bits::SampledBitSetStrategy;
+        use proptest::collection::SizeRange;
+        use proptest::collection::btree_map;
+        use proptest::prelude::*;
+        use roaring::RoaringBitmap;
+
+        use super::*;
+
+        /// The random bits strategy.
+        ///
+        /// Generate random bits with [`Store::sampled`].
+        #[derive(Clone, Debug)]
+        struct Store(Vec<u16>);
+
+        impl Store {
+            fn sampled(
+                size: impl Into<SizeRange>,
+                bits: impl Into<SizeRange>,
+            ) -> SampledBitSetStrategy<Self> {
+                SampledBitSetStrategy::new(size.into(), bits.into())
+            }
+        }
+
+        /// Implement BitSetLike as required by SampledBitSetStrategy.
+        impl BitSetLike for Store {
+            fn new_bitset(max: usize) -> Self {
+                assert!(max <= u16::MAX as usize + 1);
+                Store(Vec::new())
+            }
+            fn len(&self) -> usize {
+                u16::MAX as usize + 1
+            }
+            fn test(&self, bit: usize) -> bool {
+                self.0.binary_search(&(bit as u16)).is_ok()
+            }
+            fn set(&mut self, bit: usize) {
+                let v = bit as u16;
+                if let Err(pos) = self.0.binary_search(&v) {
+                    self.0.insert(pos, v);
+                }
+            }
+            fn clear(&mut self, bit: usize) {
+                let v = bit as u16;
+                if let Ok(pos) = self.0.binary_search(&v) {
+                    self.0.remove(pos);
+                }
+            }
+            fn count(&self) -> usize {
+                self.0.len()
+            }
+        }
+
+        /// The container strategy.
+        ///
+        /// Generates:
+        ///     50% array container with 1 to 4096 values
+        ///     50% bitmap container with 4097 to 65536 values
+        fn container_strategy() -> impl Strategy<Value = Vec<u16>> {
+            prop_oneof![
+                Store::sampled(1..=4096, ..=u16::MAX as usize).prop_map(|bs| bs.0),
+                Store::sampled(4097..u16::MAX as usize, ..=u16::MAX as usize).prop_map(|bs| bs.0),
+            ]
+        }
+
+        /// The RoaringBitmap strategy.
+        ///
+        /// Generate 0 to 16 containers, with containers from [`container_strategy`].
+        fn bitmap_strategy() -> impl Strategy<Value = RoaringBitmap> {
+            btree_map(0u16..=16, container_strategy(), 0usize..=16).prop_map(|map| {
+                let mut bitmap = RoaringBitmap::new();
+                for (key, values) in map {
+                    for v in values {
+                        bitmap.insert((key as u32) << 16 | v as u32);
+                    }
+                }
+                bitmap
+            })
+        }
+
+        /// The RoaringTreemap strategy.
+        ///
+        /// Generate 0 to 16 RoaringBitmaps, each generated by [`bitmap_strategy`].
+        fn tree_strategy() -> impl Strategy<Value = RoaringTreemap> {
+            btree_map(0u32..=16, bitmap_strategy(), 0usize..=16).prop_map(|map| {
+                let mut treemap = RoaringTreemap::new();
+                for (key, bitmap) in map {
+                    if !bitmap.is_empty() {
+                        for v in bitmap.iter() {
+                            treemap.insert((key as u64) << 32 | v as u64);
+                        }
+                    }
+                }
+                treemap
+            })
+        }
+
+        /// The serialization strategy.
+        ///
+        /// Serialize RoaringTreemap from [`tree_strategy`] into `Vec<u8>`:
+        ///     80% HybridBitmap
+        ///     10% Legacy
+        ///     10% Empty
+        fn serialization_strategy() -> impl Strategy<Value = (Vec<u8>, RoaringTreemap)> {
+            prop_oneof![
+                8 => tree_strategy().prop_map(|tree| {
+                    let bm = HybridBitmap::from_iter(tree.iter());
+                    let mut buf = Vec::new();
+                    bm.serialize_into(&mut buf).unwrap();
+                    (buf, tree)
+                }),
+                1 => tree_strategy().prop_map(|tree| {
+                    let mut buf = Vec::new();
+                    tree.serialize_into(&mut buf).unwrap();
+                    (buf, tree)
+                }),
+                1 => Just((Vec::new(), RoaringTreemap::new())),
+            ]
+        }
+
+        /// The probe strategy, picks random value for bitmap_contains to probe.
+        ///
+        /// 50% hit: probe = random value from tree (via nth)
+        /// 50% miss: probe = random u64
+        fn probe_strategy() -> impl Strategy<Value = (Vec<u8>, RoaringTreemap, u64)> {
+            (serialization_strategy(), any::<bool>(), any::<u64>()).prop_map(
+                |((buf, tree), is_hit, random_value)| {
+                    let probe = if is_hit && !tree.is_empty() {
+                        let idx = (random_value % tree.len()) as usize;
+                        tree.iter().nth(idx).unwrap_or(random_value)
+                    } else {
+                        random_value
+                    };
+                    (buf, tree, probe)
+                },
+            )
+        }
+
+        proptest! {
+            // Make the test run faster by limiting the number of cases, running 32 cases
+            // took ~16 seconds in release, and ~160 in debug.
+            // One can override this by setting the `PROPTEST_CASES` environment variable.
+            #![proptest_config(ProptestConfig::with_cases(32))]
+
+            #[test]
+            fn prop_bitmap_contains((buf, tree, value) in probe_strategy()) {
+                let expected = tree.contains(value);
+                let actual = bitmap_contains(&buf, value).unwrap();
+                assert_eq!(actual, expected);
+            }
+
+            #[test]
+            fn prop_bitmap_min((buf, tree) in serialization_strategy()) {
+                assert_eq!(bitmap_min(&buf).unwrap(), tree.min());
+            }
+
+            #[test]
+            fn prop_bitmap_max((buf, tree) in serialization_strategy()) {
+                assert_eq!(bitmap_max(&buf).unwrap(), tree.max());
+            }
+
+            #[test]
+            fn prop_bitmap_has_any(
+                ((lhs_buf, lhs_tree), (rhs_buf, rhs_tree)) in (serialization_strategy(), serialization_strategy())
+            ) {
+                let expected = !(lhs_tree & rhs_tree).is_empty();
+                let actual = bitmap_has_any(&lhs_buf, &rhs_buf).unwrap();
+                assert_eq!(actual, expected);
+            }
+
+            #[test]
+            fn prop_bitmap_has_all(
+                ((lhs_buf, lhs_tree), (rhs_buf, rhs_tree)) in (serialization_strategy(), serialization_strategy())
+            ) {
+                let expected = lhs_tree.is_superset(&rhs_tree);
+                let actual = bitmap_has_all(&lhs_buf, &rhs_buf).unwrap();
+                assert_eq!(actual, expected);
+            }
+        }
+    }
 }