Struct PerformanceMetrics 

pub struct PerformanceMetrics {
    pub operation_times: HashMap<String, Vec<Duration>>,
    pub memory_usage: HashMap<String, Vec<usize>>,
    pub throughput: HashMap<String, Vec<f64>>,
}

Performance metrics collector shared across tests

Fields

operation_times: HashMap<String, Vec<Duration>>

memory_usage: HashMap<String, Vec<usize>>

throughput: HashMap<String, Vec<f64>>

Implementations

impl PerformanceMetrics

pub fn new() -> Self

pub fn record( &mut self, operation: &str, duration: Duration, memory_kb: usize, throughput_mbps: f64, )

Record a performance metric

pub fn avg_time(&self, operation: &str) -> Option<Duration>

Get average time for an operation

Examples found in repository

examples/test_harness.rs (line 73)

fn main() {
    println!("=== Embeddenator TestKit - Test Harness ===\n");

    // Create test harness (automatically manages temp directory)
    println!("1. Creating test harness...");
    let harness = TestHarness::new();
    println!("   Temp directory: {:?}", harness.temp_dir());

    // Create a simple test file
    println!("\n2. Creating test file...");
    let file_path = harness.create_file("test.txt", b"Hello, World!");
    println!("   Created: {:?}", file_path);
    println!("   Exists: {}", file_path.exists());

    // Create a test dataset
    println!("\n3. Creating test dataset (5MB)...");
    let dataset_path = harness.create_dataset(5);
    println!("   Dataset directory: {:?}", dataset_path);

    // List files in dataset
    let files: Vec<_> = std::fs::read_dir(&dataset_path)
        .unwrap()
        .filter_map(|e| e.ok())
        .collect();
    println!("   Files created: {}", files.len());

    if let Some(first_file) = files.first() {
        let metadata = first_file.metadata().unwrap();
        println!("   First file size: {} bytes", metadata.len());
    }

    // Create large file with specific pattern
    println!("\n4. Creating large file with pattern...");
    let large_file = harness.create_large_file(
        "sequential.bin",
        10, // 10MB
        TestDataPattern::Sequential,
    );
    let metadata = std::fs::metadata(&large_file).unwrap();
    println!("   Created: {:?}", large_file);
    println!(
        "   Size: {} bytes ({} MB)",
        metadata.len(),
        metadata.len() / 1024 / 1024
    );

    // Create directory structure
    println!("\n5. Creating directory structure...");
    let dir_structure = harness.create_directory_structure("project");
    println!("   Base: {:?}", dir_structure);
    println!("   Contains dir1: {}", dir_structure.join("dir1").exists());
    println!(
        "   Contains dir2/nested: {}",
        dir_structure.join("dir2/nested").exists()
    );

    // Record metrics
    println!("\n6. Recording performance metrics...");
    harness.record_metric(
        "dataset_creation",
        std::time::Duration::from_secs(1),
        5120, // 5MB in KB
        5.0,  // 5 MB/s
    );

    let metrics = harness.metrics();
    if let Some(avg_time) = metrics.avg_time("dataset_creation") {
        println!("   Average time: {:?}", avg_time);
    }
    if let Some(avg_throughput) = metrics.avg_throughput("dataset_creation") {
        println!("   Average throughput: {:.2} MB/s", avg_throughput);
    }

    println!("\n✅ Test harness example complete!");
    println!("   (Temp directory will be automatically cleaned up)");
}

pub fn avg_throughput(&self, operation: &str) -> Option<f64>

Get average throughput for an operation

Examples found in repository

examples/test_harness.rs (line 76)

fn main() {
    println!("=== Embeddenator TestKit - Test Harness ===\n");

    // Create test harness (automatically manages temp directory)
    println!("1. Creating test harness...");
    let harness = TestHarness::new();
    println!("   Temp directory: {:?}", harness.temp_dir());

    // Create a simple test file
    println!("\n2. Creating test file...");
    let file_path = harness.create_file("test.txt", b"Hello, World!");
    println!("   Created: {:?}", file_path);
    println!("   Exists: {}", file_path.exists());

    // Create a test dataset
    println!("\n3. Creating test dataset (5MB)...");
    let dataset_path = harness.create_dataset(5);
    println!("   Dataset directory: {:?}", dataset_path);

    // List files in dataset
    let files: Vec<_> = std::fs::read_dir(&dataset_path)
        .unwrap()
        .filter_map(|e| e.ok())
        .collect();
    println!("   Files created: {}", files.len());

    if let Some(first_file) = files.first() {
        let metadata = first_file.metadata().unwrap();
        println!("   First file size: {} bytes", metadata.len());
    }

    // Create large file with specific pattern
    println!("\n4. Creating large file with pattern...");
    let large_file = harness.create_large_file(
        "sequential.bin",
        10, // 10MB
        TestDataPattern::Sequential,
    );
    let metadata = std::fs::metadata(&large_file).unwrap();
    println!("   Created: {:?}", large_file);
    println!(
        "   Size: {} bytes ({} MB)",
        metadata.len(),
        metadata.len() / 1024 / 1024
    );

    // Create directory structure
    println!("\n5. Creating directory structure...");
    let dir_structure = harness.create_directory_structure("project");
    println!("   Base: {:?}", dir_structure);
    println!("   Contains dir1: {}", dir_structure.join("dir1").exists());
    println!(
        "   Contains dir2/nested: {}",
        dir_structure.join("dir2/nested").exists()
    );

    // Record metrics
    println!("\n6. Recording performance metrics...");
    harness.record_metric(
        "dataset_creation",
        std::time::Duration::from_secs(1),
        5120, // 5MB in KB
        5.0,  // 5 MB/s
    );

    let metrics = harness.metrics();
    if let Some(avg_time) = metrics.avg_time("dataset_creation") {
        println!("   Average time: {:?}", avg_time);
    }
    if let Some(avg_throughput) = metrics.avg_throughput("dataset_creation") {
        println!("   Average throughput: {:.2} MB/s", avg_throughput);
    }

    println!("\n✅ Test harness example complete!");
    println!("   (Temp directory will be automatically cleaned up)");
}

Trait Implementations

impl Clone for PerformanceMetrics

fn clone(&self) -> PerformanceMetrics

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PerformanceMetrics

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PerformanceMetrics

fn default() -> PerformanceMetrics

Returns the “default value” for a type.