Add pseudorandom filter test function to geo_filters

Also change the RNG in the test_rng harness to use chacha12 since that's
portable.

Author: itsibitzi

crates/geo_filters/src/config.rs

@@ -353,13 +353,14 @@ pub(crate) fn take_ref<I: Iterator>(iter: &mut I, n: usize) -> impl Iterator<Ite
 
 #[cfg(test)]
 pub(crate) mod tests {
-    use rand::{rngs::StdRng, RngCore};
+    use rand::RngCore;
+    use rand_chacha::ChaCha12Rng;
 
     use crate::{Count, Method};
 
     /// Runs estimation trials and returns the average precision and variance.
     pub(crate) fn test_estimate<M: Method, C: Count<M>>(
-        rnd: &mut StdRng,
+        rnd: &mut ChaCha12Rng,
         f: impl Fn() -> C,
     ) -> (f32, f32) {
         let cnt = 10000usize;

crates/geo_filters/src/config/lookup.rs

@@ -45,7 +45,8 @@ impl HashToBucketLookup {
 
 #[cfg(test)]
 mod tests {
-    use rand::{rngs::StdRng, RngCore};
+    use rand::RngCore;
+    use rand_chacha::ChaCha12Rng;
 
     use crate::{
         config::{hash_to_bucket, phi_f64},
@@ -70,7 +71,7 @@ mod tests {
         });
     }
 
-    fn lookup_random_hashes_variance<const B: usize>(rnd: &mut StdRng, n: u64) -> f64 {
+    fn lookup_random_hashes_variance<const B: usize>(rnd: &mut ChaCha12Rng, n: u64) -> f64 {
         let phi = phi_f64(B);
         let buckets = HashToBucketLookup::new(B);
 

crates/geo_filters/src/diff_count.rs

@@ -353,6 +353,20 @@ impl<'a, C: GeoConfig<Diff>> GeoDiffCount<'a, C> {
     pub fn iter_ones(&self) -> impl Iterator<Item = C::BucketType> + '_ {
         iter_ones(self.bit_chunks().peekable()).map(C::BucketType::from_usize)
     }
+
+    /// Generate a pseudo-random filter. For a given number of items
+    #[cfg(test)]
+    pub fn pseudorandom_filter(config: C, items: usize) -> Self {
+        use rand::RngCore;
+        use rand_chacha::rand_core::SeedableRng;
+
+        let mut rng = rand_chacha::ChaCha12Rng::seed_from_u64(items as u64);
+        let mut filter = Self::new(config);
+        for _ in 0..items {
+            filter.push_hash(rng.next_u64());
+        }
+        filter
+    }
 }
 
 /// Applies a repeated bit mask to the underlying filter.
@@ -434,7 +448,8 @@ mod tests {
     use std::io::Write;
 
     use itertools::Itertools;
-    use rand::{rngs::StdRng, seq::IteratorRandom, RngCore};
+    use rand::{seq::IteratorRandom, RngCore};
+    use rand_chacha::ChaCha12Rng;
 
     use crate::{
         build_hasher::UnstableDefaultBuildHasher,
@@ -658,7 +673,7 @@ mod tests {
     // This helper exists in order to easily test serializing types with different
     // bucket types in the MSB sparse bit field representation. See tests below.
     #[cfg(target_endian = "little")]
-    fn serialization_round_trip<C: GeoConfig<Diff> + Default>(rnd: &mut StdRng) {
+    fn serialization_round_trip<C: GeoConfig<Diff> + Default>(rnd: &mut ChaCha12Rng) {
         // Run 100 simulations of random values being put into
         // a diff counter. "Serializing" to a vector to emulate
         // writing to a disk, and then deserializing and asserting

crates/geo_filters/src/test_rng.rs

@@ -1,6 +1,7 @@
 use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
 
-use rand::{rngs::StdRng, SeedableRng as _};
+use rand::SeedableRng as _;
+use rand_chacha::ChaCha12Rng;
 
 /// Provides a seeded random number generator to tests which require some
 /// degree of randomization. If the test panics the harness will print the
@@ -12,7 +13,7 @@ use rand::{rngs::StdRng, SeedableRng as _};
 /// is only ran once with this seed.
 pub fn prng_test_harness<F>(iterations: usize, mut test_fn: F)
 where
-    F: FnMut(&mut StdRng),
+    F: FnMut(&mut ChaCha12Rng),
 {
     let maybe_manual_seed = std::env::var("TEST_SEED")
         .map(|s| s.parse::<u64>().expect("Parse TEST_SEED to u64"))
@@ -21,12 +22,12 @@ where
     let maybe_panic = catch_unwind(AssertUnwindSafe(|| {
         if let Some(manual_seed) = maybe_manual_seed {
             seed = manual_seed;
-            let mut rng = StdRng::seed_from_u64(seed);
+            let mut rng = ChaCha12Rng::seed_from_u64(seed);
             test_fn(&mut rng);
         } else {
             for _ in 0..iterations {
                 seed = rand::random();
-                let mut rng = StdRng::seed_from_u64(seed);
+                let mut rng = ChaCha12Rng::seed_from_u64(seed);
                 test_fn(&mut rng);
             }
         }