Modularized duplicate code and added more tests

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<f64> = Vec::new();
     let mut resp_size: Vec<f64> = Vec::new();
     let mut req_t_size: Vec<f64> = Vec::new();
@@ -825,64 +728,196 @@ 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());
     }
-    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);
-    let req_t_std_dev = standard_deviation(&req_t_size, Some(mean_req_t_size));
-    let mean_resp_size = mean(&resp_size);
-    let resp_std_dev = standard_deviation(&resp_size, Some(mean_resp_size));
-    let mean_resp_t_size = mean(&resp_t_size);
-    let resp_t_std_dev = standard_deviation(&resp_t_size, Some(mean_resp_t_size));
-    let mean_resp_handle_t_size = mean(&resp_t_size);
-    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!("Request Standard Deviation = {}", req_std_dev);
-    println!(
-        "Average Request Time = {:?}",
-        Duration::from_secs_f64(mean_req_t_size)
+    print_stats_test_results(
+        req_size,
+        req_t_size,
+        resp_size,
+        resp_t_size,
+        resp_handle_t_size,
     );
-    println!(
-        "Request time Standard Deviation = {:?}",
-        Duration::from_secs_f64(req_t_std_dev)
+}
+
+#[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,
     );
-    println!("Average Response Size = {}", mean_resp_size);
-    println!("Response Standard Deviation = {}", resp_std_dev);
-    println!(
-        "Average Response Time = {:?}",
-        Duration::from_secs_f64(mean_resp_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!(
-        "Response Time Standard Deviation = {:?}",
-        Duration::from_secs_f64(resp_t_std_dev)
+
+    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,
     );
-    println!(
-        "Average Response Handling Time = {:?}",
-        Duration::from_secs_f64(mean_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!(
-        "Response Handling Time Standard Deviation = {:?}",
-        Duration::from_secs_f64(resp_handle_t_std_dev)
+
+    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");
 
-    println!("\n---------------Block 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
-    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);
+    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);
+        }
+    }
 
-    let b9 = th.ba.bridge_table.buckets[9][0];
-    th.ba.bridge_unreachable(&b9, &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,
+    );
+}
 
-    let b12 = th.ba.bridge_table.buckets[12][0];
-    th.ba.bridge_unreachable(&b12, &mut th.bdb);
+#[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();
@@ -897,44 +932,68 @@ fn protocol_tests() {
         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);
+    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);
+    let req_t_std_dev = standard_deviation(&req_t_size, Some(mean_req_t_size));
+    let mean_resp_size = mean(&resp_size);
+    let resp_std_dev = standard_deviation(&resp_size, Some(mean_resp_size));
+    let mean_resp_t_size = mean(&resp_t_size);
+    let resp_t_std_dev = standard_deviation(&resp_t_size, Some(mean_resp_t_size));
+    let mean_resp_handle_t_size = mean(&resp_t_size);
+    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!("Request Standard Deviation = {}", req_std_dev);
     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)
+        Duration::from_secs_f64(req_t_std_dev)
     );
-    println!("Average Response size = {}", mean_resp_size2);
-    println!("Response Standard Deviation = {}", resp_std_dev2);
+    println!("Average Response size = {}", mean_resp_size);
+    println!("Response Standard Deviation = {}", resp_std_dev);
     println!(
         "Average Response Time = {:?}",
-        Duration::from_secs_f64(mean_resp_t_size2)
+        Duration::from_secs_f64(mean_resp_t_size)
     );
     println!(
         "Response Time Standard Deviation = {:?}",
-        Duration::from_secs_f64(resp_t_std_dev2)
+        Duration::from_secs_f64(resp_t_std_dev)
     );
     println!(
         "Average Response Handling Time = {:?}",
-        Duration::from_secs_f64(mean_resp_handle_t_size2)
+        Duration::from_secs_f64(mean_resp_handle_t_size)
     );
     println!(
         "Response Handling Time Standard Deviation = {:?}",
-        Duration::from_secs_f64(resp_handle_t_std_dev2)
+        Duration::from_secs_f64(resp_handle_t_std_dev)
     );
 }