From c20b1fe88b0ab1469300bd53be14faa6a5b917a0 Mon Sep 17 00:00:00 2001 From: jacksonfu14 Date: Thu, 6 Nov 2025 07:04:52 +0100 Subject: initial commit --- morphology/tests/set.rs | 420 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 420 insertions(+) create mode 100644 morphology/tests/set.rs (limited to 'morphology/tests/set.rs') 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 = 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()); +} -- cgit v1.2.3