diff options
Diffstat (limited to 'morphology/tests/value.rs')
| -rw-r--r-- | morphology/tests/value.rs | 304 |
1 files changed, 304 insertions, 0 deletions
diff --git a/morphology/tests/value.rs b/morphology/tests/value.rs new file mode 100644 index 0000000..fcd4b76 --- /dev/null +++ b/morphology/tests/value.rs @@ -0,0 +1,304 @@ +//! Unit tests for the value module + +use std::collections::HashSet; + +// Import from the library crate +use meta_affine::value::*; +use meta_affine::Value; + +// ======================================================================== +// VALUE TESTS +// ======================================================================== + +#[test] +fn test_value_creation() { + let v1 = Value::new(0, 0); + assert_eq!(v1.outer, 0); + assert_eq!(v1.inner, 0); + + let v2 = Value::new(5, -3); + assert_eq!(v2.outer, 5); + assert_eq!(v2.inner, -3); + + let v3 = Value::new(-10, 20); + assert_eq!(v3.outer, -10); + assert_eq!(v3.inner, 20); +} + +#[test] +fn test_value_equality() { + let v1 = Value::new(2, 3); + let v2 = Value::new(2, 3); + let v3 = Value::new(2, 4); + + assert_eq!(v1, v2); + assert_ne!(v1, v3); + + // Test in sets (uniqueness) + let mut set = HashSet::new(); + set.insert(v1); + set.insert(v2); + set.insert(v3); + assert_eq!(set.len(), 2); +} + +#[test] +fn test_value_to_string() { + assert_eq!(format!("{}", Value::new(0, 0)), "(0,0)"); + assert_eq!(format!("{}", Value::new(2, 3)), "(2,3)"); + assert_eq!(format!("{}", Value::new(-1, -2)), "(-1,-2)"); + assert_eq!(format!("{}", Value::new(10, -5)), "(10,-5)"); +} + +#[test] +fn test_origin_detection() { + assert!(Value::new(0, 0).is_origin()); + assert!(!Value::new(1, 0).is_origin()); + assert!(!Value::new(0, 1).is_origin()); + assert!(!Value::new(-1, -1).is_origin()); + + let origin = Value::origin(); + assert!(origin.is_origin()); +} + +#[test] +fn test_value_copy_semantics() { + let v1 = Value::new(2, 3); + let v2 = v1; // Copy, not move + assert_eq!(v1, v2); + // v1 is still usable + assert_eq!(v1.outer, 2); +} + +// ======================================================================== +// MINIMUM DERIVATION PATH TESTS +// ======================================================================== + +#[test] +fn test_path_origin() { + let path = get_minimum_derivation_path(Value::new(0, 0)); + assert_eq!(path.len(), 1); + assert_eq!(path[0], Value::new(0, 0)); +} + +#[test] +fn test_path_positive_outer() { + // Test (3, 0) + let path = get_minimum_derivation_path(Value::new(3, 0)); + let expected = vec![ + Value::new(0, 0), + Value::new(1, 0), + Value::new(2, 0), + Value::new(3, 0), + ]; + + assert_eq!(path, expected); + assert_eq!(path.len(), 4); + assert_eq!(path.first(), Some(&Value::new(0, 0))); + assert_eq!(path.last(), Some(&Value::new(3, 0))); +} + +#[test] +fn test_path_negative_outer() { + // Test (-3, 0) + let path = get_minimum_derivation_path(Value::new(-3, 0)); + let expected = vec![ + Value::new(0, 0), + Value::new(-1, 0), + Value::new(-2, 0), + Value::new(-3, 0), + ]; + + assert_eq!(path, expected); + assert_eq!(path.len(), 4); + assert_eq!(path.first(), Some(&Value::new(0, 0))); + assert_eq!(path.last(), Some(&Value::new(-3, 0))); +} + +#[test] +fn test_path_positive_inner() { + // Test (0, 3) + let path = get_minimum_derivation_path(Value::new(0, 3)); + let expected = vec![ + Value::new(0, 0), + Value::new(0, 1), + Value::new(0, 2), + Value::new(0, 3), + ]; + + assert_eq!(path, expected); + assert_eq!(path.len(), 4); +} + +#[test] +fn test_path_negative_inner() { + // Test (0, -3) + let path = get_minimum_derivation_path(Value::new(0, -3)); + let expected = vec![ + Value::new(0, 0), + Value::new(0, -1), + Value::new(0, -2), + Value::new(0, -3), + ]; + + assert_eq!(path, expected); + assert_eq!(path.len(), 4); +} + +#[test] +fn test_path_combined_positive() { + // Test (2, 3) + let path = get_minimum_derivation_path(Value::new(2, 3)); + let expected = vec![ + Value::new(0, 0), + Value::new(1, 0), + Value::new(2, 0), + Value::new(2, 1), + Value::new(2, 2), + Value::new(2, 3), + ]; + + assert_eq!(path, expected); + assert_eq!(path.len(), 6); + assert_eq!(path.first(), Some(&Value::new(0, 0))); + assert_eq!(path.last(), Some(&Value::new(2, 3))); +} + +#[test] +fn test_path_combined_negative() { + // Test (-2, -3) + let path = get_minimum_derivation_path(Value::new(-2, -3)); + let expected = vec![ + Value::new(0, 0), + Value::new(-1, 0), + Value::new(-2, 0), + Value::new(-2, -1), + Value::new(-2, -2), + Value::new(-2, -3), + ]; + + assert_eq!(path, expected); + assert_eq!(path.len(), 6); +} + +#[test] +fn test_path_mixed_signs() { + // Test (2, -3) + let path1 = get_minimum_derivation_path(Value::new(2, -3)); + let expected1 = vec![ + Value::new(0, 0), + Value::new(1, 0), + Value::new(2, 0), + Value::new(2, -1), + Value::new(2, -2), + Value::new(2, -3), + ]; + assert_eq!(path1, expected1); + + // Test (-2, 3) + let path2 = get_minimum_derivation_path(Value::new(-2, 3)); + let expected2 = vec![ + Value::new(0, 0), + Value::new(-1, 0), + Value::new(-2, 0), + Value::new(-2, 1), + Value::new(-2, 2), + Value::new(-2, 3), + ]; + assert_eq!(path2, expected2); +} + +#[test] +fn test_path_length() { + assert_eq!(path_length(Value::new(0, 0)), 1); + assert_eq!(path_length(Value::new(3, 0)), 4); + assert_eq!(path_length(Value::new(0, 3)), 4); + assert_eq!(path_length(Value::new(2, 3)), 6); + assert_eq!(path_length(Value::new(-2, -3)), 6); + assert_eq!(path_length(Value::new(5, -7)), 13); +} + +#[test] +fn test_path_validity() { + // Test that paths satisfy key properties + let test_cases = vec![ + Value::new(0, 0), + Value::new(5, 0), + Value::new(-5, 0), + Value::new(0, 5), + Value::new(0, -5), + Value::new(3, 4), + Value::new(-3, -4), + Value::new(3, -4), + Value::new(-3, 4), + ]; + + for value in test_cases { + let path = get_minimum_derivation_path(value); + + // Property 1: Path starts at origin + assert_eq!( + path.first(), + Some(&Value::origin()), + "Path must start at origin for {}", + value + ); + + // Property 2: Path ends at target value + assert_eq!( + path.last(), + Some(&value), + "Path must end at target value for {}", + value + ); + + // Property 3: Path length matches formula + assert_eq!( + path.len(), + path_length(value), + "Path length mismatch for {}", + value + ); + + // Property 4: Each step is valid (follows one of the 5 rules) + assert_valid_steps(&path); + } +} + +fn assert_valid_steps(path: &[Value]) { + for window in path.windows(2) { + let v1 = window[0]; + let v2 = window[1]; + + let o1 = v1.outer; + let i1 = v1.inner; + let o2 = v2.outer; + let i2 = v2.inner; + + // Check that each transition follows exactly one rule + let valid_transition = (o2 == o1 + 1 && i2 == i1) // Rule 2 + || (o2 == o1 - 1 && i2 == i1) // Rule 3 + || (o2 == o1 && i2 == i1 + 1) // Rule 4 + || (o2 == o1 && i2 == i1 - 1); // Rule 5 + + assert!( + valid_transition, + "Invalid transition from {} to {}", + v1, v2 + ); + } +} + +#[test] +fn test_path_immutability() { + let value = Value::new(3, 4); + let path1 = get_minimum_derivation_path(value); + let path2 = get_minimum_derivation_path(value); + + // Both calls should produce identical results + assert_eq!(path1, path2); + + // Original value should be unchanged + assert_eq!(value.outer, 3); + assert_eq!(value.inner, 4); +} |