summaryrefslogtreecommitdiff
path: root/morphology-img/tests/integration.rs
diff options
context:
space:
mode:
authorjacksonfu14 <jackson@fashionunited.com>2025-11-17 17:21:40 +0100
committerJackson Moore <jacksonmoore@tuta.io>2025-11-17 17:21:40 +0100
commit73febb9177d86596522a4b7017ba6c3004826970 (patch)
treec722037db060a0ee8d8a76101786e5b1d7b1f224 /morphology-img/tests/integration.rs
parente11602236c10467bbba4bee6faaabf49265b8f53 (diff)
refactor: call lilypond once per batch
Diffstat (limited to 'morphology-img/tests/integration.rs')
-rw-r--r--morphology-img/tests/integration.rs405
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
-}