WIP better boxplots

Author: code-inflation

src/measurements.rs

@@ -131,7 +131,7 @@ fn log_measurements_by_test_type(
     stat_measurements
 }
 
-fn calc_stats(mbit_measurements: Vec<f64>) -> Option<(f64, f64, f64, f64, f64, f64)> {
+pub fn calc_stats(mbit_measurements: Vec<f64>) -> Option<(f64, f64, f64, f64, f64, f64)> {
     log::debug!("calc_stats for mbit_measurements {mbit_measurements:?}");
     let length = mbit_measurements.len();
     if length == 0 {

src/speedtest.rs

@@ -17,7 +17,7 @@ const BASE_URL: &str = "https://speed.cloudflare.com";
 const DOWNLOAD_URL: &str = "__down?bytes=";
 const UPLOAD_URL: &str = "__up";
 
-#[derive(Clone, Copy, Debug, Hash, Serialize, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Hash, Serialize, Eq, PartialEq, Ord, PartialOrd)]
 pub enum TestType {
     Download,
     Upload,

src/speedtest_tui.rs

@@ -35,6 +35,11 @@ pub fn speed_test_tui(
 
     // Run download tests
     if options.should_download() {
+        let _ = event_sender.send(TestEvent::TestPhaseStarted(
+            TestType::Download,
+            options.nr_tests,
+            payload_sizes.clone(),
+        ));
         measurements.extend(run_tests_tui(
             &client,
             test_download,
@@ -48,6 +53,11 @@ pub fn speed_test_tui(
 
     // Run upload tests
     if options.should_upload() {
+        let _ = event_sender.send(TestEvent::TestPhaseStarted(
+            TestType::Upload,
+            options.nr_tests,
+            payload_sizes.clone(),
+        ));
         measurements.extend(run_tests_tui(
             &client,
             test_upload,
@@ -62,14 +72,20 @@ pub fn speed_test_tui(
     let _ = event_sender.send(TestEvent::AllTestsCompleted);
     measurements
 }
-
 pub fn run_latency_test_tui(
     client: &Client,
     nr_latency_tests: u32,
     event_sender: Sender<TestEvent>,
 ) -> (Vec<f64>, f64) {
     let mut measurements: Vec<f64> = Vec::new();
 
+    // Set latency phase
+    let _ = event_sender.send(TestEvent::TestPhaseStarted(
+        TestType::Download, // Use Download as placeholder for latency
+        nr_latency_tests + 1,
+        vec![0], // Single "payload size" for latency
+    ));
+
     for _i in 0..=nr_latency_tests {
         let latency = test_latency(client);
         measurements.push(latency);
@@ -86,7 +102,6 @@ pub fn run_latency_test_tui(
     let avg_latency = measurements.iter().sum::<f64>() / measurements.len() as f64;
     (measurements, avg_latency)
 }
-
 pub fn run_tests_tui(
     client: &Client,
     test_fn: fn(&Client, usize, OutputFormat) -> f64,
@@ -98,16 +113,22 @@ pub fn run_tests_tui(
 ) -> Vec<Measurement> {
     let mut measurements: Vec<Measurement> = Vec::new();
 
-    for payload_size in payload_sizes {
-        let _ = event_sender.send(TestEvent::TestStarted(test_type, payload_size));
+    for (payload_index, payload_size) in payload_sizes.iter().enumerate() {
+        let _ = event_sender.send(TestEvent::PayloadSizeStarted(
+            test_type,
+            *payload_size,
+            payload_index,
+        ));
 
         let start = Instant::now();
         for _i in 0..nr_tests {
-            let mbit = test_fn(client, payload_size, OutputFormat::None);
+            let _ = event_sender.send(TestEvent::TestStarted(test_type, *payload_size));
+
+            let mbit = test_fn(client, *payload_size, OutputFormat::None);
 
             let measurement = Measurement {
                 test_type,
-                payload_size,
+                payload_size: *payload_size,
                 mbit,
             };
             measurements.push(measurement.clone());
@@ -116,23 +137,36 @@ pub fn run_tests_tui(
                 timestamp: Instant::now(),
                 speed: mbit,
                 test_type,
-                payload_size,
+                payload_size: *payload_size,
             }));
 
-            let _ = event_sender.send(TestEvent::TestCompleted(test_type, payload_size));
+            let _ = event_sender.send(TestEvent::TestCompleted(test_type, *payload_size));
 
             // Small delay to make the UI updates visible
             thread::sleep(Duration::from_millis(100));
         }
 
+        let _ = event_sender.send(TestEvent::PayloadSizeCompleted(test_type, *payload_size));
+
         let duration = start.elapsed();
 
         // Check time threshold for dynamic payload sizing
         if !disable_dynamic_max_payload_size && duration > TIME_THRESHOLD {
             log::info!("Exceeded threshold");
+            let _ = event_sender.send(TestEvent::TestsSkipped(
+                test_type,
+                "time limit exceeded".to_string(),
+            ));
             break;
         }
     }
 
+    // Calculate average speed for this test type
+    if !measurements.is_empty() {
+        let total_speed: f64 = measurements.iter().map(|m| m.mbit).sum();
+        let average_speed = total_speed / measurements.len() as f64;
+        let _ = event_sender.send(TestEvent::TestPhaseCompleted(test_type, average_speed));
+    }
+
     measurements
 }