From 53aca050d78bcda82bd3f2c22b672df91bba23e6 Mon Sep 17 00:00:00 2001 From: jacksonfu14 Date: Tue, 18 Nov 2025 20:34:56 +0100 Subject: scale staves to fit notes --- morphology-img/tests/template.rs | 114 +++++++++++++++++++-------------------- 1 file changed, 57 insertions(+), 57 deletions(-) (limited to 'morphology-img/tests') diff --git a/morphology-img/tests/template.rs b/morphology-img/tests/template.rs index 60ef20e..07a5f3b 100644 --- a/morphology-img/tests/template.rs +++ b/morphology-img/tests/template.rs @@ -13,27 +13,31 @@ fn test_embedded_templates_non_empty() { } #[test] -fn test_template_contains_placeholder() { - // Verify the template contains the placeholder +fn test_template_contains_placeholders() { + // Verify the template contains both placeholders let template = get_template(); - assert!(template.contains("%%%"), "template should contain '%%%' placeholder"); + assert!(template.contains("%MORPHEME%"), "template should contain '%MORPHEME%' placeholder"); + assert!(template.contains("%RUNGS%"), "template should contain '%RUNGS%' placeholder"); } #[test] fn test_successful_substitution() { // Test successful substitution with simple markup - let markup = "c'4 d'4 e'4"; - let result = substitute_template(markup); + let morpheme = "c'4 d'4 e'4"; + let rungs = "#'(-5 0 5)"; + let result = substitute_template(morpheme, rungs); assert!(result.is_ok(), "substitution should succeed"); let substituted = result.unwrap(); - // Verify the markup is present in the result - assert!(substituted.contains(markup), "result should contain the markup"); + // Verify both values are present in the result + assert!(substituted.contains(morpheme), "result should contain the morpheme"); + assert!(substituted.contains(rungs), "result should contain the rungs"); - // Verify the placeholder is no longer present - assert!(!substituted.contains("%%%"), "result should not contain placeholder"); + // Verify the placeholders are no longer present + assert!(!substituted.contains("%MORPHEME%"), "result should not contain morpheme placeholder"); + assert!(!substituted.contains("%RUNGS%"), "result should not contain rungs placeholder"); // Verify the template structure is preserved assert!(substituted.contains(r#"\version "2.24.0""#), "version should be preserved"); @@ -43,42 +47,30 @@ fn test_successful_substitution() { #[test] fn test_substitution_with_empty_markup() { - // Test with empty markup string - let markup = ""; - let result = substitute_template(markup); + // Test with empty morpheme string + let morpheme = ""; + let rungs = "#'(0)"; + let result = substitute_template(morpheme, rungs); - assert!(result.is_ok(), "substitution with empty string should succeed"); + assert!(result.is_ok(), "substitution with empty morpheme should succeed"); let substituted = result.unwrap(); - // Placeholder should be replaced with empty string - assert!(!substituted.contains("%%%")); + // Placeholders should be replaced + assert!(!substituted.contains("%MORPHEME%")); + assert!(!substituted.contains("%RUNGS%")); + assert!(substituted.contains(rungs)); } #[test] fn test_error_when_placeholder_missing() { - // This test simulates what would happen if the placeholder was missing - // We'll test this by creating a mock template without the placeholder - - // Note: We can't easily modify the embedded template at runtime, - // so we'll just verify the error handling works as designed - // by checking that our current template DOES have the placeholder + // Verify error handling works by checking that our current template + // has both required placeholders let template = get_template(); - if !template.contains("%%%") { - // If this branch were taken, substitute_template would return an error - let result = substitute_template("test"); - assert!(result.is_err()); - - if let Err(RenderError::Template(msg)) = result { - assert!(msg.contains("placeholder")); - } else { - panic!("Expected RenderError::Template"); - } - } else { - // Current template has placeholder, which is correct - assert!(template.contains("%%%")); - } + // Current template should have both placeholders + assert!(template.contains("%MORPHEME%"), "template should have morpheme placeholder"); + assert!(template.contains("%RUNGS%"), "template should have rungs placeholder"); } #[test] @@ -97,8 +89,9 @@ fn test_template_structure() { #[test] fn test_substitution_preserves_whitespace() { // Test that substitution preserves indentation and whitespace - let markup = "c'4 d'4"; - let result = substitute_template(markup).unwrap(); + let morpheme = "c'4 d'4"; + let rungs = "#'(0)"; + let result = substitute_template(morpheme, rungs).unwrap(); // The indented structure should be preserved // The markup should be indented within the entry block @@ -108,37 +101,44 @@ fn test_substitution_preserves_whitespace() { #[test] fn test_multiple_substitutions_independent() { // Test that multiple calls to substitute_template are independent - let markup1 = "c'4 d'4"; - let markup2 = "e'4 f'4"; - - let result1 = substitute_template(markup1).unwrap(); - let result2 = substitute_template(markup2).unwrap(); - - assert!(result1.contains(markup1)); - assert!(!result1.contains(markup2)); - - assert!(result2.contains(markup2)); - assert!(!result2.contains(markup1)); + let morpheme1 = "c'4 d'4"; + let morpheme2 = "e'4 f'4"; + let rungs1 = "#'(-3 0 3)"; + let rungs2 = "#'(-5 0 5)"; + + let result1 = substitute_template(morpheme1, rungs1).unwrap(); + let result2 = substitute_template(morpheme2, rungs2).unwrap(); + + assert!(result1.contains(morpheme1)); + assert!(result1.contains(rungs1)); + assert!(!result1.contains(morpheme2)); + assert!(!result1.contains(rungs2)); + + assert!(result2.contains(morpheme2)); + assert!(result2.contains(rungs2)); + assert!(!result2.contains(morpheme1)); + assert!(!result2.contains(rungs1)); } #[test] fn test_substitution_with_actual_sequence_markup() { // Test with markup that would come from the actual transformation pipeline - // This is the example from the development plan - let markup = "f'4 f4 e4 b4"; + let morpheme = "f'4 f4 e4 b4"; + let rungs = "#'(-4 0 4)"; - let result = substitute_template(markup); + let result = substitute_template(morpheme, rungs); assert!(result.is_ok()); let substituted = result.unwrap(); // Verify it creates valid LilyPond syntax structure - assert!(substituted.contains(r#"\entry { "#)); - assert!(substituted.contains(markup)); + assert!(substituted.contains(r#"\entry {"#)); + assert!(substituted.contains(morpheme)); + assert!(substituted.contains(rungs)); assert!(substituted.contains("}")); - // The substituted markup should be between the entry braces - let entry_start = substituted.find(r#"\entry { "#).unwrap(); - let markup_pos = substituted.find(markup).unwrap(); - assert!(markup_pos > entry_start, "markup should be inside entry block"); + // The substituted values should be in the correct positions + let entry_start = substituted.find(r#"\entry {"#).unwrap(); + let morpheme_pos = substituted.find(morpheme).unwrap(); + assert!(morpheme_pos > entry_start, "morpheme should be inside entry block"); } -- cgit v1.2.3