Add tests for varying percentages of blocked bridge

src/tests.rs

@@ -4,7 +4,9 @@ BridgeLine::random() or private fields */
 use super::bridge_table::BridgeLine;
 use super::proto::*;
 use super::*;
+use rand::Rng;
 use statistical::{mean, standard_deviation};
+use std::collections::HashSet;
 use std::time::{Duration, Instant};
 
 struct PerfStat {
@@ -84,7 +86,7 @@ impl TestHarness {
             open_invite::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
         let resp_handle_t = resp_handle_start.elapsed();
 
-        return (
+        (
             PerfStat {
                 req_len,
                 resp_len,
@@ -93,7 +95,7 @@ impl TestHarness {
                 resp_handle_t,
             },
             (cred, bridgeline),
-        );
+        )
     }
 
     fn trust_promotion(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Migration) {
@@ -116,7 +118,7 @@ impl TestHarness {
         let migcred = trust_promotion::handle_response(promstate, decode_resp).unwrap();
         let resp_handle_t = resp_handle_start.elapsed();
 
-        return (
+        (
             PerfStat {
                 req_len,
                 resp_len,
@@ -125,7 +127,7 @@ impl TestHarness {
                 resp_handle_t,
             },
             migcred,
-        );
+        )
     }
 
     fn level0_migration(
@@ -152,7 +154,7 @@ impl TestHarness {
         let cred = migration::handle_response(migstate, decode_resp, &self.ba.lox_pub).unwrap();
         let resp_handle_t = resp_handle_start.elapsed();
 
-        return (
+        (
             PerfStat {
                 req_len,
                 resp_len,
@@ -161,7 +163,7 @@ impl TestHarness {
                 resp_handle_t,
             },
             cred,
-        );
+        )
     }
 
     fn level_up(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Lox) {
@@ -201,7 +203,7 @@ impl TestHarness {
         let cred = level_up::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
         let resp_handle_t = resp_handle_start.elapsed();
 
-        return (
+        (
             PerfStat {
                 req_len,
                 resp_len,
@@ -210,7 +212,7 @@ impl TestHarness {
                 resp_handle_t,
             },
             cred,
-        );
+        )
     }
 
     fn issue_invite(&mut self, cred: &cred::Lox) -> (PerfStat, (cred::Lox, cred::Invitation)) {
@@ -253,7 +255,7 @@ impl TestHarness {
         .unwrap();
         let resp_handle_t = resp_handle_start.elapsed();
 
-        return (
+        (
             PerfStat {
                 req_len,
                 resp_len,
@@ -262,7 +264,7 @@ impl TestHarness {
                 resp_handle_t,
             },
             (cred, invite),
-        );
+        )
     }
 
     fn redeem_invite(&mut self, inv: &cred::Invitation) -> (PerfStat, cred::Lox) {
@@ -285,7 +287,7 @@ impl TestHarness {
         let cred = redeem_invite::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
         let resp_handle_t = resp_handle_start.elapsed();
 
-        return (
+        (
             PerfStat {
                 req_len,
                 resp_len,
@@ -294,7 +296,7 @@ impl TestHarness {
                 resp_handle_t,
             },
             cred,
-        );
+        )
     }
 
     fn check_blockage(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Migration) {
@@ -316,7 +318,7 @@ impl TestHarness {
         let migcred = check_blockage::handle_response(state, decode_resp).unwrap();
         let resp_handle_t = resp_handle_start.elapsed();
 
-        return (
+        (
             PerfStat {
                 req_len,
                 resp_len,
@@ -325,7 +327,7 @@ impl TestHarness {
                 resp_handle_t,
             },
             migcred,
-        );
+        )
     }
 
     fn blockage_migration(
@@ -355,7 +357,7 @@ impl TestHarness {
             blockage_migration::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
         let resp_handle_t = resp_handle_start.elapsed();
 
-        return (
+        (
             PerfStat {
                 req_len,
                 resp_len,
@@ -364,7 +366,7 @@ impl TestHarness {
                 resp_handle_t,
             },
             cred,
-        );
+        )
     }
 }
 
@@ -936,8 +938,8 @@ fn stats_test_invitations() {
         th.advance_days(14);
         let (_, cred2) = th.level_up(&cred1);
         th.advance_days(28);
-        let (perf_stat, (cred2a, invite)) = th.issue_invite(&cred2);
-        let (bob_perf_stat, bob_cred) = th.redeem_invite(&invite);
+        let (perf_stat, (_, invite)) = th.issue_invite(&cred2);
+        let (bob_perf_stat, _) = th.redeem_invite(&invite);
         req_size.push(perf_stat.req_len as f64);
         req_t_size.push(perf_stat.req_t.as_secs_f64());
         resp_size.push(perf_stat.resp_len as f64);
@@ -970,7 +972,203 @@ fn stats_test_invitations() {
 }
 
 #[test]
-fn stats_test_blockage_migration() {
+fn stats_test_blockage_migration_5() {
+    let mut th = TestHarness::new_buckets(10, 10);
+    let mut credentials: Vec<cred::Lox> = Vec::new();
+    for _ in 0..1000 {
+        let cred = th.open_invite().1 .0;
+        th.advance_days(30);
+        let (_, migcred) = th.trust_promotion(&cred);
+        let (_, cred1) = th.level0_migration(&cred, &migcred);
+        th.advance_days(14);
+        let (_, cred2) = th.level_up(&cred1);
+        let (_, (cred2a, invite)) = th.issue_invite(&cred2);
+        let (_, bob_cred) = th.redeem_invite(&invite);
+        th.advance_days(28);
+        let (_, _) = th.level_up(&bob_cred);
+        let (_, cred3) = th.level_up(&cred2a);
+        credentials.push(cred3);
+    }
+
+    block_bridges(&mut th, 5, credentials);
+}
+
+#[test]
+fn stats_test_blockage_migration_10() {
+    let mut th = TestHarness::new_buckets(10, 10);
+    let mut credentials: Vec<cred::Lox> = Vec::new();
+    for _ in 0..1000 {
+        let cred = th.open_invite().1 .0;
+        th.advance_days(30);
+        let (_, migcred) = th.trust_promotion(&cred);
+        let (_, cred1) = th.level0_migration(&cred, &migcred);
+        th.advance_days(14);
+        let (_, cred2) = th.level_up(&cred1);
+        let (_, (cred2a, invite)) = th.issue_invite(&cred2);
+        let (_, bob_cred) = th.redeem_invite(&invite);
+        th.advance_days(28);
+        let (_, _) = th.level_up(&bob_cred);
+        let (_, cred3) = th.level_up(&cred2a);
+        credentials.push(cred3);
+    }
+
+    block_bridges(&mut th, 10, credentials);
+}
+
+#[test]
+fn stats_test_blockage_migration_15() {
+    let mut th = TestHarness::new_buckets(10, 10);
+    let mut credentials: Vec<cred::Lox> = Vec::new();
+    for _ in 0..100 {
+        let cred = th.open_invite().1 .0;
+        th.advance_days(30);
+        let (_, migcred) = th.trust_promotion(&cred);
+        let (_, cred1) = th.level0_migration(&cred, &migcred);
+        th.advance_days(14);
+        let (_, cred2) = th.level_up(&cred1);
+        let (_, (cred2a, invite)) = th.issue_invite(&cred2);
+        let (_, bob_cred) = th.redeem_invite(&invite);
+        th.advance_days(28);
+        let (_, _) = th.level_up(&bob_cred);
+        let (_, cred3) = th.level_up(&cred2a);
+        credentials.push(cred3);
+    }
+
+    block_bridges(&mut th, 15, credentials);
+}
+
+#[test]
+fn stats_test_blockage_migration_20() {
+    let mut th = TestHarness::new_buckets(10, 10);
+    let mut credentials: Vec<cred::Lox> = Vec::new();
+    for _ in 0..100 {
+        let cred = th.open_invite().1 .0;
+        th.advance_days(30);
+        let (_, migcred) = th.trust_promotion(&cred);
+        let (_, cred1) = th.level0_migration(&cred, &migcred);
+        th.advance_days(14);
+        let (_, cred2) = th.level_up(&cred1);
+        let (_, (cred2a, invite)) = th.issue_invite(&cred2);
+        let (_, bob_cred) = th.redeem_invite(&invite);
+        th.advance_days(28);
+        let (_, _) = th.level_up(&bob_cred);
+        let (_, cred3) = th.level_up(&cred2a);
+        credentials.push(cred3);
+    }
+
+    block_bridges(&mut th, 20, credentials);
+}
+
+#[test]
+fn stats_test_blockage_migration_25() {
+    let mut th = TestHarness::new_buckets(10, 10);
+    let mut credentials: Vec<cred::Lox> = Vec::new();
+    for _ in 0..100 {
+        let cred = th.open_invite().1 .0;
+        th.advance_days(30);
+        let (_, migcred) = th.trust_promotion(&cred);
+        let (_, cred1) = th.level0_migration(&cred, &migcred);
+        th.advance_days(14);
+        let (_, cred2) = th.level_up(&cred1);
+        let (_, (cred2a, invite)) = th.issue_invite(&cred2);
+        let (_, bob_cred) = th.redeem_invite(&invite);
+        th.advance_days(28);
+        let (_, _) = th.level_up(&bob_cred);
+        let (_, cred3) = th.level_up(&cred2a);
+        credentials.push(cred3);
+    }
+
+    block_bridges(&mut th, 25, credentials);
+}
+
+#[test]
+fn stats_test_blockage_migration_30() {
+    let mut th = TestHarness::new_buckets(10, 10);
+    let mut credentials: Vec<cred::Lox> = Vec::new();
+    for _ in 0..100 {
+        let cred = th.open_invite().1 .0;
+        th.advance_days(30);
+        let (_, migcred) = th.trust_promotion(&cred);
+        let (_, cred1) = th.level0_migration(&cred, &migcred);
+        th.advance_days(14);
+        let (_, cred2) = th.level_up(&cred1);
+        let (_, (cred2a, invite)) = th.issue_invite(&cred2);
+        let (_, bob_cred) = th.redeem_invite(&invite);
+        th.advance_days(28);
+        let (_, _) = th.level_up(&bob_cred);
+        let (_, cred3) = th.level_up(&cred2a);
+        credentials.push(cred3);
+    }
+
+    block_bridges(&mut th, 30, credentials);
+}
+
+#[test]
+fn stats_test_blockage_migration_35() {
+    let mut th = TestHarness::new_buckets(10, 10);
+    let mut credentials: Vec<cred::Lox> = Vec::new();
+    for _ in 0..100 {
+        let cred = th.open_invite().1 .0;
+        th.advance_days(30);
+        let (_, migcred) = th.trust_promotion(&cred);
+        let (_, cred1) = th.level0_migration(&cred, &migcred);
+        th.advance_days(14);
+        let (_, cred2) = th.level_up(&cred1);
+        let (_, (cred2a, invite)) = th.issue_invite(&cred2);
+        let (_, bob_cred) = th.redeem_invite(&invite);
+        th.advance_days(28);
+        let (_, _) = th.level_up(&bob_cred);
+        let (_, cred3) = th.level_up(&cred2a);
+        credentials.push(cred3);
+    }
+
+    block_bridges(&mut th, 35, credentials);
+}
+
+#[test]
+fn stats_test_blockage_migration_40() {
+    let mut th = TestHarness::new_buckets(10, 10);
+    let mut credentials: Vec<cred::Lox> = Vec::new();
+    for _ in 0..100 {
+        let cred = th.open_invite().1 .0;
+        th.advance_days(30);
+        let (_, migcred) = th.trust_promotion(&cred);
+        let (_, cred1) = th.level0_migration(&cred, &migcred);
+        th.advance_days(14);
+        let (_, cred2) = th.level_up(&cred1);
+        let (_, (cred2a, invite)) = th.issue_invite(&cred2);
+        let (_, bob_cred) = th.redeem_invite(&invite);
+        th.advance_days(28);
+        let (_, _) = th.level_up(&bob_cred);
+        let (_, cred3) = th.level_up(&cred2a);
+        credentials.push(cred3);
+    }
+
+    block_bridges(&mut th, 40, credentials);
+}
+
+/// Blocks a percentage of the total number of bridges for the passed Test Harness
+/// for the number of buckets and hot spares passed at initialization
+
+fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred::Lox>) {
+    let to_block: usize = (th.ba.bridge_table.buckets.len() * percentage / 100).into();
+    let mut block_index: HashSet<usize> = HashSet::new();
+    let mut rng = rand::thread_rng();
+
+    while block_index.len() <= to_block - 1 {
+        let rand_num = rng.gen_range(0, th.ba.bridge_table.buckets.len());
+        block_index.insert(rand_num);
+    }
+
+    for index in block_index {
+        let b0 = th.ba.bridge_table.buckets[index][0];
+        let b1 = th.ba.bridge_table.buckets[index][1];
+        let b2 = th.ba.bridge_table.buckets[index][2];
+        th.ba.bridge_unreachable(&b0, &mut th.bdb);
+        th.ba.bridge_unreachable(&b1, &mut th.bdb);
+        th.ba.bridge_unreachable(&b2, &mut th.bdb);
+    }
+
     let mut req_size: Vec<f64> = Vec::new();
     let mut resp_size: Vec<f64> = Vec::new();
     let mut req_t_size: Vec<f64> = Vec::new();
@@ -981,39 +1179,39 @@ fn stats_test_blockage_migration() {
     let mut red_req_t_size: Vec<f64> = Vec::new();
     let mut red_resp_t_size: Vec<f64> = Vec::new();
     let mut red_resp_handle_t_size: Vec<f64> = Vec::new();
-    for _ in 0..10000 {
-        let mut th = TestHarness::new_buckets(3, 3);
-        let cred = th.open_invite().1 .0;
-        th.advance_days(30);
-        let (_, migcred) = th.trust_promotion(&cred);
-        let (_, cred1) = th.level0_migration(&cred, &migcred);
-        th.advance_days(14);
-        let (_, cred2) = th.level_up(&cred1);
-        th.advance_days(28);
-        let (_, cred3) = th.level_up(&cred2);
-        let (id, key) = bridge_table::from_scalar(cred3.bucket).unwrap();
+    for cred in credentials {
+        let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
         let encbuckets = th.ba.enc_bridge_table();
         let bucket =
             bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
-        th.ba.bridge_unreachable(&bucket.0[0], &mut th.bdb);
-        th.ba.bridge_unreachable(&bucket.0[1], &mut th.bdb);
-        th.ba.bridge_unreachable(&bucket.0[2], &mut th.bdb);
-        let (perf_stat, migration) = th.check_blockage(&cred3);
-        let (block_perf_stat, cred4) = th.blockage_migration(&cred3, &migration);
 
-        req_size.push(perf_stat.req_len as f64);
-        req_t_size.push(perf_stat.req_t.as_secs_f64());
-        resp_size.push(perf_stat.resp_len as f64);
-        resp_t_size.push(perf_stat.resp_t.as_secs_f64());
-        resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
-        red_req_size.push(block_perf_stat.req_len as f64);
-        red_req_t_size.push(block_perf_stat.req_t.as_secs_f64());
-        red_resp_size.push(block_perf_stat.resp_len as f64);
-        red_resp_t_size.push(block_perf_stat.resp_t.as_secs_f64());
-        red_resp_handle_t_size.push(block_perf_stat.resp_handle_t.as_secs_f64());
+        let mut count = 0;
+        for bridge_line in &bucket.0 {
+            if th.ba.bridge_table.reachable.contains_key(bridge_line) {
+                count = count + 1;
+            }
+        }
+
+        if count < 2 {
+            let (perf_stat, migration) = th.check_blockage(&cred);
+            let (block_perf_stat, _) = th.blockage_migration(&cred, &migration);
+            req_size.push(perf_stat.req_len as f64);
+            req_t_size.push(perf_stat.req_t.as_secs_f64());
+            resp_size.push(perf_stat.resp_len as f64);
+            resp_t_size.push(perf_stat.resp_t.as_secs_f64());
+            resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
+            red_req_size.push(block_perf_stat.req_len as f64);
+            red_req_t_size.push(block_perf_stat.req_t.as_secs_f64());
+            red_resp_size.push(block_perf_stat.resp_len as f64);
+            red_resp_t_size.push(block_perf_stat.resp_t.as_secs_f64());
+            red_resp_handle_t_size.push(block_perf_stat.resp_handle_t.as_secs_f64());
+        }
     }
 
-    println!("\n---------------Check Blockage----------------\n");
+    println!(
+        "\n---------------Check Blockage {}---------------\n",
+        percentage
+    );
     print_stats_test_results(
         req_size,
         req_t_size,
@@ -1022,7 +1220,10 @@ fn stats_test_blockage_migration() {
         resp_handle_t_size,
     );
 
-    println!("\n---------------Blockage Migration----------------\n");
+    println!(
+        "\n---------------Blockage Migration {}---------------\n",
+        percentage
+    );
     print_stats_test_results(
         red_req_size,
         red_req_t_size,