Add test management module: Introduce mod.rs, starter.rs, and updater.rs for managing speed test execution and statistics handling. This includes functionality for starting tests, processing updates, and logging results, enhancing the overall test management capabilities of the application.

Author: sh1ftd

src/ui/test_management/mod.rs

@@ -0,0 +1,5 @@
+mod starter;
+mod updater;
+
+pub use starter::start_test;
+pub use updater::handle_stats_update;

src/ui/test_management/starter.rs

@@ -0,0 +1,91 @@
+use crate::{
+    speedtest::Connector,
+    speedtest::SpeedTest,
+    ui::console::{ConsoleWindow, log_to_console},
+    ui::helpers::get_size_label,
+};
+use std::{sync::mpsc::Sender, time::Duration};
+use tokio::sync::mpsc;
+
+pub fn start_test(
+    connector: Connector,
+    pcileech_device: String,
+    duration: u64,
+    test_sizes: &[(usize, bool)],
+    console: &ConsoleWindow,
+    modal_tx: Sender<String>,
+    stats_tx: mpsc::Sender<(f64, u64, f64, usize, f64)>,
+) -> Result<SpeedTest, String> {
+    let selected_sizes = collect_enabled_sizes(test_sizes);
+
+    log_to_console(console, "Starting speed test...");
+
+    let test = SpeedTest::new(connector, pcileech_device)
+        .map_err(|e| format!("Failed to initialize test: {e}"))?;
+
+    let test_clone = test.clone();
+    let console_clone = console.clone();
+
+    spawn_test_runner(
+        selected_sizes,
+        duration,
+        console_clone,
+        test_clone,
+        modal_tx,
+        stats_tx,
+    );
+
+    Ok(test)
+}
+
+fn collect_enabled_sizes(test_sizes: &[(usize, bool)]) -> Vec<usize> {
+    test_sizes
+        .iter()
+        .filter_map(|(size, enabled)| (*enabled).then_some(*size))
+        .collect()
+}
+
+fn spawn_test_runner(
+    test_sizes: Vec<usize>,
+    duration: u64,
+    console: ConsoleWindow,
+    test: SpeedTest,
+    modal_tx: Sender<String>,
+    stats_tx: mpsc::Sender<(f64, u64, f64, usize, f64)>,
+) {
+    std::thread::spawn(move || {
+        let runtime = tokio::runtime::Runtime::new().expect("failed to create runtime");
+        runtime.block_on(async move {
+            if test_sizes.is_empty() {
+                log_to_console(&console, "No test sizes selected!");
+                return;
+            }
+
+            let test_duration = Duration::from_secs(duration);
+            for size in test_sizes {
+                log_test_start(&console, size);
+
+                if let Err(e) = test
+                    .run_test_with_size(size, test_duration, stats_tx.clone())
+                    .await
+                {
+                    handle_test_error(&console, e, &modal_tx);
+                    return;
+                }
+            }
+        });
+    });
+}
+
+fn log_test_start(console: &ConsoleWindow, size: usize) {
+    log_to_console(
+        console,
+        &format!("Testing with read size: {}", get_size_label(size)),
+    );
+}
+
+fn handle_test_error(console: &ConsoleWindow, error: anyhow::Error, modal_tx: &Sender<String>) {
+    let error_msg = format!("Test error: {error}");
+    log_to_console(console, &error_msg);
+    let _ = modal_tx.send(error_msg);
+}

src/ui/test_management/updater.rs

@@ -0,0 +1,153 @@
+use crate::ui::console::{self, ConsoleWindow};
+use crate::ui::helpers::get_size_label;
+use crate::ui::types::{StatsUpdateParams, TestResults};
+use std::time::Instant;
+use tokio::sync::mpsc;
+
+pub fn handle_stats_update(
+    stats_rx: &mut mpsc::Receiver<(f64, u64, f64, usize, f64)>,
+    params: &mut StatsUpdateParams<'_>,
+    results: &TestResults,
+    console: &ConsoleWindow,
+) -> bool {
+    let mut stats_closed = false;
+
+    while let Some(update) = try_recv(stats_rx) {
+        match update {
+            StatsUpdate::Data(data) => process_stats(data, params, results, console),
+            StatsUpdate::Closed => {
+                stats_closed = true;
+                break;
+            }
+            StatsUpdate::Pending => break,
+        }
+    }
+
+    if stats_closed {
+        finalize_current_chunk(params);
+    }
+
+    stats_closed
+}
+
+struct StatsData {
+    throughput: f64,
+    reads_per_sec: u64,
+    read_size: usize,
+    latency_us: f64,
+}
+
+enum StatsUpdate {
+    Data(StatsData),
+    Closed,
+    Pending,
+}
+
+fn try_recv(stats_rx: &mut mpsc::Receiver<(f64, u64, f64, usize, f64)>) -> Option<StatsUpdate> {
+    match stats_rx.try_recv() {
+        Ok((throughput, reads_per_sec, _elapsed_secs, read_size, latency_us)) => {
+            Some(StatsUpdate::Data(StatsData {
+                throughput,
+                reads_per_sec,
+                read_size,
+                latency_us,
+            }))
+        }
+        Err(tokio::sync::mpsc::error::TryRecvError::Empty) => Some(StatsUpdate::Pending),
+        Err(tokio::sync::mpsc::error::TryRecvError::Disconnected) => Some(StatsUpdate::Closed),
+    }
+}
+
+fn process_stats(
+    data: StatsData,
+    params: &mut StatsUpdateParams<'_>,
+    results: &TestResults,
+    console: &ConsoleWindow,
+) {
+    record_chunk_completion(params, data.read_size);
+
+    *params.current_throughput = data.throughput;
+    *params.current_reads = data.reads_per_sec;
+    *params.current_latency = data.latency_us;
+
+    if params.current_test_size.as_ref().copied() != Some(data.read_size) {
+        *params.test_start_time = Some(Instant::now());
+        *params.current_test_size = Some(data.read_size);
+    }
+
+    let max_throughput = (*params.max_throughput).max(data.throughput);
+    *params.max_throughput = max_throughput;
+
+    log_stats(console, &data);
+    update_results(results, params, &data);
+}
+
+fn record_chunk_completion(params: &mut StatsUpdateParams<'_>, read_size: usize) {
+    if let Some(current_size) = (*params.current_test_size)
+        && current_size != read_size
+        && !params
+            .completed_chunks
+            .iter()
+            .any(|(size, _)| *size == current_size)
+        && let Some(start_time) = *params.test_start_time
+    {
+        let completion_time = start_time.elapsed().as_secs_f64();
+        params
+            .completed_chunks
+            .push((current_size, completion_time));
+    }
+}
+
+fn log_stats(console: &ConsoleWindow, data: &StatsData) {
+    console::log_to_console(
+        console,
+        &format!(
+            "Throughput: {:.2} MB/s, Reads/s: {}, Latency: {:.1} μs, Size: {}",
+            data.throughput,
+            data.reads_per_sec,
+            data.latency_us,
+            get_size_label(data.read_size)
+        ),
+    );
+}
+
+fn update_results(results: &TestResults, params: &StatsUpdateParams<'_>, data: &StatsData) {
+    if let Ok(mut results_guard) = results.lock() {
+        let entry_index = results_guard
+            .iter()
+            .position(|(size, _)| *size == data.read_size);
+
+        if entry_index.is_none() {
+            results_guard.push((data.read_size, (Vec::new(), Vec::new(), Vec::new())));
+        }
+
+        if let Some(entry) = results_guard
+            .iter_mut()
+            .find(|(size, _)| *size == data.read_size)
+        {
+            let elapsed_secs = (*params.test_start_time)
+                .map(|t| t.elapsed().as_secs_f64())
+                .unwrap_or(0.0);
+            let reads_per_sec = data.reads_per_sec as f64;
+
+            entry.1.0.push((elapsed_secs, data.throughput));
+            entry.1.1.push((elapsed_secs, reads_per_sec));
+            entry.1.2.push((elapsed_secs, data.latency_us));
+        }
+    }
+}
+
+fn finalize_current_chunk(params: &mut StatsUpdateParams<'_>) {
+    if let Some(current_size) = (*params.current_test_size)
+        && !params
+            .completed_chunks
+            .iter()
+            .any(|(s, _)| *s == current_size)
+        && let Some(start_time) = *params.test_start_time
+    {
+        let completion_time = start_time.elapsed().as_secs_f64();
+        params
+            .completed_chunks
+            .push((current_size, completion_time));
+    }
+}