vecna
/
lox
mirror of https://gitlab.torproject.org/vecna/lox.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Modularized duplicate code and added more tests

This commit is contained in:
onyinyang 2021-06-22 14:43:15 -04:00
parent f1ba7e8066
commit e504c6ce37
1 changed files with 278 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

497
crates/lox-library/src/tests.rs
View File

@ -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<f64> = Vec::new();
let mut resp_size: Vec<f64> = Vec::new();
let mut req_t_size: Vec<f64> = 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<f64> = Vec::new();
let mut resp_size: Vec<f64> = Vec::new();
let mut req_t_size: Vec<f64> = Vec::new();
let mut resp_t_size: Vec<f64> = Vec::new();
let mut resp_handle_t_size: Vec<f64> = 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<f64> = Vec::new();
let mut resp_size: Vec<f64> = Vec::new();
let mut req_t_size: Vec<f64> = Vec::new();
let mut resp_t_size: Vec<f64> = Vec::new();
let mut resp_handle_t_size: Vec<f64> = Vec::new();
let mut tot_req_size: Vec<f64> = Vec::new();
let mut tot_resp_size: Vec<f64> = Vec::new();
let mut tot_req_t_size: Vec<f64> = Vec::new();
let mut tot_resp_t_size: Vec<f64> = Vec::new();
let mut tot_resp_handle_t_size: Vec<f64> = 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<f64> = Vec::new();
let mut resp_size: Vec<f64> = Vec::new();
let mut req_t_size: Vec<f64> = Vec::new();
let mut resp_t_size: Vec<f64> = Vec::new();
let mut resp_handle_t_size: Vec<f64> = Vec::new();
let mut tot_req_size: Vec<f64> = Vec::new();
let mut tot_resp_size: Vec<f64> = Vec::new();
let mut tot_req_t_size: Vec<f64> = Vec::new();
let mut tot_resp_t_size: Vec<f64> = Vec::new();
let mut tot_resp_handle_t_size: Vec<f64> = 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<f64> = Vec::new();
let mut resp_size_b: Vec<f64> = Vec::new();
let mut req_t_size_b: Vec<f64> = Vec::new();
let mut resp_t_size_b: Vec<f64> = Vec::new();
let mut resp_handle_t_size_b: Vec<f64> = 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<f64> = Vec::new();
let mut resp_size2: Vec<f64> = Vec::new();
let mut req_t_size2: Vec<f64> = Vec::new();
let mut resp_t_size2: Vec<f64> = Vec::new();
let mut resp_handle_t_size2: Vec<f64> = 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<f64>,
req_t_size: Vec<f64>,
resp_size: Vec<f64>,
resp_t_size: Vec<f64>,
resp_handle_t_size: Vec<f64>,
) {
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<f64> = Vec::new();
let mut resp_size2: Vec<f64> = Vec::new();
let mut req_t_size2: Vec<f64> = Vec::new();
let mut resp_t_size2: Vec<f64> = Vec::new();
let mut resp_handle_t_size2: Vec<f64> = 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)
);
}