Fix up benchmarks and tests

benches/fuzzy_tags_benches.rs

@@ -1,27 +1,26 @@
-use criterion::{criterion_group, criterion_main, Criterion, BenchmarkId};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use fuzzymetatag::FuzzyMetaTagKeyPair;
 use std::time::Duration;
 
 fn benchmark_generate_tag(c: &mut Criterion) {
     let mut group = c.benchmark_group("generate_tags");
-    group.measurement_time(Duration::new(10,0));
+    group.measurement_time(Duration::new(10, 0));
     let key = FuzzyMetaTagKeyPair::generate(24);
-    for p in [5,10,15].iter() {
-        group.bench_with_input(BenchmarkId::from_parameter(p), p, |b, _gamma| b.iter(|| { key.public_key.generate_tag() }));
+    for p in [5, 10, 15].iter() {
+        group.bench_with_input(BenchmarkId::from_parameter(p), p, |b, _gamma| b.iter(|| key.public_key.generate_tag()));
     }
 }
 
 fn benchmark_test_tag(c: &mut Criterion) {
     let mut group = c.benchmark_group("test_tags");
-    group.measurement_time(Duration::new(10,0));
+    group.measurement_time(Duration::new(10, 0));
     let key = FuzzyMetaTagKeyPair::generate(24);
-    for p in [5,10,15].iter() {
+    for p in [5, 10, 15].iter() {
         let tag = key.public_key.generate_tag();
         let detection_key = key.extract(*p);
-        group.bench_with_input(BenchmarkId::from_parameter(p), p, |b, _gamma| b.iter(|| { detection_key.test_tag(&tag) }));
+        group.bench_with_input(BenchmarkId::from_parameter(p), p, |b, _gamma| b.iter(|| detection_key.test_tag(&tag)));
     }
 }
 
-
 criterion_group!(benches, benchmark_generate_tag, benchmark_test_tag);
-criterion_main!(benches);
+criterion_main!(benches);

src/lib.rs

@@ -159,13 +159,10 @@ impl FuzzyMetaTagKeyPair {
         }
     }
 
-
     /// extract a detection key for a given false positive (p = 2^-n)
     pub fn extract(&self, n: usize) -> FuzzyMetaDetectionKey {
         let parts = self.detection_key.0.iter().take(n).cloned().collect();
-        FuzzyMetaDetectionKey {
-            0: parts
-        }
+        FuzzyMetaDetectionKey { 0: parts }
     }
 
     /// a hash function that takes 3 risretto points as a parameter and outputs 0 or 1.
@@ -200,29 +197,28 @@ mod tests {
         for i in 0..number_of_messages {
             let tag = key.public_key.generate_tag();
             println!("{}: {}", i, tag);
-            assert!(key.detection_key.test_tag(&tag));
+            assert!(key.extract(5).test_tag(&tag));
         }
     }
 
     #[test]
     fn false_postives() {
-        let gamma = 3;
+        let gamma = 8;
         let number_of_messages = 1000;
         let key = FuzzyMetaTagKeyPair::generate(gamma);
         let mut false_positives = 0;
         for _i in 0..number_of_messages {
             let key2 = FuzzyMetaTagKeyPair::generate(gamma);
             let tag = key2.public_key.generate_tag();
-            assert!(key2.detection_key.test_tag(&tag));
-            if key.detection_key.test_tag(&tag) == true {
+            assert!(key2.extract(3).test_tag(&tag));
+            if key.extract(3).test_tag(&tag) == true {
                 false_positives += 1;
             }
         }
         println!(
             "Expected False Positive Rate: {}\nActual False Positive Rate: {}",
-            (2.0_f64).powi(-(gamma as i32)),
+            (2.0_f64).powi(-3),
             (false_positives as f64 / number_of_messages as f64)
         );
     }
-
 }