fmt, clippy and bench for other hashers

shyba · May 8, 2024 · 869777e · 869777e
1 parent 97f9a06
commit 869777e
Show file tree

Hide file tree

Showing 4 changed files with 47 additions and 26 deletions.
diff --git a/benches/no_hash.rs b/benches/no_hash.rs
@@ -4,6 +4,12 @@ pub struct NoHasher {
     state: u64,
 }
 
+impl Default for NoHasher {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl NoHasher {
     pub fn new() -> Self {
         NoHasher { state: 42 }

diff --git a/benches/simple_benchmark.rs b/benches/simple_benchmark.rs
@@ -2,7 +2,7 @@ mod no_hash;
 use balufilter::{blocking::BlockedAtomicFilter, AtomicFilter, BaluFilter};
 use bloomfilter::Bloom;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use fastbloom::BloomFilter;
+use fastbloom::{BloomFilter, DefaultHasher};
 use no_hash::NoHasher;
 use std::hash::BuildHasher;
 
@@ -34,6 +34,19 @@ pub fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("register blocked check missing", |b| {
         b.iter(|| filter.check(&black_box(inverse_cycle.next().unwrap())))
     });
+    let filter: BlockedAtomicFilter<56_547_705, 24, DefaultHasher> =
+        BlockedAtomicFilter::with_state_and_seed(DefaultHasher::default(), 42);
+    c.bench_function("register fastbloom_default_hasher blocked insert", |b| {
+        b.iter(|| filter.insert(&black_box(cycle.next().unwrap())))
+    });
+    c.bench_function(
+        "register fastbloom_default_hasher blocked check present",
+        |b| b.iter(|| filter.check(&black_box(cycle.next().unwrap()))),
+    );
+    c.bench_function(
+        "register fastbloom_default_hasher blocked check missing",
+        |b| b.iter(|| filter.check(&black_box(inverse_cycle.next().unwrap()))),
+    );
     let filter: AtomicFilter<BITS_SIZE, 23, NoHasher> =
         AtomicFilter::with_state_and_seed(NoHasher::new(), 42);
     c.bench_function("nohash insert", |b| {
@@ -107,7 +120,9 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         b.iter(|| bloomfilter.check(black_box(&inverse_cycle.next().unwrap())))
     });
 
-    let mut bloomfilter = BloomFilter::with_false_pos(rate).hasher(NoHasher::new()).expected_items(1_000_000);
+    let mut bloomfilter = BloomFilter::with_false_pos(rate)
+        .hasher(NoHasher::new())
+        .expected_items(1_000_000);
 
     c.bench_function("fastbloom insert", |b| {
         b.iter(|| bloomfilter.insert(black_box(&cycle.next().unwrap())))

diff --git a/src/blocking.rs b/src/blocking.rs
@@ -116,19 +116,19 @@ mod test {
     #[test]
     fn test_blocked_insert_check() {
         let filter: BlockedAtomicFilter<320, 8, RandomState> = BlockedAtomicFilter::default();
-        assert_eq!(false, filter.check(&"tchan"));
-        assert_eq!(false, filter.insert(&"tchan"));
-        assert_eq!(true, filter.check(&"tchan"));
-        assert_eq!(true, filter.insert(&"tchan"));
-
-        assert_eq!(false, filter.check(&"molejo"));
-        assert_eq!(false, filter.insert(&"molejo"));
-        assert_eq!(true, filter.check(&"molejo"));
-        assert_eq!(true, filter.insert(&"molejo"));
+        assert!(!filter.check(&"tchan"));
+        assert!(!filter.insert(&"tchan"));
+        assert!(filter.check(&"tchan"));
+        assert!(filter.insert(&"tchan"));
+
+        assert!(!filter.check(&"molejo"));
+        assert!(!filter.insert(&"molejo"));
+        assert!(filter.check(&"molejo"));
+        assert!(filter.insert(&"molejo"));
     }
 
     // This test needs --release, otherwise it can take a lot of time
-    #[cfg(feature="slow-test")]
+    #[cfg(feature = "slow-test")]
     #[test]
     fn test_very_large_blocked_filter_insert_does_not_blow_stack() {
         let filter: BlockedAtomicFilter<56_547_705, 24, RandomState> =

diff --git a/src/lib.rs b/src/lib.rs
@@ -121,14 +121,14 @@ mod tests {
     #[test]
     fn test_simple_insert() {
         let filter: AtomicFilter<320, 50, RandomState> = AtomicFilter::default();
-        assert_eq!(false, filter.insert(&"tchan"));
-        assert_eq!(true, filter.insert(&"tchan"));
-        assert_eq!(false, filter.insert(&"molejo"));
-        assert_eq!(true, filter.insert(&"molejo"));
+        assert!(!filter.insert(&"tchan"));
+        assert!(filter.insert(&"tchan"));
+        assert!(!filter.insert(&"molejo"));
+        assert!(filter.insert(&"molejo"));
     }
 
     // This test needs --release, otherwise it can take a lot of time
-    #[cfg(feature="slow-test")]
+    #[cfg(feature = "slow-test")]
     #[test]
     fn test_very_large_filter_insert_does_not_blow_stack() {
         let filter: AtomicFilter<33_547_705, 23, RandomState> = AtomicFilter::default();
@@ -158,15 +158,15 @@ mod tests {
     #[test]
     fn test_insert_check() {
         let filter: AtomicFilter<320, 43, RandomState> = AtomicFilter::default();
-        assert_eq!(false, filter.check(&"tchan"));
-        assert_eq!(false, filter.insert(&"tchan"));
-        assert_eq!(true, filter.check(&"tchan"));
-        assert_eq!(true, filter.insert(&"tchan"));
+        assert!(!filter.check(&"tchan"));
+        assert!(!filter.insert(&"tchan"));
+        assert!(filter.check(&"tchan"));
+        assert!(filter.insert(&"tchan"));
 
-        assert_eq!(false, filter.check(&"molejo"));
-        assert_eq!(false, filter.insert(&"molejo"));
-        assert_eq!(true, filter.check(&"molejo"));
-        assert_eq!(true, filter.insert(&"molejo"));
+        assert!(!filter.check(&"molejo"));
+        assert!(!filter.insert(&"molejo"));
+        assert!(filter.check(&"molejo"));
+        assert!(filter.insert(&"molejo"));
     }
 
     #[test]
@@ -228,7 +228,7 @@ mod tests {
                         }
                     }
                     p /= 1_000_000f64;
-                    assert!(p < 0.000002f64 as f64, "P = {} > 0.000002", p);
+                    assert!(p < 0_f64, "P = {} > 0.000002", p);
                     let mut found = false;
                     for element in 0..1_000_000 {
                         if !thread_filter.check(&element) {