diff options
| author | jacksonfu14 <jackson@fashionunited.com> | 2025-11-06 07:04:52 +0100 |
|---|---|---|
| committer | Jackson Moore <jacksonmoore@tuta.io> | 2025-11-06 07:04:52 +0100 |
| commit | c20b1fe88b0ab1469300bd53be14faa6a5b917a0 (patch) | |
| tree | 9e41975e6f6852146216a05ba4cef09436688aa2 /morphology/tests | |
initial commit
Diffstat (limited to 'morphology/tests')
| -rw-r--r-- | morphology/tests/sequence.rs | 554 | ||||
| -rw-r--r-- | morphology/tests/set.rs | 420 | ||||
| -rw-r--r-- | morphology/tests/value.rs | 304 |
3 files changed, 1278 insertions, 0 deletions
diff --git a/morphology/tests/sequence.rs b/morphology/tests/sequence.rs new file mode 100644 index 0000000..07e4d34 --- /dev/null +++ b/morphology/tests/sequence.rs @@ -0,0 +1,554 @@ +//! Unit tests for the sequence module + +use std::collections::HashSet; + +use meta_affine::{Sequence, ValidSet, Value}; +use meta_affine::sequence::*; + +// ======================================================================== +// SEQUENCE CREATION TESTS +// ======================================================================== + +#[test] +fn test_sequence_creation() { + let seq = Sequence::new(vec![Value::new(0, 0)]); + assert_eq!(seq.length(), 1); +} + +#[test] +fn test_sequence_values() { + let values = vec![Value::new(0, 0), Value::new(1, 0), Value::new(0, 0)]; + let seq = Sequence::new(values.clone()); + + assert_eq!(seq.values(), &values[..]); +} + +#[test] +fn test_sequence_length() { + let seq1 = Sequence::new(vec![Value::origin()]); + assert_eq!(seq1.length(), 1); + + let seq2 = Sequence::new(vec![Value::new(1, 0), Value::new(0, 0)]); + assert_eq!(seq2.length(), 2); +} + +// ======================================================================== +// CONSTRAINT 1: COVERAGE TESTS +// ======================================================================== + +#[test] +fn test_coverage_all_present() { + let mut set_values = HashSet::new(); + set_values.insert(Value::new(0, 0)); + set_values.insert(Value::new(1, 0)); + let set = ValidSet::from_values(set_values).unwrap(); + + let seq = Sequence::new(vec![Value::new(0, 0), Value::new(1, 0), Value::new(0, 0)]); + assert!(check_coverage(&seq, &set)); +} + +#[test] +fn test_coverage_missing_value() { + let mut set_values = HashSet::new(); + set_values.insert(Value::new(0, 0)); + set_values.insert(Value::new(1, 0)); + let set = ValidSet::from_values(set_values).unwrap(); + + // Sequence missing (1,0) + let seq = Sequence::new(vec![Value::new(0, 0)]); + assert!(!check_coverage(&seq, &set)); +} + +#[test] +fn test_coverage_with_repetitions() { + let set = ValidSet::origin_set(); + + // (0,0) appears three times - still valid + let seq = Sequence::new(vec![Value::origin()]); + assert!(check_coverage(&seq, &set)); +} + +// ======================================================================== +// CONSTRAINT 2: NO CONSECUTIVE DUPLICATES TESTS +// ======================================================================== + +#[test] +fn test_no_consecutive_duplicates_valid() { + let seq = Sequence::new(vec![ + Value::new(0, 0), + Value::new(1, 0), + Value::new(0, 0), + Value::new(1, 0), + ]); + assert!(check_no_consecutive_duplicates(&seq)); +} + +#[test] +fn test_no_consecutive_duplicates_invalid() { + let seq = Sequence::new(vec![ + Value::new(0, 0), + Value::new(0, 0), // Duplicate! + Value::new(1, 0), + ]); + assert!(!check_no_consecutive_duplicates(&seq)); +} + +#[test] +fn test_no_consecutive_duplicates_single_element() { + let seq = Sequence::new(vec![Value::origin()]); + assert!(check_no_consecutive_duplicates(&seq)); +} + +#[test] +fn test_no_consecutive_duplicates_empty() { + let seq = Sequence::new(vec![]); + assert!(check_no_consecutive_duplicates(&seq)); +} + +// ======================================================================== +// CONSTRAINT 3: TERMINAL TESTS +// ======================================================================== + +#[test] +fn test_terminal_valid() { + let seq = Sequence::new(vec![Value::new(1, 0), Value::origin()]); + assert!(check_terminal(&seq)); +} + +#[test] +fn test_terminal_invalid() { + let seq = Sequence::new(vec![Value::origin(), Value::new(1, 0)]); + assert!(!check_terminal(&seq)); +} + +#[test] +fn test_terminal_single_origin() { + let seq = Sequence::new(vec![Value::origin()]); + assert!(check_terminal(&seq)); +} + +#[test] +fn test_terminal_empty() { + let seq = Sequence::new(vec![]); + assert!(!check_terminal(&seq)); +} + +// ======================================================================== +// CONSTRAINT 4: OUTER VALUE CONSTRAINT TESTS +// ======================================================================== + +#[test] +fn test_outer_value_constraint_valid_simple() { + // Last occurrence of outer=1 is (1,0) ✓ + let seq = Sequence::new(vec![ + Value::new(1, 1), + Value::new(1, 0), + Value::new(0, 0), + ]); + assert!(check_outer_value_constraint(&seq)); +} + +#[test] +fn test_outer_value_constraint_invalid_simple() { + // Last occurrence of outer=1 is (1,1) ✗ + let seq = Sequence::new(vec![ + Value::new(1, 0), + Value::new(1, 1), + Value::new(0, 0), + ]); + assert!(!check_outer_value_constraint(&seq)); +} + +#[test] +fn test_outer_value_constraint_multiple_outers() { + // Last of outer=1 is (1,0), last of outer=0 is (0,0) ✓ + let seq = Sequence::new(vec![ + Value::new(1, 1), + Value::new(0, 1), + Value::new(1, 0), + Value::new(0, 0), + ]); + assert!(check_outer_value_constraint(&seq)); +} + +#[test] +fn test_outer_value_constraint_complex() { + // Valid: outer=2 last at (2,0), outer=0 last at (0,0) + let seq = Sequence::new(vec![ + Value::new(2, 1), + Value::new(2, 2), + Value::new(0, 1), + Value::new(2, 0), + Value::new(0, 0), + ]); + assert!(check_outer_value_constraint(&seq)); +} + +#[test] +fn test_outer_value_constraint_only_origin() { + let seq = Sequence::new(vec![Value::origin()]); + assert!(check_outer_value_constraint(&seq)); +} + +#[test] +fn test_outer_value_constraint_negative_outer() { + // Last of outer=-1 is (-1,0) ✓ + let seq = Sequence::new(vec![ + Value::new(-1, -1), + Value::new(-1, 0), + Value::new(0, 0), + ]); + assert!(check_outer_value_constraint(&seq)); +} + +// ======================================================================== +// COMBINED VALIDATION TESTS +// ======================================================================== + +#[test] +fn test_is_valid_all_constraints_satisfied() { + let mut set_values = HashSet::new(); + set_values.insert(Value::new(0, 0)); + set_values.insert(Value::new(1, 0)); + let set = ValidSet::from_values(set_values).unwrap(); + + let seq = Sequence::new(vec![ + Value::new(1, 0), + Value::new(0, 0), + ]); + + assert!(seq.is_valid(&set)); +} + +#[test] +fn test_is_valid_fails_coverage() { + let mut set_values = HashSet::new(); + set_values.insert(Value::new(0, 0)); + set_values.insert(Value::new(1, 0)); + let set = ValidSet::from_values(set_values).unwrap(); + + // Missing (1,0) + let seq = Sequence::new(vec![Value::new(0, 0)]); + assert!(!seq.is_valid(&set)); +} + +#[test] +fn test_is_valid_fails_consecutive_duplicates() { + let set = ValidSet::origin_set(); + + let seq = Sequence::new(vec![ + Value::new(0, 0), + Value::new(0, 0), // Duplicate! + ]); + assert!(!seq.is_valid(&set)); +} + +#[test] +fn test_is_valid_fails_terminal() { + let set = ValidSet::origin_set(); + + let seq = Sequence::new(vec![Value::new(1, 0)]); + assert!(!seq.is_valid(&set)); +} + +#[test] +fn test_is_valid_fails_outer_constraint() { + let mut set_values = HashSet::new(); + set_values.insert(Value::new(0, 0)); + set_values.insert(Value::new(1, 0)); + set_values.insert(Value::new(1, 1)); + let set = ValidSet::from_values(set_values).unwrap(); + + // Last occurrence of outer=1 is (1,1), not (1,0) + let seq = Sequence::new(vec![ + Value::new(1, 0), + Value::new(1, 1), + Value::new(0, 0), + ]); + assert!(!seq.is_valid(&set)); +} + +// ======================================================================== +// SEQUENCE GENERATION TESTS +// ======================================================================== + +#[test] +fn test_generate_sequences_length_1() { + let set = ValidSet::origin_set(); + let sequences = generate_sequences(&set, 1); + + // Only one valid sequence: [(0,0)] + assert_eq!(sequences.len(), 1); + assert_eq!(sequences[0].values(), &[Value::origin()]); +} + +#[test] +fn test_generate_sequences_length_2_simple_set() { + let mut set_values = HashSet::new(); + set_values.insert(Value::new(0, 0)); + set_values.insert(Value::new(1, 0)); + let set = ValidSet::from_values(set_values).unwrap(); + + let sequences = generate_sequences(&set, 2); + + // Valid sequences: [(1,0), (0,0)] + // Invalid: [(0,0), (1,0)] - doesn't end with (0,0) + // Invalid: [(0,0), (0,0)] - consecutive duplicates + // Invalid: [(1,0), (1,0)] - consecutive duplicates + + assert!(sequences.len() >= 1); + + // Check all generated sequences are valid + for seq in &sequences { + assert!(seq.is_valid(&set), "Invalid sequence: {:?}", seq); + } + + // Check the expected sequence is present + let expected = Sequence::new(vec![Value::new(1, 0), Value::new(0, 0)]); + assert!(sequences.contains(&expected)); +} + +#[test] +fn test_generate_sequences_no_valid_for_empty_set() { + let set = ValidSet::new(); + let sequences = generate_sequences(&set, 1); + + assert_eq!(sequences.len(), 0); +} + +#[test] +fn test_generate_sequences_length_zero() { + let set = ValidSet::origin_set(); + let sequences = generate_sequences(&set, 0); + + assert_eq!(sequences.len(), 0); +} + +#[test] +fn test_generate_sequences_all_valid() { + let mut set_values = HashSet::new(); + set_values.insert(Value::new(0, 0)); + set_values.insert(Value::new(1, 0)); + let set = ValidSet::from_values(set_values).unwrap(); + + let sequences = generate_sequences(&set, 3); + + // All generated sequences must be valid + for seq in &sequences { + assert!(seq.is_valid(&set), "Generated invalid sequence: {:?}", seq); + assert_eq!(seq.length(), 3); + } +} + +#[test] +fn test_generate_sequences_complex_set() { + let mut set_values = HashSet::new(); + set_values.insert(Value::new(0, 0)); + set_values.insert(Value::new(1, 0)); + set_values.insert(Value::new(1, 1)); + let set = ValidSet::from_values(set_values).unwrap(); + + let sequences = generate_sequences(&set, 4); + + // All sequences must be valid + for seq in &sequences { + assert!(seq.is_valid(&set)); + assert_eq!(seq.length(), 4); + } + + // Should have at least some sequences + assert!(sequences.len() > 0); +} + +#[test] +fn test_generate_all_sequences_length_1() { + let sequences = generate_all_sequences(1); + + // Only [(0,0)] is valid for length 1 + assert_eq!(sequences.len(), 1); + assert_eq!(sequences[0].values(), &[Value::origin()]); +} + +#[test] +fn test_generate_all_sequences_length_2() { + let sequences = generate_all_sequences(2); + + // Should have multiple valid sequences from different sets + assert!(sequences.len() > 0); + + // All must be valid and have length 2 + for seq in &sequences { + assert_eq!(seq.length(), 2); + assert!(check_no_consecutive_duplicates(seq)); + assert!(check_terminal(seq)); + assert!(check_outer_value_constraint(seq)); + } +} + +// ======================================================================== +// PROPERTY-BASED TESTS +// ======================================================================== + +#[test] +fn test_generated_sequences_satisfy_all_constraints() { + let set = ValidSet::origin_set() + .add_value_with_dependencies(Value::new(1, 1)); + + let sequences = generate_sequences(&set, 3); + + for seq in &sequences { + // Constraint 1: Coverage + assert!(check_coverage(seq, &set), "Coverage failed for {:?}", seq); + + // Constraint 2: No consecutive duplicates + assert!( + check_no_consecutive_duplicates(seq), + "Consecutive duplicates in {:?}", + seq + ); + + // Constraint 3: Terminal + assert!(check_terminal(seq), "Terminal failed for {:?}", seq); + + // Constraint 4: Outer value constraint + assert!( + check_outer_value_constraint(seq), + "Outer constraint failed for {:?}", + seq + ); + } +} + +#[test] +fn test_no_duplicate_sequences_generated() { + let set = ValidSet::origin_set() + .add_value_with_dependencies(Value::new(1, 0)); + + let sequences = generate_sequences(&set, 3); + + // Check for duplicates + for i in 0..sequences.len() { + for j in (i + 1)..sequences.len() { + assert_ne!( + &sequences[i], &sequences[j], + "Found duplicate sequences at {} and {}", + i, j + ); + } + } +} + +#[test] +fn test_sequence_length_matches_requested() { + let set = ValidSet::origin_set() + .add_value_with_dependencies(Value::new(1, 0)); + + for length in 1..=4 { + let sequences = generate_sequences(&set, length); + for seq in &sequences { + assert_eq!(seq.length(), length); + } + } +} + +// ======================================================================== +// EDGE CASES +// ======================================================================== + +#[test] +fn test_single_value_set_single_length() { + // Set with only origin + let set = ValidSet::origin_set(); + let sequences = generate_sequences(&set, 1); + + assert_eq!(sequences.len(), 1); + assert_eq!(sequences[0].values(), &[Value::origin()]); +} + +#[test] +fn test_set_with_origin_coverage_constraint() { + // Set has 2 values but we need length 1 - cannot satisfy coverage + let mut set_values = HashSet::new(); + set_values.insert(Value::new(0, 0)); // Origin is required + set_values.insert(Value::new(1, 0)); + let set = ValidSet::from_values(set_values).unwrap(); + + // Cannot generate length-1 sequences because we can't cover both values + let sequences = generate_sequences(&set, 1); + assert_eq!(sequences.len(), 0); + + // But length-2 sequences should work + let sequences2 = generate_sequences(&set, 2); + assert!(sequences2.len() > 0); +} + +#[test] +fn test_negative_coordinates_in_sequence() { + let set = ValidSet::new() + .add_value_with_dependencies(Value::new(-1, -1)); + + let sequences = generate_sequences(&set, 3); + + // All generated sequences should be valid + for seq in &sequences { + assert!(seq.is_valid(&set)); + } +} + +#[test] +fn test_large_set_small_sequence() { + // Set with 6 values, sequence of length 6 (minimum to cover all) + let set = ValidSet::new() + .add_value_with_dependencies(Value::new(2, 3)); + + let sequences = generate_sequences(&set, 6); + + // Should have at least some sequences + assert!(sequences.len() > 0); + + for seq in &sequences { + assert!(seq.is_valid(&set)); + assert_eq!(seq.length(), 6); + } +} + +#[test] +fn test_sequence_longer_than_set_size() { + // Set size 2, sequence length 4 + let mut set_values = HashSet::new(); + set_values.insert(Value::new(0, 0)); + set_values.insert(Value::new(1, 0)); + let set = ValidSet::from_values(set_values).unwrap(); + + let sequences = generate_sequences(&set, 4); + + // Should have sequences (values can repeat, just not consecutively) + assert!(sequences.len() > 0); + + for seq in &sequences { + assert!(seq.is_valid(&set)); + } +} + +#[test] +fn test_count_sequences() { + let set = ValidSet::origin_set(); + let count = count_sequences(&set, 1); + + assert_eq!(count, 1); +} + +#[test] +fn test_outer_constraint_with_multiple_values() { + // Test that outer constraint is properly enforced with multiple outer values + let set = ValidSet::new() + .add_value_with_dependencies(Value::new(1, 1)) + .add_value_with_dependencies(Value::new(-1, -1)); + + let sequences = generate_sequences(&set, set.size()); + + for seq in &sequences { + assert!(check_outer_value_constraint(seq), + "Outer constraint violated in {:?}", seq); + } +} diff --git a/morphology/tests/set.rs b/morphology/tests/set.rs new file mode 100644 index 0000000..54b441a --- /dev/null +++ b/morphology/tests/set.rs @@ -0,0 +1,420 @@ +//! Unit tests for the set module + +use std::collections::HashSet; + +use meta_affine::{ValidSet, Value}; +use meta_affine::set::*; + +// ======================================================================== +// VALID SET CREATION TESTS +// ======================================================================== + +#[test] +fn test_new_empty_set() { + let set = ValidSet::new(); + assert_eq!(set.size(), 0); + assert!(set.is_valid()); // Empty set is vacuously valid +} + +#[test] +fn test_origin_set() { + let set = ValidSet::origin_set(); + assert_eq!(set.size(), 1); + assert!(set.contains(&Value::origin())); + assert!(set.is_valid()); +} + +#[test] +fn test_from_values_valid() { + let mut values = HashSet::new(); + values.insert(Value::new(0, 0)); + values.insert(Value::new(1, 0)); + values.insert(Value::new(1, 1)); + + let set = ValidSet::from_values(values).unwrap(); + assert_eq!(set.size(), 3); + assert!(set.is_valid()); +} + +#[test] +fn test_from_values_invalid() { + // Missing (1,0) - not downward closed + let mut values = HashSet::new(); + values.insert(Value::new(0, 0)); + values.insert(Value::new(1, 1)); + + let result = ValidSet::from_values(values); + assert!(result.is_err()); +} + +#[test] +fn test_from_values_invalid_missing_origin() { + // Missing origin + let mut values = HashSet::new(); + values.insert(Value::new(1, 0)); + + let result = ValidSet::from_values(values); + assert!(result.is_err()); +} + +// ======================================================================== +// VALIDITY CHECKING TESTS +// ======================================================================== + +#[test] +fn test_is_valid_simple_cases() { + // {(0,0)} + let set1 = ValidSet::origin_set(); + assert!(set1.is_valid()); + + // {(0,0), (1,0)} + let mut values = HashSet::new(); + values.insert(Value::new(0, 0)); + values.insert(Value::new(1, 0)); + let set2 = ValidSet::from_values(values).unwrap(); + assert!(set2.is_valid()); + + // {(0,0), (0,1)} + let mut values = HashSet::new(); + values.insert(Value::new(0, 0)); + values.insert(Value::new(0, 1)); + let set3 = ValidSet::from_values(values).unwrap(); + assert!(set3.is_valid()); +} + +#[test] +fn test_is_valid_complex_path() { + // {(0,0), (1,0), (2,0), (2,1), (2,2), (2,3)} + let mut values = HashSet::new(); + values.insert(Value::new(0, 0)); + values.insert(Value::new(1, 0)); + values.insert(Value::new(2, 0)); + values.insert(Value::new(2, 1)); + values.insert(Value::new(2, 2)); + values.insert(Value::new(2, 3)); + + let set = ValidSet::from_values(values).unwrap(); + assert!(set.is_valid()); +} + +#[test] +fn test_is_valid_negative_values() { + // {(0,0), (-1,0), (-1,-1)} + let mut values = HashSet::new(); + values.insert(Value::new(0, 0)); + values.insert(Value::new(-1, 0)); + values.insert(Value::new(-1, -1)); + + let set = ValidSet::from_values(values).unwrap(); + assert!(set.is_valid()); +} + +#[test] +fn test_invalid_missing_intermediate() { + // Missing (1,0) - should be invalid + let mut values = HashSet::new(); + values.insert(Value::new(0, 0)); + values.insert(Value::new(2, 0)); + + let result = ValidSet::from_values(values); + assert!(result.is_err()); +} + +// ======================================================================== +// SET OPERATIONS TESTS +// ======================================================================== + +#[test] +fn test_add_value() { + let set = ValidSet::origin_set(); + + // Add (1,0) to {(0,0)} + let set2 = set.add_value(Value::new(1, 0)).unwrap(); + assert_eq!(set2.size(), 2); + assert!(set2.contains(&Value::new(1, 0))); + + // Original set unchanged (immutability) + assert_eq!(set.size(), 1); +} + +#[test] +fn test_add_value_invalid() { + let set = ValidSet::origin_set(); + + // Try to add (2,0) without (1,0) - should fail + let result = set.add_value(Value::new(2, 0)); + assert!(result.is_err()); +} + +#[test] +fn test_add_value_with_dependencies() { + let set = ValidSet::new(); + + // Add (2,3) with all dependencies + let set2 = set.add_value_with_dependencies(Value::new(2, 3)); + + // Should contain: (0,0), (1,0), (2,0), (2,1), (2,2), (2,3) + assert_eq!(set2.size(), 6); + assert!(set2.contains(&Value::new(0, 0))); + assert!(set2.contains(&Value::new(1, 0))); + assert!(set2.contains(&Value::new(2, 0))); + assert!(set2.contains(&Value::new(2, 1))); + assert!(set2.contains(&Value::new(2, 2))); + assert!(set2.contains(&Value::new(2, 3))); + assert!(set2.is_valid()); +} + +#[test] +fn test_contains() { + let set = ValidSet::origin_set(); + + assert!(set.contains(&Value::origin())); + assert!(!set.contains(&Value::new(1, 0))); +} + +#[test] +fn test_size() { + let set = ValidSet::origin_set(); + assert_eq!(set.size(), 1); + + let set2 = set.add_value(Value::new(1, 0)).unwrap(); + assert_eq!(set2.size(), 2); +} + +#[test] +fn test_values_iterator() { + let mut values = HashSet::new(); + values.insert(Value::new(0, 0)); + values.insert(Value::new(1, 0)); + values.insert(Value::new(0, 1)); + + let set = ValidSet::from_values(values.clone()).unwrap(); + + let collected: HashSet<Value> = set.values().copied().collect(); + assert_eq!(collected, values); +} + +#[test] +fn test_values_sorted() { + let mut values = HashSet::new(); + values.insert(Value::new(1, 0)); + values.insert(Value::new(0, 1)); + values.insert(Value::new(0, 0)); + values.insert(Value::new(-1, 0)); + + let set = ValidSet::from_values(values).unwrap(); + let sorted = set.values_sorted(); + + // Should be sorted by (outer, inner) + assert_eq!(sorted[0], Value::new(-1, 0)); + assert_eq!(sorted[1], Value::new(0, 0)); + assert_eq!(sorted[2], Value::new(0, 1)); + assert_eq!(sorted[3], Value::new(1, 0)); +} + +// ======================================================================== +// SET GENERATION TESTS +// ======================================================================== + +#[test] +fn test_generate_valid_sets_size_1() { + let sets = generate_valid_sets(1); + + // Should only have {(0,0)} + assert_eq!(sets.len(), 1); + assert_eq!(sets[0].size(), 1); + assert!(sets[0].contains(&Value::origin())); +} + +#[test] +fn test_generate_valid_sets_size_2() { + let sets = generate_valid_sets(2); + + // Should include: + // {(0,0)} + // {(0,0), (1,0)} + // {(0,0), (-1,0)} + // {(0,0), (0,1)} + // {(0,0), (0,-1)} + + assert!(sets.len() >= 5); + + // Check that all generated sets are valid + for set in &sets { + assert!(set.is_valid(), "Generated set is not valid: {:?}", set); + } + + // Check specific sets exist + let has_origin_plus_1_0 = sets.iter().any(|s| { + s.size() == 2 && s.contains(&Value::origin()) && s.contains(&Value::new(1, 0)) + }); + assert!(has_origin_plus_1_0); + + let has_origin_plus_0_1 = sets.iter().any(|s| { + s.size() == 2 && s.contains(&Value::origin()) && s.contains(&Value::new(0, 1)) + }); + assert!(has_origin_plus_0_1); +} + +#[test] +fn test_generate_valid_sets_size_3() { + let sets = generate_valid_sets(3); + + // Should include all from size 2, plus new size-3 sets + assert!(sets.len() > 5); + + // All sets should be valid + for set in &sets { + assert!(set.is_valid(), "Generated set is not valid"); + } + + // Check a specific size-3 set exists: {(0,0), (1,0), (1,1)} + let has_target_set = sets.iter().any(|s| { + s.size() == 3 + && s.contains(&Value::new(0, 0)) + && s.contains(&Value::new(1, 0)) + && s.contains(&Value::new(1, 1)) + }); + assert!(has_target_set); +} + +#[test] +fn test_generate_valid_sets_all_valid() { + // Generate sets up to size 4 and verify all are valid + let sets = generate_valid_sets(4); + + for set in &sets { + assert!(set.is_valid(), "Generated invalid set: {:?}", set); + } + + // Should have generated multiple sets + assert!(sets.len() > 10); +} + +#[test] +fn test_generate_valid_sets_no_duplicates() { + let sets = generate_valid_sets(4); + + // Check for duplicates manually + for i in 0..sets.len() { + for j in (i + 1)..sets.len() { + assert_ne!(&sets[i], &sets[j], "Found duplicate sets at indices {} and {}", i, j); + } + } +} + +#[test] +fn test_generate_valid_sets_of_size() { + let sets = generate_valid_sets_of_size(3); + + // All sets should have size exactly 3 + for set in &sets { + assert_eq!(set.size(), 3); + assert!(set.is_valid()); + } + + // Should have multiple size-3 sets + assert!(sets.len() > 3); +} + +// ======================================================================== +// PROPERTY-BASED TESTS +// ======================================================================== + +#[test] +fn test_all_generated_sets_contain_origin() { + let sets = generate_valid_sets(5); + + for set in &sets { + if set.size() > 0 { + assert!( + set.contains(&Value::origin()), + "Non-empty valid set must contain origin" + ); + } + } +} + +#[test] +fn test_downward_closure_property() { + // For any value in a generated set, all values in its path must be in the set + let sets = generate_valid_sets(5); + + for set in &sets { + for &value in set.values() { + let path = meta_affine::value::get_minimum_derivation_path(value); + for dep in path { + assert!( + set.contains(&dep), + "Set {:?} contains {} but missing dependency {}", + set.values_sorted(), + value, + dep + ); + } + } + } +} + +#[test] +fn test_immutability_of_operations() { + let set1 = ValidSet::origin_set(); + let original_size = set1.size(); + + // Add a value + let _set2 = set1.add_value(Value::new(1, 0)).unwrap(); + + // Original set should be unchanged + assert_eq!(set1.size(), original_size); + assert!(!set1.contains(&Value::new(1, 0))); +} + +// ======================================================================== +// EDGE CASES +// ======================================================================== + +#[test] +fn test_empty_set_is_valid() { + let set = ValidSet::new(); + assert!(set.is_valid()); +} + +#[test] +fn test_generate_sets_size_zero() { + let sets = generate_valid_sets(0); + assert_eq!(sets.len(), 1); + assert_eq!(sets[0].size(), 0); +} + +#[test] +fn test_large_value_with_dependencies() { + // Test that adding a "far" value includes all intermediate values + let set = ValidSet::new(); + let set2 = set.add_value_with_dependencies(Value::new(3, 4)); + + // Path length for (3,4) is 3 + 4 + 1 = 8 + assert_eq!(set2.size(), 8); + assert!(set2.is_valid()); +} + +#[test] +fn test_negative_coordinates() { + let set = ValidSet::new(); + let set2 = set.add_value_with_dependencies(Value::new(-2, -3)); + + // Should contain: (0,0), (-1,0), (-2,0), (-2,-1), (-2,-2), (-2,-3) + assert_eq!(set2.size(), 6); + assert!(set2.contains(&Value::new(-1, 0))); + assert!(set2.contains(&Value::new(-2, -1))); + assert!(set2.is_valid()); +} + +#[test] +fn test_mixed_signs() { + let set = ValidSet::new(); + let set2 = set.add_value_with_dependencies(Value::new(2, -3)); + + // Path: (0,0), (1,0), (2,0), (2,-1), (2,-2), (2,-3) + assert_eq!(set2.size(), 6); + assert!(set2.is_valid()); +} 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); +} |