Struct TestHarness 

pub struct TestHarness { /* private fields */ }

Test harness for comprehensive validation

Manages temporary directories, test datasets, and performance metrics. Automatically cleans up resources when dropped.

Implementations

impl TestHarness

pub fn new() -> Self

Create a new test harness

Examples found in repository

examples/test_harness.rs (line 12)

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 temp_dir(&self) -> &Path

Get the temporary directory path

Examples found in repository

examples/test_harness.rs (line 13)

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 record_metric( &self, operation: &str, duration: Duration, memory_kb: usize, throughput_mbps: f64, )

Record a performance metric

Examples found in repository

examples/test_harness.rs (lines 65-70)

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 metrics(&self) -> PerformanceMetrics

Get a copy of current metrics

Examples found in repository

examples/test_harness.rs (line 72)

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 create_dataset(&self, size_mb: usize) -> PathBuf

Create a test dataset of specified size in MB

Creates a directory with various file types and patterns

Examples found in repository

examples/test_harness.rs (line 23)

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 create_file(&self, name: &str, content: &[u8]) -> PathBuf

Create a test file with specific content

Examples found in repository

examples/test_harness.rs (line 17)

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 create_directory_structure(&self, name: &str) -> PathBuf

Create a directory structure with various files

Examples found in repository

examples/test_harness.rs (line 55)

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 create_large_file( &self, name: &str, size_mb: usize, pattern: TestDataPattern, ) -> PathBuf

Create a large file with specified pattern

Examples found in repository

examples/test_harness.rs (lines 40-44)

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 Default for TestHarness

fn default() -> Self

Returns the “default value” for a type.