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/sequence.rs | |
initial commit
Diffstat (limited to 'morphology/tests/sequence.rs')
| -rw-r--r-- | morphology/tests/sequence.rs | 554 |
1 files changed, 554 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); + } +} |