summaryrefslogtreecommitdiff
path: root/morphology/tests/sequence.rs
diff options
context:
space:
mode:
authorjacksonfu14 <jackson@fashionunited.com>2025-11-06 07:04:52 +0100
committerJackson Moore <jacksonmoore@tuta.io>2025-11-06 07:04:52 +0100
commitc20b1fe88b0ab1469300bd53be14faa6a5b917a0 (patch)
tree9e41975e6f6852146216a05ba4cef09436688aa2 /morphology/tests/sequence.rs
initial commit
Diffstat (limited to 'morphology/tests/sequence.rs')
-rw-r--r--morphology/tests/sequence.rs554
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);
+ }
+}