summaryrefslogtreecommitdiff
path: root/morphology/tests/set.rs
diff options
context:
space:
mode:
Diffstat (limited to 'morphology/tests/set.rs')
-rw-r--r--morphology/tests/set.rs420
1 files changed, 420 insertions, 0 deletions
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());
+}