diff --git a/crates/lox-library/src/tests.rs b/crates/lox-library/src/tests.rs index 660452d..17450e2 100644 --- a/crates/lox-library/src/tests.rs +++ b/crates/lox-library/src/tests.rs @@ -712,685 +712,43 @@ fn test_blockage_migration() { assert!(th.ba.verify_lox(&cred4)); } -//#[test] -fn stats_test_trust_levels(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); +#[test] +fn stats_test_trust_levels() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; - let mut promo_req_size: Vec = Vec::new(); - let mut promo_resp_size: Vec = Vec::new(); - let mut promo_req_time: Vec = Vec::new(); - let mut promo_resp_time: Vec = Vec::new(); - let mut promo_resp_handle_time: Vec = Vec::new(); - let mut mig_req_size: Vec = Vec::new(); - let mut mig_resp_size: Vec = Vec::new(); - let mut mig_req_time: Vec = Vec::new(); - let mut mig_resp_time: Vec = Vec::new(); - let mut mig_resp_handle_time: Vec = Vec::new(); - let mut sec_req_size: Vec = Vec::new(); - let mut sec_resp_size: Vec = Vec::new(); - let mut sec_req_time: Vec = Vec::new(); - let mut sec_resp_time: Vec = Vec::new(); - let mut sec_resp_handle_time: Vec = Vec::new(); - let mut three_req_size: Vec = Vec::new(); - let mut three_resp_size: Vec = Vec::new(); - let mut three_req_time: Vec = Vec::new(); - let mut three_resp_time: Vec = Vec::new(); - let mut three_resp_handle_time: Vec = Vec::new(); - let mut four_req_size: Vec = Vec::new(); - let mut four_resp_size: Vec = Vec::new(); - let mut four_req_time: Vec = Vec::new(); - let mut four_resp_time: Vec = Vec::new(); - let mut four_resp_handle_time: Vec = Vec::new(); - let mut open_req_size: Vec = Vec::new(); - let mut open_resp_size: Vec = Vec::new(); - let mut open_req_time: Vec = Vec::new(); - let mut open_resp_time: Vec = Vec::new(); - let mut open_resp_handle_time: Vec = 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); - th.advance_days(28); - let (three_perf_stat, cred3) = th.level_up(&cred2); - th.advance_days(56); - let (four_perf_stat, _) = th.level_up(&cred3); - 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()); - // 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); - } + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); - println!("\n----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----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----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----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----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----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, - ); -} - -//#[test] -fn stats_test_invitations(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - - let mut req_size: Vec = Vec::new(); - let mut resp_size: Vec = Vec::new(); - let mut req_time: Vec = Vec::new(); - let mut resp_time: Vec = Vec::new(); - let mut resp_handle_time: Vec = Vec::new(); - let mut red_req_size: Vec = Vec::new(); - let mut red_resp_size: Vec = Vec::new(); - let mut red_req_time: Vec = Vec::new(); - let mut red_resp_time: Vec = Vec::new(); - let mut red_resp_handle_time: Vec = Vec::new(); - for _ in 0..10000 { - 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 (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_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----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, - ); -} - -//#[test] -fn stats_test_blockage_migration_5(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = 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(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = 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(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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); -} - -//#[test] -fn stats_test_blockage_migration_45(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 45, credentials); -} - -//#[test] -fn stats_test_blockage_migration_50(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 50, credentials); -} - -//#[test] -fn stats_test_blockage_migration_55(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 55, credentials); -} - -//#[test] -fn stats_test_blockage_migration_60(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 60, credentials); -} - -//#[test] -fn stats_test_blockage_migration_65(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 65, credentials); -} - -//#[test] -fn stats_test_blockage_migration_70(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 70, credentials); -} - -//#[test] -fn stats_test_blockage_migration_75(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 75, credentials); -} - -//#[test] -fn stats_test_blockage_migration_80(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 80, credentials); -} - -//#[test] -fn stats_test_blockage_migration_85(buckets: u16) { - let mut th = TestHarness::new_buckets(buckets, buckets); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 85, credentials); -} - -//#[test] -fn stats_test_blockage_migration_90(bucket: u16) { - let mut th = TestHarness::new_buckets(bucket, bucket); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 90, credentials); -} - -//#[test] -fn stats_test_blockage_migration_95(bucket: u16) { - let mut th = TestHarness::new_buckets(bucket, bucket); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 95, credentials); -} - -//#[test] -fn stats_test_blockage_migration_100(bucket: u16) { - let mut th = TestHarness::new_buckets(bucket, bucket); - let mut credentials: Vec = Vec::new(); - for _ in 0..10000 { - 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, 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 = Vec::new(); - let mut resp_size: Vec = Vec::new(); - let mut req_time: Vec = Vec::new(); - let mut resp_time: Vec = Vec::new(); - let mut resp_handle_time: Vec = Vec::new(); - let mut red_req_size: Vec = Vec::new(); - let mut red_resp_size: Vec = Vec::new(); - let mut red_req_time: Vec = Vec::new(); - let mut red_resp_time: Vec = Vec::new(); - let mut red_resp_handle_time: Vec = Vec::new(); - let mut promo_req_size: Vec = Vec::new(); - let mut promo_resp_size: Vec = Vec::new(); - let mut promo_req_time: Vec = Vec::new(); - let mut promo_resp_time: Vec = Vec::new(); - let mut promo_resp_handle_time: Vec = Vec::new(); - let mut mig_req_size: Vec = Vec::new(); - let mut mig_resp_size: Vec = Vec::new(); - let mut mig_req_time: Vec = Vec::new(); - let mut mig_resp_time: Vec = Vec::new(); - let mut mig_resp_handle_time: Vec = Vec::new(); - let mut sec_req_size: Vec = Vec::new(); - let mut sec_resp_size: Vec = Vec::new(); - let mut sec_req_time: Vec = Vec::new(); - let mut sec_resp_time: Vec = Vec::new(); - let mut sec_resp_handle_time: Vec = Vec::new(); - let mut three_req_size: Vec = Vec::new(); - let mut three_resp_size: Vec = Vec::new(); - let mut three_req_time: Vec = Vec::new(); - let mut three_resp_time: Vec = Vec::new(); - let mut three_resp_handle_time: Vec = Vec::new(); - let mut four_req_size: Vec = Vec::new(); - let mut four_resp_size: Vec = Vec::new(); - let mut four_req_time: Vec = Vec::new(); - let mut four_resp_time: Vec = Vec::new(); - let mut four_resp_handle_time: Vec = Vec::new(); - let mut open_req_size: Vec = Vec::new(); - let mut open_resp_size: Vec = Vec::new(); - let mut open_req_time: Vec = Vec::new(); - let mut open_resp_time: Vec = Vec::new(); - let mut open_resp_handle_time: Vec = Vec::new(); - let mut credentials: Vec = Vec::new(); + let mut promo_req_size: Vec = Vec::new(); + let mut promo_resp_size: Vec = Vec::new(); + let mut promo_req_time: Vec = Vec::new(); + let mut promo_resp_time: Vec = Vec::new(); + let mut promo_resp_handle_time: Vec = Vec::new(); + let mut mig_req_size: Vec = Vec::new(); + let mut mig_resp_size: Vec = Vec::new(); + let mut mig_req_time: Vec = Vec::new(); + let mut mig_resp_time: Vec = Vec::new(); + let mut mig_resp_handle_time: Vec = Vec::new(); + let mut sec_req_size: Vec = Vec::new(); + let mut sec_resp_size: Vec = Vec::new(); + let mut sec_req_time: Vec = Vec::new(); + let mut sec_resp_time: Vec = Vec::new(); + let mut sec_resp_handle_time: Vec = Vec::new(); + let mut three_req_size: Vec = Vec::new(); + let mut three_resp_size: Vec = Vec::new(); + let mut three_req_time: Vec = Vec::new(); + let mut three_resp_time: Vec = Vec::new(); + let mut three_resp_handle_time: Vec = Vec::new(); + let mut four_req_size: Vec = Vec::new(); + let mut four_resp_size: Vec = Vec::new(); + let mut four_req_time: Vec = Vec::new(); + let mut four_resp_time: Vec = Vec::new(); + let mut four_resp_handle_time: Vec = Vec::new(); + let mut open_req_size: Vec = Vec::new(); + let mut open_resp_size: Vec = Vec::new(); + let mut open_req_time: Vec = Vec::new(); + let mut open_resp_time: Vec = Vec::new(); + let mut open_resp_handle_time: Vec = Vec::new(); for _ in 0..10000 { let (open_perf_stat, cred) = th.open_invite(); th.advance_days(30); @@ -1398,13 +756,10 @@ fn stats_test_blockage_migration_incremental_and_levels(buckets: u16) { 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); + let (three_perf_stat, cred3) = th.level_up(&cred2); th.advance_days(56); - let (four_perf_stat, cred4) = th.level_up(&cred3); - credentials.push(cred4); + let (four_perf_stat, _) = th.level_up(&cred3); 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); @@ -1435,6 +790,92 @@ fn stats_test_blockage_migration_incremental_and_levels(buckets: u16) { 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!("\n***START: {}*3*2 BUCKETS LEVELS***\n", x); + println!("\n----OPEN-INVITATION-{}---\n", x); + print_stats_test_results( + open_req_size, + open_req_time, + open_resp_size, + open_resp_time, + open_resp_handle_time, + ); + + println!("\n----TRUST-PROMOTION-1: 30 days-{}---\n", x); + print_stats_test_results( + promo_req_size, + promo_req_time, + promo_resp_size, + promo_resp_time, + promo_resp_handle_time, + ); + + println!("\n----TRUST-MIGRATION-0: 30 days-{}---\n", x); + print_stats_test_results( + mig_req_size, + mig_req_time, + mig_resp_size, + mig_resp_time, + mig_resp_handle_time, + ); + + println!("\n----LEVEL-UP-2: 44 days-{}---\n", x); + print_stats_test_results( + sec_req_size, + sec_req_time, + sec_resp_size, + sec_resp_time, + sec_resp_handle_time, + ); + + println!("\n----LEVEL-UP-3: 72 days---{}---\n", x); + print_stats_test_results( + three_req_size, + three_req_time, + three_resp_size, + three_resp_time, + three_resp_handle_time, + ); + + println!("\n----LEVEL-UP-4: 128 days---{}---\n", x); + print_stats_test_results( + four_req_size, + four_req_time, + four_resp_size, + four_resp_time, + four_resp_handle_time, + ); + } +} + +#[test] +fn stats_test_invitations() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + + let mut req_size: Vec = Vec::new(); + let mut resp_size: Vec = Vec::new(); + let mut req_time: Vec = Vec::new(); + let mut resp_time: Vec = Vec::new(); + let mut resp_handle_time: Vec = Vec::new(); + let mut red_req_size: Vec = Vec::new(); + let mut red_resp_size: Vec = Vec::new(); + let mut red_req_time: Vec = Vec::new(); + let mut red_resp_time: Vec = Vec::new(); + let mut red_resp_handle_time: Vec = Vec::new(); + for _ in 0..10000 { + 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 (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_time.push(perf_stat.req_t.as_secs_f64()); resp_size.push(perf_stat.resp_len as f64); @@ -1445,118 +886,560 @@ fn stats_test_blockage_migration_incremental_and_levels(buckets: u16) { 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"); + println!("\n***START: {}*3*2 BUCKETS INVITATIONS***\n", x); + println!("\n----ISSUE-INVITATION-{}---\n", x); 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", x); print_stats_test_results( - red_req_size, - red_req_time, - red_resp_size, - red_resp_time, - red_resp_handle_time, - ); + red_req_size, + red_req_time, + red_resp_size, + red_resp_time, + red_resp_handle_time, + ); + } +} +#[test] +fn stats_test_blockage_migration_5() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = 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); + } + + println!("\n***START: {}*3*2 BUCKETS 5***\n", x); + block_bridges(&mut th, 5, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_10() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = 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); + } + + println!("\n***START: {}*3*2 BUCKETS 10***\n", x); block_bridges(&mut th, 10, credentials); } } #[test] -fn test_all(){ +fn stats_test_blockage_migration_15() { let buckets: Vec = 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 mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + println!("\n***START: {}*3*2 BUCKETS 15***\n", x); + block_bridges(&mut th, 15, credentials); } +} - let buckets2: Vec = 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); +#[test] +fn stats_test_blockage_migration_20() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 20***\n", x); + block_bridges(&mut th, 20, credentials); } +} - println!("\nAll done!\n"); +#[test] +fn stats_test_blockage_migration_25() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 25***\n", x); + block_bridges(&mut th, 25, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_30() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 30***\n", x); + block_bridges(&mut th, 30, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_35() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 35***\n", x); + block_bridges(&mut th, 35, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_40() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 40***\n", x); + block_bridges(&mut th, 40, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_45() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 45***\n", x); + block_bridges(&mut th, 45, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_50() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 50***\n", x); + block_bridges(&mut th, 50, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_55() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 55***\n", x); + block_bridges(&mut th, 55, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_60() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 60***\n", x); + block_bridges(&mut th, 60, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_65() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 65***\n", x); + block_bridges(&mut th, 65, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_70() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 70***\n", x); + block_bridges(&mut th, 70, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_75() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 75***\n", x); + block_bridges(&mut th, 75, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_80() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 80***\n", x); + block_bridges(&mut th, 80, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_85() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 85***\n", x); + block_bridges(&mut th, 85, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_90() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 90***\n", x); + block_bridges(&mut th, 90, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_95() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + + println!("\n***START: {}*3*2 BUCKETS 95***\n", x); + block_bridges(&mut th, 95, credentials); + } +} + +#[test] +fn stats_test_blockage_migration_100() { + let buckets: Vec = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500]; + + for x in buckets { + let mut th = TestHarness::new_buckets(x, x); + let mut credentials: Vec = Vec::new(); + for _ in 0..10000 { + 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); + } + println!("\n***START: {}*3*2 BUCKETS 100***\n", x); + block_bridges(&mut th, 100, credentials); + } } /// Blocks a percentage of the bridges for the passed Test Harness @@ -1625,23 +1508,13 @@ fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec