diff --git a/crates/lox-library/src/tests.rs b/crates/lox-library/src/tests.rs index cebbe95..a2f87c3 100644 --- a/crates/lox-library/src/tests.rs +++ b/crates/lox-library/src/tests.rs @@ -380,11 +380,7 @@ fn test_open_invite() { let encbuckets = th.ba.enc_bridge_table(); let bucket = bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap(); - println!("Request size = {:?}", perf_stat.req_len); - println!("Request time = {:?}", perf_stat.req_t); - println!("Response size = {:?}", perf_stat.resp_len); - println!("Response time = {:?}", perf_stat.resp_t); - println!("Response handle time = {:?}", perf_stat.resp_handle_t); + print_test_results(perf_stat); println!("cred = {:?}", cred); println!("bucket = {:?}", bucket); println!("bridgeline = {:?}", bridgeline); @@ -412,11 +408,7 @@ fn test_trust_promotion() { let encbuckets = th.ba.enc_bridge_table(); let bucket = bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap(); - println!("Request size = {:?}", perf_stat.req_len); - println!("Request time = {:?}", perf_stat.req_t); - println!("Response size = {:?}", perf_stat.resp_len); - println!("Response time = {:?}", perf_stat.resp_t); - println!("Response handle time = {:?}", perf_stat.resp_handle_t); + print_test_results(perf_stat); println!("bucket = {:?}", bucket); assert!(th.ba.verify_reachability(&bucket.1.unwrap())); } @@ -433,37 +425,13 @@ fn test_level0_migration() { let (perf_stat, migcred) = th.trust_promotion(&cred); assert!(th.ba.verify_migration(&migcred)); - println!( - "Trust Promotion to 1 Request size = {:?}", - perf_stat.req_len - ); - println!("Trust Promotion to 1 Request time = {:?}", perf_stat.req_t); - println!( - "Trust Promotion to 1 Response size = {:?}", - perf_stat.resp_len - ); - println!( - "Trust Promotion to 1 Response time = {:?}", - perf_stat.resp_t - ); - println!( - "Trust Promotion to 1 Response handle time = {:?}", - perf_stat.resp_handle_t - ); + println!("--Trust Promotion to 1--\n"); + print_test_results(perf_stat); let (mperf_stat, newloxcred) = th.level0_migration(&cred, &migcred); - println!("Level 0 migration Request size = {:?}", mperf_stat.req_len); - println!("Level 0 migration Request time = {:?}", mperf_stat.req_t); - println!( - "Level 0 migration Response size = {:?}", - mperf_stat.resp_len - ); - println!("Level 0 migration Response time = {:?}", mperf_stat.resp_t); - println!( - "Level 0 migration Response handle time = {:?}", - perf_stat.resp_handle_t - ); + println!("--Level 0 migration--\n"); + print_test_results(mperf_stat); assert!(th.ba.verify_lox(&newloxcred)); println!("newloxcred = {:?}", newloxcred); @@ -488,46 +456,14 @@ fn test_level_up() { // Go up to level 1 let (perf_stat, migcred) = th.trust_promotion(&cred); - println!( - "Trust Promotion to 1 Request size = {:?}", - perf_stat.req_len - ); - println!("Trust Promotion to 1 Request time = {:?}", perf_stat.req_t); - println!( - "Trust Promotion to 1 Response size = {:?}", - perf_stat.resp_len - ); - println!( - "Trust Promotion to 1 Response time = {:?}", - perf_stat.resp_t - ); - println!( - "Trust Promotion to 1 Response handle time = {:?}", - perf_stat.resp_handle_t - ); + + println!("--Trust Promotion to 1--\n"); + print_test_results(perf_stat); let (mperf_stat, cred1) = th.level0_migration(&cred, &migcred); - println!( - "New Level 1 credential Request size = {:?}", - mperf_stat.req_len - ); - println!( - "New Level 1 credential Request time = {:?}", - mperf_stat.req_t - ); - println!( - "New Level 1 credential Response size = {:?}", - mperf_stat.resp_len - ); - println!( - "New Level 1 credential Response time = {:?}", - mperf_stat.resp_t - ); - println!( - "New Level 1 credential Response handle time = {:?}", - perf_stat.resp_handle_t - ); + println!("--New Level 1 Credential--\n"); + print_test_results(mperf_stat); assert!(scalar_u32(&cred1.trust_level).unwrap() == 1); @@ -536,27 +472,10 @@ fn test_level_up() { let (two_perf_stat, cred2) = th.level_up(&cred1); assert!(scalar_u32(&cred2.trust_level).unwrap() == 2); + + println!("--Upgrade to Level 2--\n"); + print_test_results(two_perf_stat); println!("cred2 = {:?}", cred2); - println!( - "Trust Promotion to 2 Request size = {:?}", - two_perf_stat.req_len - ); - println!( - "Trust Promotion to 2 Request time = {:?}", - two_perf_stat.req_t - ); - println!( - "Trust Promotion to 2 Response size = {:?}", - two_perf_stat.resp_len - ); - println!( - "Trust Promotion to 2 Response time = {:?}", - two_perf_stat.resp_t - ); - println!( - "Trust Promotion to 2 Response handle time = {:?}", - two_perf_stat.resp_handle_t - ); assert!(th.ba.verify_lox(&cred2)); // Time passes @@ -564,27 +483,9 @@ fn test_level_up() { let (three_perf_stat, cred3) = th.level_up(&cred2); assert!(scalar_u32(&cred3.trust_level).unwrap() == 3); + println!("--Upgrade to Level 3--\n"); + print_test_results(three_perf_stat); println!("cred3 = {:?}", cred3); - println!( - "Trust Promotion to 3 Request size = {:?}", - three_perf_stat.req_len - ); - println!( - "Trust Promotion to 3 Request time = {:?}", - three_perf_stat.req_t - ); - println!( - "Trust Promotion to 3 Response size = {:?}", - three_perf_stat.resp_len - ); - println!( - "Trust Promotion to 3 Response time = {:?}", - three_perf_stat.resp_t - ); - println!( - "Trust Promotion to 3 Response handle time = {:?}", - three_perf_stat.resp_handle_t - ); assert!(th.ba.verify_lox(&cred3)); // Time passes @@ -592,27 +493,9 @@ fn test_level_up() { let (four_perf_stat, cred4) = th.level_up(&cred3); assert!(scalar_u32(&cred3.trust_level).unwrap() == 3); + println!("--Upgrade to Level 4--\n"); + print_test_results(four_perf_stat); println!("cred4 = {:?}", cred4); - println!( - "Trust Promotion to 4 Request size = {:?}", - four_perf_stat.req_len - ); - println!( - "Trust Promotion to 4 Request time = {:?}", - four_perf_stat.req_t - ); - println!( - "Trust Promotion to 4 Response size = {:?}", - four_perf_stat.resp_len - ); - println!( - "Trust Promotion to 4 Response time = {:?}", - four_perf_stat.resp_t - ); - println!( - "Trust Promotion to 4 Response handle time = {:?}", - four_perf_stat.resp_handle_t - ); assert!(th.ba.verify_lox(&cred4)); } @@ -627,21 +510,29 @@ fn test_issue_invite() { th.advance_days(47); // Go up to level 1 - let (_perf_stat, migcred) = th.trust_promotion(&cred); - let (_mperf_stat, cred1) = th.level0_migration(&cred, &migcred); + let (perf_stat, migcred) = th.trust_promotion(&cred); + println!("--Trust Promotion to 1--\n"); + print_test_results(perf_stat); + let (mperf_stat, cred1) = th.level0_migration(&cred, &migcred); + println!("--New Level 1 Credential--\n"); + print_test_results(mperf_stat); assert!(scalar_u32(&cred1.trust_level).unwrap() == 1); // Time passes th.advance_days(20); // Go up to level 2 - let (_two_perf_stat, cred2) = th.level_up(&cred1); + let (two_perf_stat, cred2) = th.level_up(&cred1); + println!("--Upgrade to Level 2--\n"); + print_test_results(two_perf_stat); assert!(scalar_u32(&cred2.trust_level).unwrap() == 2); println!("cred2 = {:?}", cred2); assert!(th.ba.verify_lox(&cred2)); // Issue an invitation - let (_invite_perf_stat, (cred2a, invite)) = th.issue_invite(&cred2); + let (invite_perf_stat, (cred2a, invite)) = th.issue_invite(&cred2); + println!("--Issue Invitation--\n"); + print_test_results(invite_perf_stat); assert!(th.ba.verify_lox(&cred2a)); assert!(th.ba.verify_invitation(&invite)); println!("cred2a = {:?}", cred2a); @@ -659,21 +550,29 @@ fn test_redeem_invite() { th.advance_days(47); // Go up to level 1 - let (_perf_stat, migcred) = th.trust_promotion(&cred); - let (_one_perf_stat, cred1) = th.level0_migration(&cred, &migcred); + let (perf_stat, migcred) = th.trust_promotion(&cred); + println!("--Trust Promotion to 1--\n"); + print_test_results(perf_stat); + let (mperf_stat, cred1) = th.level0_migration(&cred, &migcred); + println!("--New Level 1 Credential--\n"); + print_test_results(mperf_stat); assert!(scalar_u32(&cred1.trust_level).unwrap() == 1); // Time passes th.advance_days(20); // Go up to level 2 - let (_two_perf_stat, cred2) = th.level_up(&cred1); + let (two_perf_stat, cred2) = th.level_up(&cred1); + println!("--Upgrade to Level 2--\n"); + print_test_results(two_perf_stat); assert!(scalar_u32(&cred2.trust_level).unwrap() == 2); println!("cred2 = {:?}", cred2); assert!(th.ba.verify_lox(&cred2)); // Issue an invitation to Bob - let (_invite_perf_stat, (cred2a, bob_invite)) = th.issue_invite(&cred2); + let (invite_perf_stat, (cred2a, bob_invite)) = th.issue_invite(&cred2); + println!("--Issue Invitation--\n"); + print_test_results(invite_perf_stat); assert!(th.ba.verify_lox(&cred2a)); assert!(th.ba.verify_invitation(&bob_invite)); println!("cred2a = {:?}", cred2a); @@ -683,7 +582,9 @@ fn test_redeem_invite() { th.advance_days(12); // Bob joins the system - let (_bob_perf_stat, bob_cred) = th.redeem_invite(&bob_invite); + let (bob_perf_stat, bob_cred) = th.redeem_invite(&bob_invite); + println!("--Bob joins the system--\n"); + print_test_results(bob_perf_stat); assert!(th.ba.verify_lox(&bob_cred)); println!("bob_cred = {:?}", bob_cred); } @@ -810,8 +711,10 @@ fn test_blockage_migration() { } #[test] -fn protocol_tests() { +fn stats_test_open_invite() { let mut th = TestHarness::new_buckets(10, 10); + + println!("\n---------------Open Invitationn-------------------\n"); let mut req_size: Vec = Vec::new(); let mut resp_size: Vec = Vec::new(); let mut req_t_size: Vec = Vec::new(); @@ -825,6 +728,234 @@ fn protocol_tests() { resp_t_size.push(perf_stat.resp_t.as_secs_f64()); resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64()); } + + print_stats_test_results( + req_size, + req_t_size, + resp_size, + resp_t_size, + resp_handle_t_size, + ); +} + +#[test] +fn stats_test_trust_promotion() { + let mut th = TestHarness::new_buckets(10, 10); + println!("\n-------Trust Promotion--------\n"); + + let mut req_size: Vec = Vec::new(); + let mut resp_size: Vec = Vec::new(); + let mut req_t_size: Vec = Vec::new(); + let mut resp_t_size: Vec = Vec::new(); + let mut resp_handle_t_size: Vec = Vec::new(); + for _ in 0..1000 { + let cred = th.open_invite().1 .0; + th.advance_days(47); + let (perf_stat, _) = th.trust_promotion(&cred); + req_size.push(perf_stat.req_len as f64); + req_t_size.push(perf_stat.req_t.as_secs_f64()); + resp_size.push(perf_stat.resp_len as f64); + resp_t_size.push(perf_stat.resp_t.as_secs_f64()); + resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64()); + } + + print_stats_test_results( + req_size, + req_t_size, + resp_size, + resp_t_size, + resp_handle_t_size, + ); +} + +#[test] +fn stats_test_trust_level0_migration() { + let mut th = TestHarness::new_buckets(10, 10); + + println!("\n-------------Trust Level0 Migration----------------\n"); + let mut req_size: Vec = Vec::new(); + let mut resp_size: Vec = Vec::new(); + let mut req_t_size: Vec = Vec::new(); + let mut resp_t_size: Vec = Vec::new(); + let mut resp_handle_t_size: Vec = Vec::new(); + let mut tot_req_size: Vec = Vec::new(); + let mut tot_resp_size: Vec = Vec::new(); + let mut tot_req_t_size: Vec = Vec::new(); + let mut tot_resp_t_size: Vec = Vec::new(); + let mut tot_resp_handle_t_size: Vec = Vec::new(); + for _ in 0..1000 { + let cred = th.open_invite().1 .0; + th.advance_days(47); + let (tp_perf_stat, migcred) = th.trust_promotion(&cred); + let (perf_stat, _) = th.level0_migration(&cred, &migcred); + req_size.push(perf_stat.req_len as f64); + req_t_size.push(perf_stat.req_t.as_secs_f64()); + resp_size.push(perf_stat.resp_len as f64); + resp_t_size.push(perf_stat.resp_t.as_secs_f64()); + resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64()); + tot_req_size.push((perf_stat.req_len + tp_perf_stat.req_len) as f64); + tot_req_t_size.push((perf_stat.req_t + tp_perf_stat.req_t).as_secs_f64()); + tot_resp_size.push((perf_stat.resp_len + tp_perf_stat.resp_len) as f64); + tot_resp_t_size.push((perf_stat.resp_t + tp_perf_stat.resp_t).as_secs_f64()); + tot_resp_handle_t_size + .push((perf_stat.resp_handle_t + tp_perf_stat.resp_handle_t).as_secs_f64()); + } + + print_stats_test_results( + req_size, + req_t_size, + resp_size, + resp_t_size, + resp_handle_t_size, + ); + + println!("\n-------Total Trust Promotion to Level 1-------\n"); + print_stats_test_results( + tot_req_size, + tot_req_t_size, + tot_resp_size, + tot_resp_t_size, + tot_resp_handle_t_size, + ); +} + + +#[test] +fn stats_test_trust_level_up() { + let mut th = TestHarness::new_buckets(10, 10); + + println!("\n-------------Trust Level0 Migration----------------\n"); + let mut req_size: Vec = Vec::new(); + let mut resp_size: Vec = Vec::new(); + let mut req_t_size: Vec = Vec::new(); + let mut resp_t_size: Vec = Vec::new(); + let mut resp_handle_t_size: Vec = Vec::new(); + let mut tot_req_size: Vec = Vec::new(); + let mut tot_resp_size: Vec = Vec::new(); + let mut tot_req_t_size: Vec = Vec::new(); + let mut tot_resp_t_size: Vec = Vec::new(); + let mut tot_resp_handle_t_size: Vec = Vec::new(); + for _ in 0..1000 { + let cred = th.open_invite().1 .0; + th.advance_days(47); + let (tp_perf_stat, migcred) = th.trust_promotion(&cred); + let (perf_stat, cred1) = th.level0_migration(&cred, &migcred); + th.advance_days(20); + let (two_perf_stat, cred2) = th.level_up(&cred1); + th.advance_days(30); + let (three_perf_stat, cred3) = th.level_up(&cred2); + th.advance_days(60); + let (four_perf_stat, cred3) = th.level_up(&cred2); + req_size.push(perf_stat.req_len as f64); + req_t_size.push(perf_stat.req_t.as_secs_f64()); + resp_size.push(perf_stat.resp_len as f64); + resp_t_size.push(perf_stat.resp_t.as_secs_f64()); + resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64()); + tot_req_size.push((perf_stat.req_len + tp_perf_stat.req_len) as f64); + tot_req_t_size.push((perf_stat.req_t + tp_perf_stat.req_t).as_secs_f64()); + tot_resp_size.push((perf_stat.resp_len + tp_perf_stat.resp_len) as f64); + tot_resp_t_size.push((perf_stat.resp_t + tp_perf_stat.resp_t).as_secs_f64()); + tot_resp_handle_t_size + .push((perf_stat.resp_handle_t + tp_perf_stat.resp_handle_t).as_secs_f64()); + } + + print_stats_test_results( + req_size, + req_t_size, + resp_size, + resp_t_size, + resp_handle_t_size, + ); + + println!("\n-------Total Trust Promotion to Level 1-------\n"); + print_stats_test_results( + tot_req_size, + tot_req_t_size, + tot_resp_size, + tot_resp_t_size, + tot_resp_handle_t_size, + ); +} +#[test] +fn stats_test_blocked_bridges() { + let mut th = TestHarness::new_buckets(10, 10); + println!("\n-------Trust Promotion With Blocked Bridges--------\n"); + + let mut req_size_b: Vec = Vec::new(); + let mut resp_size_b: Vec = Vec::new(); + let mut req_t_size_b: Vec = Vec::new(); + let mut resp_t_size_b: Vec = Vec::new(); + let mut resp_handle_t_size_b: Vec = Vec::new(); + for _ in 0..1000 { + let cred = th.open_invite().1 .0; + th.advance_days(47); + let (perf_stat, migcred) = th.trust_promotion(&cred); + req_size_b.push(perf_stat.req_len as f64); + req_t_size_b.push(perf_stat.req_t.as_secs_f64()); + resp_size_b.push(perf_stat.resp_len as f64); + resp_t_size_b.push(perf_stat.resp_t.as_secs_f64()); + resp_handle_t_size_b.push(perf_stat.resp_handle_t.as_secs_f64()); + } + + // Mark 5 bridges in untrusted buckets as unreachable + for i in 0..50 { + if i % 2 == 0 { + let b0 = th.ba.bridge_table.buckets[i][0]; + th.ba.bridge_unreachable(&b0, &mut th.bdb); + } + } + + print_stats_test_results( + req_size_b, + req_t_size_b, + resp_size_b, + resp_t_size_b, + resp_handle_t_size_b, + ); +} + +#[test] +fn stats_test_something_else_test() { + let mut th = TestHarness::new_buckets(10, 10); + println!("\n---------------Block Bridges-------------------\n"); + + let mut req_size2: Vec = Vec::new(); + let mut resp_size2: Vec = Vec::new(); + let mut req_t_size2: Vec = Vec::new(); + let mut resp_t_size2: Vec = Vec::new(); + let mut resp_handle_t_size2: Vec = Vec::new(); + for _ in 0..1000 { + let (perf_stat2, _) = th.open_invite(); + req_size2.push(perf_stat2.req_len as f64); + req_t_size2.push(perf_stat2.req_t.as_secs_f64()); + resp_size2.push(perf_stat2.resp_len as f64); + resp_t_size2.push(perf_stat2.resp_t.as_secs_f64()); + resp_handle_t_size2.push(perf_stat2.resp_handle_t.as_secs_f64()); + } + print_stats_test_results( + req_size2, + req_t_size2, + resp_size2, + resp_t_size2, + resp_handle_t_size2, + ); +} + +fn print_test_results(perf_stat: PerfStat) { + println!("Request size = {:?}", perf_stat.req_len); + println!("Request time = {:?}", perf_stat.req_t); + println!("Response size = {:?}", perf_stat.resp_len); + println!("Response time = {:?}", perf_stat.resp_t); + println!("Response handle time = {:?}", perf_stat.resp_handle_t); +} + +fn print_stats_test_results( + req_size: Vec, + req_t_size: Vec, + resp_size: Vec, + resp_t_size: Vec, + resp_handle_t_size: Vec, +) { let mean_req_size = mean(&req_size); let req_std_dev = standard_deviation(&req_size, Some(mean_req_size)); let mean_req_t_size = mean(&req_t_size); @@ -837,7 +968,7 @@ fn protocol_tests() { let resp_handle_t_std_dev = standard_deviation(&resp_handle_t_size, Some(mean_resp_handle_t_size)); - println!("Average Request Size = {}", mean_req_size); + println!("Average Request size = {}", mean_req_size); println!("Request Standard Deviation = {}", req_std_dev); println!( "Average Request Time = {:?}", @@ -847,7 +978,7 @@ fn protocol_tests() { "Request time Standard Deviation = {:?}", Duration::from_secs_f64(req_t_std_dev) ); - println!("Average Response Size = {}", mean_resp_size); + println!("Average Response size = {}", mean_resp_size); println!("Response Standard Deviation = {}", resp_std_dev); println!( "Average Response Time = {:?}", @@ -865,76 +996,4 @@ fn protocol_tests() { "Response Handling Time Standard Deviation = {:?}", Duration::from_secs_f64(resp_handle_t_std_dev) ); - - println!("\n---------------Block Bridges-------------------\n"); - - // Mark 5 bridges in untrusted buckets as unreachable - let b0 = th.ba.bridge_table.buckets[0][0]; - th.ba.bridge_unreachable(&b0, &mut th.bdb); - - let b3 = th.ba.bridge_table.buckets[3][0]; - th.ba.bridge_unreachable(&b3, &mut th.bdb); - - let b6 = th.ba.bridge_table.buckets[6][0]; - th.ba.bridge_unreachable(&b6, &mut th.bdb); - - let b9 = th.ba.bridge_table.buckets[9][0]; - th.ba.bridge_unreachable(&b9, &mut th.bdb); - - let b12 = th.ba.bridge_table.buckets[12][0]; - th.ba.bridge_unreachable(&b12, &mut th.bdb); - - let mut req_size2: Vec = Vec::new(); - let mut resp_size2: Vec = Vec::new(); - let mut req_t_size2: Vec = Vec::new(); - let mut resp_t_size2: Vec = Vec::new(); - let mut resp_handle_t_size2: Vec = Vec::new(); - for _ in 0..1000 { - let (perf_stat2, _) = th.open_invite(); - req_size2.push(perf_stat2.req_len as f64); - req_t_size2.push(perf_stat2.req_t.as_secs_f64()); - resp_size2.push(perf_stat2.resp_len as f64); - resp_t_size2.push(perf_stat2.resp_t.as_secs_f64()); - resp_handle_t_size2.push(perf_stat2.resp_handle_t.as_secs_f64()); - } - let mean_req_size2 = mean(&req_size2); - let req_std_dev2 = standard_deviation(&req_size2, Some(mean_req_size2)); - let mean_req_t_size2 = mean(&req_t_size2); - let req_t_std_dev2 = standard_deviation(&req_t_size2, Some(mean_req_t_size2)); - let mean_resp_size2 = mean(&resp_size2); - let resp_std_dev2 = standard_deviation(&resp_size2, Some(mean_resp_size2)); - let mean_resp_t_size2 = mean(&resp_t_size2); - let resp_t_std_dev2 = standard_deviation(&resp_t_size2, Some(mean_resp_t_size2)); - let mean_resp_handle_t_size2 = mean(&resp_t_size2); - let resp_handle_t_std_dev2 = - standard_deviation(&resp_handle_t_size2, Some(mean_resp_handle_t_size2)); - - println!("Average Request size = {}", mean_req_size2); - println!("Request Standard Deviation = {}", req_std_dev2); - println!( - "Average Request Time = {:?}", - Duration::from_secs_f64(mean_req_t_size) - ); - println!( - "Request time Standard Deviation = {:?}", - Duration::from_secs_f64(req_t_std_dev2) - ); - println!("Average Response size = {}", mean_resp_size2); - println!("Response Standard Deviation = {}", resp_std_dev2); - println!( - "Average Response Time = {:?}", - Duration::from_secs_f64(mean_resp_t_size2) - ); - println!( - "Response Time Standard Deviation = {:?}", - Duration::from_secs_f64(resp_t_std_dev2) - ); - println!( - "Average Response Handling Time = {:?}", - Duration::from_secs_f64(mean_resp_handle_t_size2) - ); - println!( - "Response Handling Time Standard Deviation = {:?}", - Duration::from_secs_f64(resp_handle_t_std_dev2) - ); }