diff --git a/crates/lox-library/src/tests.rs b/crates/lox-library/src/tests.rs index 0b21dd3..660452d 100644 --- a/crates/lox-library/src/tests.rs +++ b/crates/lox-library/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 = Vec::new(); let mut promo_resp_size: Vec = 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 = Vec::new(); let mut resp_size: Vec = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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(); + 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 = 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 = 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