Added perfstat time outputs for each test

src/tests.rs

@@ -713,206 +713,146 @@ fn test_blockage_migration() {
 }
 
 #[test]
-fn stats_test_open_invite() {
+fn stats_test_trust_levels() {
     let mut th = TestHarness::new_buckets(150, 150);
 
-    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..10000 {
-        let (perf_stat, _) = th.open_invite();
-        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());
-    }
-
-    println!("\n---------------Open Invitationn-------------------\n");
-    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(150, 150);
-
-    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..10000 {
-        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());
-    }
-
-    println!("\n-------Trust Promotion--------\n");
-    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(150, 150);
-
-    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..10000 {
-        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());
-    }
-
-    println!("\n-------------Trust Level0 Migration----------------\n");
-    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(150, 150);
-
-    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 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_t_size: Vec<f64> = Vec::new();
-    let mut sec_resp_t_size: Vec<f64> = Vec::new();
-    let mut sec_resp_handle_t_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_t_size: Vec<f64> = Vec::new();
-    let mut three_resp_t_size: Vec<f64> = Vec::new();
-    let mut three_resp_handle_t_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_t_size: Vec<f64> = Vec::new();
-    let mut four_resp_t_size: Vec<f64> = Vec::new();
-    let mut four_resp_handle_t_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();
     for _ in 0..10000 {
-        let cred = th.open_invite().1 .0;
+        let (open_perf_stat, cred) = th.open_invite();
         th.advance_days(30);
-        let (tp_perf_stat, migcred) = th.trust_promotion(&cred);
-        let (perf_stat, cred1) = th.level0_migration(&cred, &migcred);
+        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);
         th.advance_days(28);
         let (three_perf_stat, cred3) = th.level_up(&cred2);
         th.advance_days(56);
         let (four_perf_stat, _) = th.level_up(&cred3);
-        req_size.push((perf_stat.req_len + tp_perf_stat.req_len) as f64);
-        req_t_size.push((perf_stat.req_t + tp_perf_stat.req_t).as_secs_f64());
-        resp_size.push((perf_stat.resp_len + tp_perf_stat.resp_len) as f64);
-        resp_t_size.push((perf_stat.resp_t + tp_perf_stat.resp_t).as_secs_f64());
-        resp_handle_t_size
-            .push((perf_stat.resp_handle_t + tp_perf_stat.resp_handle_t).as_secs_f64());
+        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_t_size.push(sec_perf_stat.req_t.as_secs_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_t_size.push(sec_perf_stat.resp_t.as_secs_f64());
-        sec_resp_handle_t_size.push(sec_perf_stat.resp_handle_t.as_secs_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_t_size.push(three_perf_stat.req_t.as_secs_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_t_size.push(three_perf_stat.resp_t.as_secs_f64());
-        three_resp_handle_t_size.push(three_perf_stat.resp_handle_t.as_secs_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_t_size.push(four_perf_stat.req_t.as_secs_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_t_size.push(four_perf_stat.resp_t.as_secs_f64());
-        four_resp_handle_t_size.push(four_perf_stat.resp_handle_t.as_secs_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!("\n---Trust Promotion + Migration to Level 1: 30 days----\n");
+    println!("\n---------------Open Invitationn-------------------\n");
+    print_stats_test_results(
+        open_req_size,
+        open_req_time,
+        open_resp_size,
+        open_resp_time,
+        open_resp_handle_time,
+    );
+
+    println!("\n-------Trust Promotion to Level 1: 30 days----\n");
     print_stats_test_results(
-        req_size,
-        req_t_size,
-        resp_size,
-        resp_t_size,
-        resp_handle_t_size,
+        promo_req_size,
+        promo_req_time,
+        promo_resp_size,
+        promo_resp_time,
+        promo_resp_handle_time,
+    );
+
+    println!("\n-------Trust Level 0 Migration: 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-------Trust Promotion to Level 2: 44 days-------\n");
     print_stats_test_results(
         sec_req_size,
-        sec_req_t_size,
+        sec_req_time,
         sec_resp_size,
-        sec_resp_t_size,
-        sec_resp_handle_t_size,
+        sec_resp_time,
+        sec_resp_handle_time,
     );
 
     println!("\n-------Trust Promotion to Level 3: 72 days------\n");
     print_stats_test_results(
         three_req_size,
-        three_req_t_size,
+        three_req_time,
         three_resp_size,
-        three_resp_t_size,
-        three_resp_handle_t_size,
+        three_resp_time,
+        three_resp_handle_time,
     );
 
     println!("\n-------Trust Promotion to Level 4: 128 days------\n");
     print_stats_test_results(
         four_req_size,
-        four_req_t_size,
+        four_req_time,
         four_resp_size,
-        four_resp_t_size,
-        four_resp_handle_t_size,
+        four_resp_time,
+        four_resp_handle_time,
     );
 }
 
@@ -922,14 +862,14 @@ fn stats_test_invitations() {
 
     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 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_t_size: Vec<f64> = Vec::new();
-    let mut red_resp_t_size: Vec<f64> = Vec::new();
-    let mut red_resp_handle_t_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();
     for _ in 0..10000 {
         let cred = th.open_invite().1 .0;
         th.advance_days(30);
@@ -941,33 +881,31 @@ fn stats_test_invitations() {
         let (perf_stat, (_, invite)) = th.issue_invite(&cred2);
         let (bob_perf_stat, _) = th.redeem_invite(&invite);
         req_size.push(perf_stat.req_len as f64);
-        req_t_size.push(perf_stat.req_t.as_secs_f64());
+        req_time.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());
+        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_t_size.push(bob_perf_stat.req_t.as_secs_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_t_size.push(bob_perf_stat.resp_t.as_secs_f64());
-        red_resp_handle_t_size.push(bob_perf_stat.resp_handle_t.as_secs_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");
-    print_stats_test_results(
-        req_size,
-        req_t_size,
-        resp_size,
-        resp_t_size,
-        resp_handle_t_size,
-    );
+    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_t_size,
+        red_req_time,
         red_resp_size,
-        red_resp_t_size,
-        red_resp_handle_t_size,
+        red_resp_time,
+        red_resp_handle_time,
     );
 }
 
@@ -1443,14 +1381,14 @@ fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred:
 
     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 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_t_size: Vec<f64> = Vec::new();
-    let mut red_resp_t_size: Vec<f64> = Vec::new();
-    let mut red_resp_handle_t_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();
     for cred in credentials {
         let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
         let encbuckets = th.ba.enc_bridge_table();
@@ -1468,15 +1406,19 @@ fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred:
             let (perf_stat, migration) = th.check_blockage(&cred);
             let (block_perf_stat, _) = th.blockage_migration(&cred, &migration);
             req_size.push(perf_stat.req_len as f64);
-            req_t_size.push(perf_stat.req_t.as_secs_f64());
+            req_time.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());
+            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(block_perf_stat.req_len as f64);
-            red_req_t_size.push(block_perf_stat.req_t.as_secs_f64());
+            red_req_time.push(block_perf_stat.req_t.as_secs_f64());
             red_resp_size.push(block_perf_stat.resp_len as f64);
-            red_resp_t_size.push(block_perf_stat.resp_t.as_secs_f64());
-            red_resp_handle_t_size.push(block_perf_stat.resp_handle_t.as_secs_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);
         }
     }
 
@@ -1484,13 +1426,7 @@ fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred:
         "\n---------------Check Blockage {}---------------\n",
         percentage
     );
-    print_stats_test_results(
-        req_size,
-        req_t_size,
-        resp_size,
-        resp_t_size,
-        resp_handle_t_size,
-    );
+    print_stats_test_results(req_size, req_time, resp_size, resp_time, resp_handle_time);
 
     println!(
         "\n---------------Blockage Migration {}---------------\n",
@@ -1498,10 +1434,10 @@ fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred:
     );
     print_stats_test_results(
         red_req_size,
-        red_req_t_size,
+        red_req_time,
         red_resp_size,
-        red_resp_t_size,
-        red_resp_handle_t_size,
+        red_resp_time,
+        red_resp_handle_time,
     );
 }
 
@@ -1513,51 +1449,57 @@ fn print_test_results(perf_stat: PerfStat) {
     println!("Response handle time = {:?}", perf_stat.resp_handle_t);
 }
 
+fn print_time_test_results(perf_stat: PerfStat) {
+    println!("Request time = {:?}", perf_stat.req_t);
+    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>,
+    req_time: Vec<f64>,
     resp_size: Vec<f64>,
-    resp_t_size: Vec<f64>,
-    resp_handle_t_size: Vec<f64>,
+    resp_time: Vec<f64>,
+    resp_handle_time: 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_req_time = mean(&req_time);
+    let req_time_std_dev = standard_deviation(&req_time, Some(mean_req_time));
     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_handle_t_size);
-    let resp_handle_t_std_dev =
-        standard_deviation(&resp_handle_t_size, Some(mean_resp_handle_t_size));
+    let mean_resp_time = mean(&resp_time);
+    let resp_time_std_dev = standard_deviation(&resp_time, Some(mean_resp_time));
+    let mean_resp_handle_time = mean(&resp_handle_time);
+    let resp_handle_time_std_dev =
+        standard_deviation(&resp_handle_time, Some(mean_resp_handle_time));
 
     println!("Average request size = {} bytes", mean_req_size);
     println!("Request size standard deviation = {} bytes", req_std_dev);
     println!(
         "Average request time = {:?}",
-        Duration::from_secs_f64(mean_req_t_size)
+        Duration::from_secs_f64(mean_req_time)
     );
     println!(
         "Request time standard deviation = {:?}",
-        Duration::from_secs_f64(req_t_std_dev)
+        Duration::from_secs_f64(req_time_std_dev)
     );
     println!("Average response size = {} bytes", mean_resp_size);
     println!("Response standard deviation = {} bytes", resp_std_dev);
     println!(
         "Average response time = {:?}",
-        Duration::from_secs_f64(mean_resp_t_size)
+        Duration::from_secs_f64(mean_resp_time)
     );
     println!(
         "Response time standard deviation = {:?}",
-        Duration::from_secs_f64(resp_t_std_dev)
+        Duration::from_secs_f64(resp_time_std_dev)
     );
     println!(
         "Average response handling time = {:?}",
-        Duration::from_secs_f64(mean_resp_handle_t_size)
+        Duration::from_secs_f64(mean_resp_handle_time)
     );
     println!(
         "Response handling time standard deviation = {:?}",
-        Duration::from_secs_f64(resp_handle_t_std_dev)
+        Duration::from_secs_f64(resp_handle_time_std_dev)
     );
 }