summaryrefslogtreecommitdiff
path: root/morphology/tests
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
initial commit
Diffstat (limited to 'morphology/tests')
-rw-r--r--morphology/tests/sequence.rs554
-rw-r--r--morphology/tests/set.rs420
-rw-r--r--morphology/tests/value.rs304
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);
+}