//! 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, None); // 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, None); // 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); } }