//! Unit tests for the set module use std::collections::HashSet; use morphology::{ValidSet, Value}; use morphology::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 = morphology::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()); }