diff options
Diffstat (limited to 'morphology-img/tests/integration.rs')
| -rw-r--r-- | morphology-img/tests/integration.rs | 405 |
1 files changed, 1 insertions, 404 deletions
diff --git a/morphology-img/tests/integration.rs b/morphology-img/tests/integration.rs index 423d668..b61f097 100644 --- a/morphology-img/tests/integration.rs +++ b/morphology-img/tests/integration.rs @@ -1,8 +1,7 @@ -use morphology_img::{render_sequences, RenderConfig, ProgressCallback}; +use morphology_img::{render_sequences, RenderConfig}; use morphology::{Sequence, Value}; use tempfile::TempDir; use std::fs; -use std::sync::{Arc, Mutex}; /// Test the complete pipeline with basic configuration #[test] @@ -365,178 +364,6 @@ fn test_render_sequences_realistic_workflow() { assert_eq!(svg_paths[3].file_name().unwrap().to_str().unwrap(), "sequence-3.svg"); } -// Tests for progress callback - -/// Test that progress callback is called correctly -#[test] -#[ignore] -fn test_progress_callback_basic() { - let sequences = vec![ - Sequence::new(vec![Value::origin()]), - Sequence::new(vec![Value::new(1, 0)]), - Sequence::new(vec![Value::new(2, 0)]), - ]; - - let progress_calls = Arc::new(Mutex::new(Vec::new())); - let progress_calls_clone = progress_calls.clone(); - - let callback: ProgressCallback = Arc::new(move |current, total| { - progress_calls_clone.lock().unwrap().push((current, total)); - }); - - let output_dir = TempDir::new().unwrap(); - let config = RenderConfig::new(output_dir.path()) - .progress_callback(callback); - - let svg_paths = render_sequences(&sequences, &config).unwrap(); - - // Verify all SVGs were created - assert_eq!(svg_paths.len(), 3); - - // Verify progress callback was called correctly - let calls = progress_calls.lock().unwrap(); - assert_eq!(calls.len(), 3, "callback should be called once per sequence"); - - // Verify calls have correct values - assert_eq!(calls[0], (1, 3), "first call should be (1, 3)"); - assert_eq!(calls[1], (2, 3), "second call should be (2, 3)"); - assert_eq!(calls[2], (3, 3), "third call should be (3, 3)"); -} - -/// Test progress callback with single sequence -#[test] -#[ignore] -fn test_progress_callback_single() { - let sequences = vec![Sequence::new(vec![Value::origin()])]; - - let progress_calls = Arc::new(Mutex::new(Vec::new())); - let progress_calls_clone = progress_calls.clone(); - - let callback: ProgressCallback = Arc::new(move |current, total| { - progress_calls_clone.lock().unwrap().push((current, total)); - }); - - let output_dir = TempDir::new().unwrap(); - let config = RenderConfig::new(output_dir.path()) - .progress_callback(callback); - - let _svg_paths = render_sequences(&sequences, &config).unwrap(); - - let calls = progress_calls.lock().unwrap(); - assert_eq!(calls.len(), 1); - assert_eq!(calls[0], (1, 1)); -} - -/// Test progress callback with many sequences -#[test] -#[ignore] -fn test_progress_callback_many() { - let sequences: Vec<Sequence> = (0..10) - .map(|i| Sequence::new(vec![Value::new(i, 0)])) - .collect(); - - let progress_calls = Arc::new(Mutex::new(Vec::new())); - let progress_calls_clone = progress_calls.clone(); - - let callback: ProgressCallback = Arc::new(move |current, total| { - progress_calls_clone.lock().unwrap().push((current, total)); - }); - - let output_dir = TempDir::new().unwrap(); - let config = RenderConfig::new(output_dir.path()) - .progress_callback(callback); - - let svg_paths = render_sequences(&sequences, &config).unwrap(); - - assert_eq!(svg_paths.len(), 10); - - let calls = progress_calls.lock().unwrap(); - assert_eq!(calls.len(), 10); - - // Verify each call has correct values - for (i, &(current, total)) in calls.iter().enumerate() { - assert_eq!(current, i + 1); - assert_eq!(total, 10); - } -} - -/// Test that rendering works without progress callback -#[test] -#[ignore] -fn test_no_progress_callback() { - let sequences = vec![ - Sequence::new(vec![Value::origin()]), - Sequence::new(vec![Value::new(1, 0)]), - ]; - - let output_dir = TempDir::new().unwrap(); - let config = RenderConfig::new(output_dir.path()); - // No progress callback set - - let svg_paths = render_sequences(&sequences, &config).unwrap(); - - // Should work normally without callback - assert_eq!(svg_paths.len(), 2); - for svg_path in &svg_paths { - assert!(svg_path.exists()); - } -} - -/// Test progress callback with empty sequence list -#[test] -#[ignore] -fn test_progress_callback_empty() { - let sequences: Vec<Sequence> = vec![]; - - let progress_calls = Arc::new(Mutex::new(Vec::new())); - let progress_calls_clone = progress_calls.clone(); - - let callback: ProgressCallback = Arc::new(move |current, total| { - progress_calls_clone.lock().unwrap().push((current, total)); - }); - - let output_dir = TempDir::new().unwrap(); - let config = RenderConfig::new(output_dir.path()) - .progress_callback(callback); - - let svg_paths = render_sequences(&sequences, &config).unwrap(); - - assert_eq!(svg_paths.len(), 0); - - // Callback should not be called for empty list - let calls = progress_calls.lock().unwrap(); - assert_eq!(calls.len(), 0, "callback should not be called for empty input"); -} - -/// Test that progress callback can track actual progress -#[test] -#[ignore] -fn test_progress_callback_tracking() { - let sequences: Vec<Sequence> = (0..5) - .map(|i| Sequence::new(vec![Value::new(i, 0)])) - .collect(); - - let last_progress = Arc::new(Mutex::new((0, 0))); - let last_progress_clone = last_progress.clone(); - - let callback: ProgressCallback = Arc::new(move |current, total| { - let mut progress = last_progress_clone.lock().unwrap(); - *progress = (current, total); - }); - - let output_dir = TempDir::new().unwrap(); - let config = RenderConfig::new(output_dir.path()) - .progress_callback(callback); - - let svg_paths = render_sequences(&sequences, &config).unwrap(); - - assert_eq!(svg_paths.len(), 5); - - // Last progress should be 5/5 - let final_progress = last_progress.lock().unwrap(); - assert_eq!(*final_progress, (5, 5), "final progress should be 5/5"); -} - // ============================================================================ // Batch Chunking Tests // ============================================================================ @@ -664,43 +491,6 @@ fn test_batch_chunking_preserves_order() { #[test] #[ignore] -fn test_batch_chunking_with_progress() { - // Test that progress callback works correctly with batching - let sequences: Vec<Sequence> = (0..8) - .map(|i| { - Sequence::new(vec![Value::new(i, 0)]) - }) - .collect(); - - let progress_calls = Arc::new(Mutex::new(Vec::new())); - let progress_calls_clone = progress_calls.clone(); - - let callback: ProgressCallback = Arc::new(move |current, total| { - progress_calls_clone.lock().unwrap().push((current, total)); - }); - - let output_dir = TempDir::new().unwrap(); - let config = RenderConfig::new(output_dir.path()) - .max_batch_size(3) - .progress_callback(callback); - - let svg_paths = render_sequences(&sequences, &config).unwrap(); - - assert_eq!(svg_paths.len(), 8); - - // Progress should track within each batch - let calls = progress_calls.lock().unwrap(); - assert!(!calls.is_empty(), "Progress callback should be called"); - - // Note: Progress is per-batch, so we should see: - // Batch 1 (3 items): (1,3), (2,3), (3,3) - // Batch 2 (3 items): (1,3), (2,3), (3,3) - // Batch 3 (2 items): (1,2), (2,2) - assert_eq!(calls.len(), 8, "Should have 8 progress calls total"); -} - -#[test] -#[ignore] fn test_batch_size_one() { // Edge case: batch size of 1 (process one at a time) let sequences: Vec<Sequence> = (0..3) @@ -720,196 +510,3 @@ fn test_batch_size_one() { assert!(path.exists()); } } - -// ============================================================================ -// Parallel Processing Tests -// ============================================================================ - -#[test] -#[ignore] -fn test_parallel_rendering_basic() { - // Test that parallel rendering works correctly - let sequences: Vec<Sequence> = (0..10) - .map(|i| { - Sequence::new(vec![Value::new(i, 0)]) - }) - .collect(); - - let output_dir = TempDir::new().unwrap(); - let config = RenderConfig::new(output_dir.path()) - .parallel(true); - - let svg_paths = render_sequences(&sequences, &config).unwrap(); - - assert_eq!(svg_paths.len(), 10); - for path in &svg_paths { - assert!(path.exists(), "SVG file should exist: {}", path.display()); - } -} - -#[test] -#[ignore] -fn test_parallel_vs_sequential_same_results() { - // Verify that parallel and sequential produce the same results - let sequences: Vec<Sequence> = (0..5) - .map(|i| { - Sequence::new(vec![Value::new(i, 0), Value::new(i, 1)]) - }) - .collect(); - - // Sequential rendering - let output_dir_seq = TempDir::new().unwrap(); - let config_seq = RenderConfig::new(output_dir_seq.path()) - .parallel(false); - - let svg_paths_seq = render_sequences(&sequences, &config_seq).unwrap(); - - // Parallel rendering - let output_dir_par = TempDir::new().unwrap(); - let config_par = RenderConfig::new(output_dir_par.path()) - .parallel(true); - - let svg_paths_par = render_sequences(&sequences, &config_par).unwrap(); - - // Both should produce same number of files - assert_eq!(svg_paths_seq.len(), svg_paths_par.len()); - - // Both should have files with same names - for (seq_path, par_path) in svg_paths_seq.iter().zip(svg_paths_par.iter()) { - assert_eq!( - seq_path.file_name(), - par_path.file_name(), - "Sequential and parallel should produce same filenames" - ); - assert!(seq_path.exists()); - assert!(par_path.exists()); - } -} - -#[test] -#[ignore] -fn test_parallel_with_progress_callback() { - // Test that progress callbacks work with parallel rendering - let sequences: Vec<Sequence> = (0..8) - .map(|i| { - Sequence::new(vec![Value::new(i, 0)]) - }) - .collect(); - - let progress_calls = Arc::new(Mutex::new(Vec::new())); - let progress_calls_clone = progress_calls.clone(); - - let callback: ProgressCallback = Arc::new(move |current, total| { - progress_calls_clone.lock().unwrap().push((current, total)); - }); - - let output_dir = TempDir::new().unwrap(); - let config = RenderConfig::new(output_dir.path()) - .parallel(true) - .progress_callback(callback); - - let svg_paths = render_sequences(&sequences, &config).unwrap(); - - assert_eq!(svg_paths.len(), 8); - - // Progress callback should have been called 8 times - let calls = progress_calls.lock().unwrap(); - assert_eq!(calls.len(), 8, "Progress callback should be called for each file"); - - // All calls should have total=8 - for (_current, total) in calls.iter() { - assert_eq!(*total, 8, "Total should always be 8"); - } -} - -#[test] -#[ignore] -fn test_parallel_default_is_false() { - let config = RenderConfig::default(); - assert!(!config.parallel, "Parallel should default to false"); - - let config2 = RenderConfig::new("output"); - assert!(!config2.parallel, "Parallel should default to false"); -} - -#[test] -#[ignore] -fn test_parallel_with_batch_chunking() { - // Test parallel rendering combined with batch chunking - let sequences: Vec<Sequence> = (0..15) - .map(|i| { - Sequence::new(vec![Value::new(i, 0)]) - }) - .collect(); - - let output_dir = TempDir::new().unwrap(); - let config = RenderConfig::new(output_dir.path()) - .parallel(true) - .max_batch_size(5); - - let svg_paths = render_sequences(&sequences, &config).unwrap(); - - // All 15 SVGs should be created - assert_eq!(svg_paths.len(), 15); - - // Verify files are in order (sequence-00.svg through sequence-14.svg) - for (i, path) in svg_paths.iter().enumerate() { - let expected_filename = format!("sequence-{:02}.svg", i); - assert_eq!( - path.file_name().unwrap().to_str().unwrap(), - expected_filename, - "Files should be in correct order" - ); - assert!(path.exists()); - } -} - -#[test] -#[ignore] -fn test_benchmark_parallel_vs_sequential() { - use std::time::Instant; - - // Create many sequences for meaningful benchmark - let sequences: Vec<Sequence> = (0..20) - .map(|i| { - Sequence::new(vec![Value::new(i, 0)]) - }) - .collect(); - - // Sequential rendering - let output_dir_seq = TempDir::new().unwrap(); - let config_seq = RenderConfig::new(output_dir_seq.path()) - .parallel(false); - - let start = Instant::now(); - let svg_paths_seq = render_sequences(&sequences, &config_seq).unwrap(); - let sequential_time = start.elapsed(); - - assert_eq!(svg_paths_seq.len(), 20); - - // Parallel rendering - let output_dir_par = TempDir::new().unwrap(); - let config_par = RenderConfig::new(output_dir_par.path()) - .parallel(true); - - let start = Instant::now(); - let svg_paths_par = render_sequences(&sequences, &config_par).unwrap(); - let parallel_time = start.elapsed(); - - assert_eq!(svg_paths_par.len(), 20); - - // Print timing results - println!("\n=== Parallel vs Sequential Benchmark (20 sequences) ==="); - println!("Sequential time: {:?}", sequential_time); - println!("Parallel time: {:?}", parallel_time); - - if parallel_time < sequential_time { - let speedup = sequential_time.as_secs_f64() / parallel_time.as_secs_f64(); - println!("Speedup: {:.2}x faster", speedup); - } else { - println!("Note: Parallel was slower (overhead or system constraints)"); - } - - // No strict assertion on speed - depends on system - // Just verify both completed successfully -} |