Added tests for different sized bridges

src/tests.rs

@@ -28,7 +28,7 @@ impl TestHarness {
         TestHarness::new_buckets(5, 5)
     }
 
-    fn new_buckets(num_buckets: u8, hot_spare: u8) -> Self {
+    fn new_buckets(num_buckets: u16, hot_spare: u16) -> Self {
         // Create a BridegDb
         let mut bdb = BridgeDb::new();
         // Create a BridgeAuth
@@ -712,9 +712,9 @@ fn test_blockage_migration() {
     assert!(th.ba.verify_lox(&cred4));
 }
 
-#[test]
-fn stats_test_trust_levels() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_trust_levels(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
 
     let mut promo_req_size: Vec<f64> = Vec::new();
     let mut promo_resp_size: Vec<f64> = Vec::new();
@@ -787,21 +787,21 @@ fn stats_test_trust_levels() {
         four_resp_size.push(four_perf_stat.resp_len as f64);
         four_resp_time.push(four_perf_stat.resp_t.as_secs_f64());
         four_resp_handle_time.push(four_perf_stat.resp_handle_t.as_secs_f64());
-        println!("OPEN_INVITE");
-        print_time_test_results(open_perf_stat);
-        println!("TRUST_PROMOTION");
-        print_time_test_results(tp_perf_stat);
-        println!("LEVEL_1_MIGRATION");
-        print_time_test_results(mig_perf_stat);
-        println!("LEVEL_2_UP");
-        print_time_test_results(sec_perf_stat);
-        println!("LEVEL_3_UP");
-        print_time_test_results(three_perf_stat);
-        println!("LEVEL_4_UP");
-        print_time_test_results(four_perf_stat);
+       // println!("OPEN_INVITE");
+       // print_time_test_results(open_perf_stat);
+       // println!("TRUST_PROMOTION");
+       // print_time_test_results(tp_perf_stat);
+       // println!("LEVEL_1_MIGRATION");
+       // print_time_test_results(mig_perf_stat);
+       // println!("LEVEL_2_UP");
+       // print_time_test_results(sec_perf_stat);
+       // println!("LEVEL_3_UP");
+       // print_time_test_results(three_perf_stat);
+       // println!("LEVEL_4_UP");
+       // print_time_test_results(four_perf_stat);
     }
 
-    println!("\n---------------Open Invitationn-------------------\n");
+    println!("\n----OPEN-INVITATION----\n");
     print_stats_test_results(
         open_req_size,
         open_req_time,
@@ -810,7 +810,7 @@ fn stats_test_trust_levels() {
         open_resp_handle_time,
     );
 
-    println!("\n-------Trust Promotion to Level 1: 30 days----\n");
+    println!("\n----TRUST-PROMOTION-1: 30 days----\n");
     print_stats_test_results(
         promo_req_size,
         promo_req_time,
@@ -819,7 +819,7 @@ fn stats_test_trust_levels() {
         promo_resp_handle_time,
     );
 
-    println!("\n-------Trust Level 0 Migration: 30 days------------\n");
+    println!("\n----TRUST-MIGRATION-0: 30 days------------\n");
     print_stats_test_results(
         mig_req_size,
         mig_req_time,
@@ -828,7 +828,7 @@ fn stats_test_trust_levels() {
         mig_resp_handle_time,
     );
 
-    println!("\n-------Trust Promotion to Level 2: 44 days-------\n");
+    println!("\n----LEVEL-UP-2: 44 days----\n");
     print_stats_test_results(
         sec_req_size,
         sec_req_time,
@@ -837,7 +837,7 @@ fn stats_test_trust_levels() {
         sec_resp_handle_time,
     );
 
-    println!("\n-------Trust Promotion to Level 3: 72 days------\n");
+    println!("\n----LEVEL-UP-3: 72 days------\n");
     print_stats_test_results(
         three_req_size,
         three_req_time,
@@ -846,7 +846,7 @@ fn stats_test_trust_levels() {
         three_resp_handle_time,
     );
 
-    println!("\n-------Trust Promotion to Level 4: 128 days------\n");
+    println!("\n----LEVEL-UP-4: 128 days------\n");
     print_stats_test_results(
         four_req_size,
         four_req_time,
@@ -856,9 +856,9 @@ fn stats_test_trust_levels() {
     );
 }
 
-#[test]
-fn stats_test_invitations() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_invitations(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
 
     let mut req_size: Vec<f64> = Vec::new();
     let mut resp_size: Vec<f64> = Vec::new();
@@ -890,16 +890,12 @@ fn stats_test_invitations() {
         red_resp_size.push(bob_perf_stat.resp_len as f64);
         red_resp_time.push(bob_perf_stat.resp_t.as_secs_f64());
         red_resp_handle_time.push(bob_perf_stat.resp_handle_t.as_secs_f64());
-        println!("ISSUE_INVITE");
-        print_time_test_results(perf_stat);
-        println!("REDEEM_INVITE");
-        print_time_test_results(bob_perf_stat);
     }
 
-    println!("\n---------------Issue Invitation----------------\n");
+    println!("\n----ISSUE-INVITATION----\n");
     print_stats_test_results(req_size, req_time, resp_size, resp_time, resp_handle_time);
 
-    println!("\n---------------Redeem Invitation----------------\n");
+    println!("\n----REDEEM-INVITATION----\n");
     print_stats_test_results(
         red_req_size,
         red_req_time,
@@ -909,9 +905,9 @@ fn stats_test_invitations() {
     );
 }
 
-#[test]
-fn stats_test_blockage_migration_5() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_5(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..1000 {
         let cred = th.open_invite().1 .0;
@@ -931,9 +927,9 @@ fn stats_test_blockage_migration_5() {
     block_bridges(&mut th, 5, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_10() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_10(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..1000 {
         let cred = th.open_invite().1 .0;
@@ -953,9 +949,9 @@ fn stats_test_blockage_migration_10() {
     block_bridges(&mut th, 10, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_15() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_15(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -975,9 +971,9 @@ fn stats_test_blockage_migration_15() {
     block_bridges(&mut th, 15, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_20() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_20(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -997,9 +993,9 @@ fn stats_test_blockage_migration_20() {
     block_bridges(&mut th, 20, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_25() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_25(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1019,9 +1015,9 @@ fn stats_test_blockage_migration_25() {
     block_bridges(&mut th, 25, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_30() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_30(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1041,9 +1037,9 @@ fn stats_test_blockage_migration_30() {
     block_bridges(&mut th, 30, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_35() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_35(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1063,9 +1059,9 @@ fn stats_test_blockage_migration_35() {
     block_bridges(&mut th, 35, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_40() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_40(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1085,9 +1081,9 @@ fn stats_test_blockage_migration_40() {
     block_bridges(&mut th, 40, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_45() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_45(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1107,9 +1103,9 @@ fn stats_test_blockage_migration_45() {
     block_bridges(&mut th, 45, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_50() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_50(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1129,9 +1125,9 @@ fn stats_test_blockage_migration_50() {
     block_bridges(&mut th, 50, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_55() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_55(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1151,9 +1147,9 @@ fn stats_test_blockage_migration_55() {
     block_bridges(&mut th, 55, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_60() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_60(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1173,9 +1169,9 @@ fn stats_test_blockage_migration_60() {
     block_bridges(&mut th, 60, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_65() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_65(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1195,9 +1191,9 @@ fn stats_test_blockage_migration_65() {
     block_bridges(&mut th, 65, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_70() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_70(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1217,9 +1213,9 @@ fn stats_test_blockage_migration_70() {
     block_bridges(&mut th, 70, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_75() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_75(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1239,9 +1235,9 @@ fn stats_test_blockage_migration_75() {
     block_bridges(&mut th, 75, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_80() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_80(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1261,9 +1257,9 @@ fn stats_test_blockage_migration_80() {
     block_bridges(&mut th, 80, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_85() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_85(buckets: u16) {
+    let mut th = TestHarness::new_buckets(buckets, buckets);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1283,9 +1279,9 @@ fn stats_test_blockage_migration_85() {
     block_bridges(&mut th, 85, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_90() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_90(bucket: u16) {
+    let mut th = TestHarness::new_buckets(bucket, bucket);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1305,9 +1301,9 @@ fn stats_test_blockage_migration_90() {
     block_bridges(&mut th, 90, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_95() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_95(bucket: u16) {
+    let mut th = TestHarness::new_buckets(bucket, bucket);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1327,9 +1323,9 @@ fn stats_test_blockage_migration_95() {
     block_bridges(&mut th, 95, credentials);
 }
 
-#[test]
-fn stats_test_blockage_migration_100() {
-    let mut th = TestHarness::new_buckets(150, 150);
+//#[test]
+fn stats_test_blockage_migration_100(bucket: u16) {
+    let mut th = TestHarness::new_buckets(bucket, bucket);
     let mut credentials: Vec<cred::Lox> = Vec::new();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
@@ -1349,6 +1345,220 @@ fn stats_test_blockage_migration_100() {
     block_bridges(&mut th, 100, credentials);
 }
 
+//#[test] Check if times/sizes change after blocking
+fn stats_test_blockage_migration_incremental_and_levels(buckets: u16) {
+    println!("\n----WEIRD-TEST----\n");
+    let mut th = TestHarness::new_buckets(buckets, buckets);
+    for _ in 0..15{
+    	let mut req_size: Vec<f64> = Vec::new();
+    	let mut resp_size: Vec<f64> = Vec::new();
+    	let mut req_time: Vec<f64> = Vec::new();
+    	let mut resp_time: Vec<f64> = Vec::new();
+    	let mut resp_handle_time: Vec<f64> = Vec::new();
+    	let mut red_req_size: Vec<f64> = Vec::new();
+    	let mut red_resp_size: Vec<f64> = Vec::new();
+    	let mut red_req_time: Vec<f64> = Vec::new();
+    	let mut red_resp_time: Vec<f64> = Vec::new();
+    	let mut red_resp_handle_time: Vec<f64> = Vec::new();
+    	let mut promo_req_size: Vec<f64> = Vec::new();
+    	let mut promo_resp_size: Vec<f64> = Vec::new();
+    	let mut promo_req_time: Vec<f64> = Vec::new();
+    	let mut promo_resp_time: Vec<f64> = Vec::new();
+    	let mut promo_resp_handle_time: Vec<f64> = Vec::new();
+    	let mut mig_req_size: Vec<f64> = Vec::new();
+    	let mut mig_resp_size: Vec<f64> = Vec::new();
+    	let mut mig_req_time: Vec<f64> = Vec::new();
+    	let mut mig_resp_time: Vec<f64> = Vec::new();
+    	let mut mig_resp_handle_time: Vec<f64> = Vec::new();
+    	let mut sec_req_size: Vec<f64> = Vec::new();
+    	let mut sec_resp_size: Vec<f64> = Vec::new();
+    	let mut sec_req_time: Vec<f64> = Vec::new();
+    	let mut sec_resp_time: Vec<f64> = Vec::new();
+    	let mut sec_resp_handle_time: Vec<f64> = Vec::new();
+    	let mut three_req_size: Vec<f64> = Vec::new();
+    	let mut three_resp_size: Vec<f64> = Vec::new();
+    	let mut three_req_time: Vec<f64> = Vec::new();
+    	let mut three_resp_time: Vec<f64> = Vec::new();
+    	let mut three_resp_handle_time: Vec<f64> = Vec::new();
+    	let mut four_req_size: Vec<f64> = Vec::new();
+    	let mut four_resp_size: Vec<f64> = Vec::new();
+    	let mut four_req_time: Vec<f64> = Vec::new();
+    	let mut four_resp_time: Vec<f64> = Vec::new();
+    	let mut four_resp_handle_time: Vec<f64> = Vec::new();
+    	let mut open_req_size: Vec<f64> = Vec::new();
+    	let mut open_resp_size: Vec<f64> = Vec::new();
+    	let mut open_req_time: Vec<f64> = Vec::new();
+    	let mut open_resp_time: Vec<f64> = Vec::new();
+    	let mut open_resp_handle_time: Vec<f64> = Vec::new();
+        let mut credentials: Vec<cred::Lox> = Vec::new();
+        for _ in 0..10000 {
+            let (open_perf_stat, cred) = th.open_invite();
+            th.advance_days(30);
+            let (tp_perf_stat, migcred) = th.trust_promotion(&cred.0);
+            let (mig_perf_stat, cred1) = th.level0_migration(&cred.0, &migcred);
+            th.advance_days(14);
+            let (sec_perf_stat, cred2) = th.level_up(&cred1);
+            let (perf_stat, (cred2a, invite)) = th.issue_invite(&cred2);
+            let (bob_perf_stat, _) = th.redeem_invite(&invite);
+            th.advance_days(28);
+            let (three_perf_stat, cred3) = th.level_up(&cred2a);
+            th.advance_days(56);
+            let (four_perf_stat, cred4) = th.level_up(&cred3);
+            credentials.push(cred4);
+            open_req_size.push(open_perf_stat.req_len as f64);
+            open_req_time.push(open_perf_stat.req_t.as_secs_f64());
+            open_resp_size.push(open_perf_stat.resp_len as f64);
+            open_resp_time.push(open_perf_stat.resp_t.as_secs_f64());
+            open_resp_handle_time.push(open_perf_stat.resp_handle_t.as_secs_f64());
+            promo_req_size.push(tp_perf_stat.req_len as f64);
+            promo_req_time.push(tp_perf_stat.req_t.as_secs_f64());
+            promo_resp_size.push(tp_perf_stat.resp_len as f64);
+            promo_resp_time.push(tp_perf_stat.resp_t.as_secs_f64());
+            promo_resp_handle_time.push(tp_perf_stat.resp_handle_t.as_secs_f64());
+            mig_req_size.push(mig_perf_stat.req_len as f64);
+            mig_req_time.push(mig_perf_stat.req_t.as_secs_f64());
+            mig_resp_size.push(mig_perf_stat.resp_len as f64);
+            mig_resp_time.push(mig_perf_stat.resp_t.as_secs_f64());
+            mig_resp_handle_time.push(mig_perf_stat.resp_handle_t.as_secs_f64());
+            sec_req_size.push(sec_perf_stat.req_len as f64);
+            sec_req_time.push(sec_perf_stat.req_t.as_secs_f64());
+            sec_resp_size.push(sec_perf_stat.resp_len as f64);
+            sec_resp_time.push(sec_perf_stat.resp_t.as_secs_f64());
+            sec_resp_handle_time.push(sec_perf_stat.resp_handle_t.as_secs_f64());
+            three_req_size.push(three_perf_stat.req_len as f64);
+            three_req_time.push(three_perf_stat.req_t.as_secs_f64());
+            three_resp_size.push(three_perf_stat.resp_len as f64);
+            three_resp_time.push(three_perf_stat.resp_t.as_secs_f64());
+            three_resp_handle_time.push(three_perf_stat.resp_handle_t.as_secs_f64());
+            four_req_size.push(four_perf_stat.req_len as f64);
+            four_req_time.push(four_perf_stat.req_t.as_secs_f64());
+            four_resp_size.push(four_perf_stat.resp_len as f64);
+            four_resp_time.push(four_perf_stat.resp_t.as_secs_f64());
+            four_resp_handle_time.push(four_perf_stat.resp_handle_t.as_secs_f64());
+            req_size.push(perf_stat.req_len as f64);
+            req_time.push(perf_stat.req_t.as_secs_f64());
+            resp_size.push(perf_stat.resp_len as f64);
+            resp_time.push(perf_stat.resp_t.as_secs_f64());
+            resp_handle_time.push(perf_stat.resp_handle_t.as_secs_f64());
+            red_req_size.push(bob_perf_stat.req_len as f64);
+            red_req_time.push(bob_perf_stat.req_t.as_secs_f64());
+            red_resp_size.push(bob_perf_stat.resp_len as f64);
+            red_resp_time.push(bob_perf_stat.resp_t.as_secs_f64());
+            red_resp_handle_time.push(bob_perf_stat.resp_handle_t.as_secs_f64());
+
+        }
+
+        println!("\n----WEIRD-OPEN-INVITATION----\n");
+        print_stats_test_results(
+            open_req_size,
+            open_req_time,
+            open_resp_size,
+            open_resp_time,
+            open_resp_handle_time,
+        );
+
+        println!("\n----WEIRD-TRUST-PROMOTION-1: 30 days----\n");
+        print_stats_test_results(
+            promo_req_size,
+            promo_req_time,
+            promo_resp_size,
+            promo_resp_time,
+            promo_resp_handle_time,
+        );
+
+        println!("\n----WEIRD-TRUST-MIGRATION-0: 30 days------------\n");
+        print_stats_test_results(
+            mig_req_size,
+            mig_req_time,
+            mig_resp_size,
+            mig_resp_time,
+            mig_resp_handle_time,
+        );
+
+        println!("\n----WEIRD-LEVEL-UP-2: 44 days----\n");
+        print_stats_test_results(
+            sec_req_size,
+            sec_req_time,
+            sec_resp_size,
+            sec_resp_time,
+            sec_resp_handle_time,
+        );
+
+        println!("\n----WEIRD-LEVEL-UP-3: 72 days------\n");
+        print_stats_test_results(
+            three_req_size,
+            three_req_time,
+            three_resp_size,
+            three_resp_time,
+            three_resp_handle_time,
+        );
+
+        println!("\n----WEIRD-LEVEL-UP-4: 128 days------\n");
+        print_stats_test_results(
+            four_req_size,
+            four_req_time,
+            four_resp_size,
+            four_resp_time,
+            four_resp_handle_time,
+        );
+        println!("\n----ISSUE-INVITATION----\n");
+        print_stats_test_results(req_size, req_time, resp_size, resp_time, resp_handle_time);
+        println!("\n----REDEEM-INVITATION----\n");
+        print_stats_test_results(
+          red_req_size,
+          red_req_time,
+          red_resp_size,
+          red_resp_time,
+          red_resp_handle_time,
+      );
+
+
+        block_bridges(&mut th, 10, credentials);
+    }
+}
+
+#[test]
+fn test_all(){
+    let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
+
+    for x in buckets {
+        println!("\n***START: {}*3*2 BUCKETS***\n", x);
+        stats_test_trust_levels(x);
+        stats_test_invitations(x);
+        stats_test_blockage_migration_5(x);
+        stats_test_blockage_migration_10(x);
+        stats_test_blockage_migration_15(x);
+        stats_test_blockage_migration_20(x);
+        stats_test_blockage_migration_25(x);
+        stats_test_blockage_migration_30(x);
+        stats_test_blockage_migration_35(x);
+        stats_test_blockage_migration_40(x);
+        stats_test_blockage_migration_45(x);
+        stats_test_blockage_migration_50(x);
+        stats_test_blockage_migration_55(x);
+        stats_test_blockage_migration_60(x);
+        stats_test_blockage_migration_65(x);
+        stats_test_blockage_migration_70(x);
+        stats_test_blockage_migration_75(x);
+        stats_test_blockage_migration_80(x);
+        stats_test_blockage_migration_85(x);
+        stats_test_blockage_migration_90(x);
+        stats_test_blockage_migration_95(x);
+        stats_test_blockage_migration_100(x);
+
+    }
+
+    let buckets2: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
+    for x in buckets2 {
+        println!("\n***START: {}*3*2 BUCKETS FOR WEIRD TEST***\n", x);
+        stats_test_blockage_migration_incremental_and_levels(x);
+
+    }
+
+    println!("\nAll done!\n");
+
+}
+
 /// Blocks a percentage of the bridges for the passed Test Harness
 /// excluding the hot spare buckets as they will not have been handed out.
 /// The logic assumes hot spare buckets are appended to the end of the bridge_table
@@ -1415,21 +1625,21 @@ fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred:
             red_resp_size.push(block_perf_stat.resp_len as f64);
             red_resp_time.push(block_perf_stat.resp_t.as_secs_f64());
             red_resp_handle_time.push(block_perf_stat.resp_handle_t.as_secs_f64());
-            println!("CHECK_BLOCKAGE_{}", percentage);
-            print_time_test_results(perf_stat);
-            println!("BLOCKAGE_MIGRATION_{}", percentage);
-            print_time_test_results(block_perf_stat);
+//            println!("CHECK_BLOCKAGE_{}", percentage);
+//            print_time_test_results(perf_stat);
+//            println!("BLOCKAGE_MIGRATION_{}", percentage);
+//            print_time_test_results(block_perf_stat);
         }
     }
 
     println!(
-        "\n---------------Check Blockage {}---------------\n",
+        "\n----CHECK-BLOCKAGE-{}----\n",
         percentage
     );
     print_stats_test_results(req_size, req_time, resp_size, resp_time, resp_handle_time);
 
     println!(
-        "\n---------------Blockage Migration {}---------------\n",
+        "\n----BLOCKAGE-MIGRATION-{}----\n",
         percentage
     );
     print_stats_test_results(
@@ -1441,6 +1651,7 @@ fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred:
     );
 }
 
+
 fn print_test_results(perf_stat: PerfStat) {
     println!("Request size = {:?} bytes", perf_stat.req_len);
     println!("Request time = {:?}", perf_stat.req_t);