Increased test coverage of PropagatingEffect

Signed-off-by: Marvin Hansen <[email protected]>

Author: marvin-hansen

deep_causality/src/types/reasoning_types/propagating_effect/mod.rs

@@ -13,7 +13,7 @@ mod display;
 mod partial_eq;
 
 // The graph type alias, updated to be recursive on the new unified enum.
-pub type EffectGraph = UltraGraph<crate::PropagatingEffect>;
+pub type EffectGraph = UltraGraph<PropagatingEffect>;
 
 /// Unified data and control-flow container for causal reasoning.
 ///
@@ -43,11 +43,11 @@ pub enum PropagatingEffect {
     Halting,
     /// A dispatch command that directs a reasoning engine to jump to a specific
     /// next causaloid with the specified id (`usize`) and provide it with the encapsulated effect as its new input.
-    RelayTo(usize, Box<crate::PropagatingEffect>),
+    RelayTo(usize, Box<PropagatingEffect>),
 }
 
 // Predicate methods
-impl crate::PropagatingEffect {
+impl PropagatingEffect {
     pub fn is_none(&self) -> bool {
         matches!(self, PropagatingEffect::None)
     }
@@ -117,10 +117,6 @@ impl PropagatingEffect {
         crate::PropagatingEffect::Map(HashMap::new())
     }
 
-    pub fn new_map_with_capacity(size: usize) -> Self {
-        crate::PropagatingEffect::Map(HashMap::with_capacity(size))
-    }
-
     /// Inserts a key-value pair into an Effect Map.
     /// Panics if the Effect is not a Map variant.
     pub fn insert(&mut self, key: IdentificationValue, value: crate::PropagatingEffect) {

deep_causality/tests/types/reasoning_types/propagating_effect_tests.rs

@@ -154,66 +154,86 @@ fn test_clone() {
 
 #[test]
 fn test_partial_eq() {
+    // None variant
     let effect1 = PropagatingEffect::None;
     let effect2 = PropagatingEffect::None;
     let effect3 = PropagatingEffect::Deterministic(false);
     assert_eq!(effect1, effect2);
     assert_ne!(effect1, effect3);
 
+    // Deterministic variant
     let effect1 = PropagatingEffect::Deterministic(true);
     let effect2 = PropagatingEffect::Deterministic(true);
     let effect3 = PropagatingEffect::Deterministic(false);
     assert_eq!(effect1, effect2);
     assert_ne!(effect1, effect3);
 
+    // Numerical variant
     let effect1 = PropagatingEffect::Numerical(1.0);
     let effect2 = PropagatingEffect::Numerical(1.0);
     let effect3 = PropagatingEffect::Numerical(23.0);
     assert_eq!(effect1, effect2);
     assert_ne!(effect1, effect3);
 
+    // Probabilistic variant
     let effect4 = PropagatingEffect::Probabilistic(0.5);
     let effect5 = PropagatingEffect::Probabilistic(0.5);
     let effect6 = PropagatingEffect::Probabilistic(0.6);
     assert_eq!(effect4, effect5);
     assert_ne!(effect4, effect6);
 
+    // ContextualLink variant
     let effect7 = PropagatingEffect::ContextualLink(1, 2);
     let effect8 = PropagatingEffect::ContextualLink(1, 2);
     let effect9 = PropagatingEffect::ContextualLink(2, 1);
     assert_eq!(effect7, effect8);
     assert_ne!(effect7, effect9);
 
-    assert_ne!(effect1, effect4);
-    assert_ne!(effect1, effect7);
-    assert_ne!(effect4, effect7);
-
-    let map1 = HashMap::new();
+    // Map variant
+    let mut map1 = HashMap::new();
+    map1.insert(1, Box::new(PropagatingEffect::Numerical(1.0)));
+    map1.insert(2, Box::new(PropagatingEffect::Deterministic(true)));
+    let effect10 = PropagatingEffect::Map(map1.clone());
 
-    let effect1 = PropagatingEffect::Map(map1.clone());
-    let effect2 = PropagatingEffect::Map(map1);
-    let effect3 = PropagatingEffect::None;
-    assert_eq!(effect1, effect2);
-    assert_ne!(effect1, effect3);
+    let mut map2 = HashMap::new();
+    map2.insert(1, Box::new(PropagatingEffect::Numerical(1.0)));
+    map2.insert(2, Box::new(PropagatingEffect::Deterministic(true)));
+    let effect11 = PropagatingEffect::Map(map2.clone());
 
-    let graph = Arc::new(UltraGraph::new());
-    let effect1 = PropagatingEffect::Graph(graph.clone());
-    let effect2 = PropagatingEffect::Graph(graph.clone());
-    let effect3 = PropagatingEffect::None;
-    assert_eq!(effect1, effect2);
-    assert_ne!(effect1, effect3);
+    let mut map3 = HashMap::new();
+    map3.insert(1, Box::new(PropagatingEffect::Numerical(1.0)));
+    map3.insert(3, Box::new(PropagatingEffect::Deterministic(false))); // Different key and value
+    let effect12 = PropagatingEffect::Map(map3.clone());
 
-    let effect1 = PropagatingEffect::Halting;
-    let effect2 = PropagatingEffect::Halting;
-    let effect3 = PropagatingEffect::Deterministic(false);
-    assert_eq!(effect1, effect2);
-    assert_ne!(effect1, effect3);
+    assert_eq!(effect10, effect11);
+    assert_ne!(effect10, effect12);
 
-    let effect7 = PropagatingEffect::RelayTo(1, Box::new(PropagatingEffect::None));
-    let effect8 = PropagatingEffect::RelayTo(1, Box::new(PropagatingEffect::None));
-    let effect9 = PropagatingEffect::None;
-    assert_eq!(effect7, effect8);
-    assert_ne!(effect7, effect9);
+    // Graph variant
+    let graph1 = Arc::new(UltraGraph::new());
+    let graph2 = Arc::new(UltraGraph::new());
+    // let graph3 = Arc::new(UltraGraph::new());
+
+    let effect13 = PropagatingEffect::Graph(Arc::clone(&graph1));
+    let effect14 = PropagatingEffect::Graph(Arc::clone(&graph1)); // Same Arc
+    let effect15 = PropagatingEffect::Graph(Arc::clone(&graph2)); // Different Arc, same content
+    assert_eq!(effect13, effect14); // Should be equal due to Arc::ptr_eq
+    assert_ne!(effect13, effect15); // Should be not equal due to Arc::ptr_eq
+
+    // Halting variant
+    let effect16 = PropagatingEffect::Halting;
+    let effect17 = PropagatingEffect::Halting;
+    let effect18 = PropagatingEffect::Deterministic(false);
+    assert_eq!(effect16, effect17);
+    assert_ne!(effect16, effect18);
+
+    // RelayTo variant
+    let effect19 = PropagatingEffect::RelayTo(1, Box::new(PropagatingEffect::Deterministic(true)));
+    let effect20 = PropagatingEffect::RelayTo(1, Box::new(PropagatingEffect::Deterministic(true)));
+    let effect21 = PropagatingEffect::RelayTo(2, Box::new(PropagatingEffect::Deterministic(true)));
+    let effect22 = PropagatingEffect::RelayTo(1, Box::new(PropagatingEffect::Deterministic(false)));
+    assert_eq!(effect19, effect20);
+    assert_ne!(effect19, effect21);
+    assert_ne!(effect19, effect22);
 }
 
 #[test]
@@ -274,6 +294,59 @@ fn test_map_variant() {
     assert!(new_map.get_deterministic_from_map(99).is_err());
 }
 
+#[test]
+#[should_panic(expected = "Cannot insert into PropagatingEffect that is not a Map variant")]
+fn test_insert_panic() {
+    let mut effect = PropagatingEffect::None;
+    effect.insert(1, PropagatingEffect::Numerical(1.0));
+}
+
+#[test]
+fn test_get_numerical_from_map_error_not_map() {
+    let effect = PropagatingEffect::None;
+    let result = effect.get_numerical_from_map(1);
+    assert!(result.is_err());
+    assert_eq!(
+        result.unwrap_err().to_string(),
+        "CausalityError: Cannot get value by key from PropagatingEffect that is not a Map variant"
+    );
+}
+
+#[test]
+fn test_get_numerical_from_map_error_wrong_type() {
+    let mut map = PropagatingEffect::new_map();
+    map.insert(1, PropagatingEffect::Deterministic(true));
+    let result = map.get_numerical_from_map(1);
+    assert!(result.is_err());
+    assert_eq!(
+        result.unwrap_err().to_string(),
+        "CausalityError: Effect for key '1' is not of type Numerical"
+    );
+}
+
+#[test]
+fn test_get_deterministic_from_map_error_not_map() {
+    let effect = PropagatingEffect::None;
+    let result = effect.get_deterministic_from_map(1);
+    assert!(result.is_err());
+    assert_eq!(
+        result.unwrap_err().to_string(),
+        "CausalityError: Cannot get value by key from PropagatingEffect that is not a Map variant"
+    );
+}
+
+#[test]
+fn test_get_deterministic_from_map_error_wrong_type() {
+    let mut map = PropagatingEffect::new_map();
+    map.insert(1, PropagatingEffect::Numerical(1.0));
+    let result = map.get_deterministic_from_map(1);
+    assert!(result.is_err());
+    assert_eq!(
+        result.unwrap_err().to_string(),
+        "CausalityError: Effect for key '1' is not of type Deterministic"
+    );
+}
+
 #[test]
 fn test_graph_variant() {
     let graph1 = Arc::new(UltraGraph::new());