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

Added tests for different sized bridges

This commit is contained in:
onyinyang 2021-11-22 22:56:48 -05:00
parent 82272ea933
commit 3bb50aa9ab
No known key found for this signature in database
GPG Key ID: 156A6435430C2036
1 changed files with 308 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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