Improved test coverage; renamed for simpler name convention.

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

Author: marvin-hansen

deep_causality/benches/benchmarks/bench_collection.rs

@@ -20,7 +20,7 @@ fn small_causality_collection_benchmark(criterion: &mut Criterion) {
 
     criterion.bench_function("small_causality_collection_propagation", |bencher| {
         bencher.iter(|| {
-            coll.evaluate_deterministic_propagation(&evidence, &AggregateLogic::All)
+            coll.evaluate_deterministic(&evidence, &AggregateLogic::All)
                 .unwrap()
         })
     });
@@ -32,7 +32,7 @@ fn medium_causality_collection_benchmark(criterion: &mut Criterion) {
 
     criterion.bench_function("medium_causality_collection_propagation", |bencher| {
         bencher.iter(|| {
-            coll.evaluate_deterministic_propagation(&evidence, &AggregateLogic::All)
+            coll.evaluate_deterministic(&evidence, &AggregateLogic::All)
                 .unwrap()
         })
     });
@@ -44,7 +44,7 @@ fn large_causality_collection_benchmark(criterion: &mut Criterion) {
 
     criterion.bench_function("large_causality_collection_propagation", |bencher| {
         bencher.iter(|| {
-            coll.evaluate_deterministic_propagation(&evidence, &AggregateLogic::All)
+            coll.evaluate_deterministic(&evidence, &AggregateLogic::All)
                 .unwrap()
         })
     });

deep_causality/src/traits/causable/causable_reasoning.rs

@@ -60,7 +60,7 @@ where
     ///
     /// # Errors
     /// Returns a `CausalityError` if any `Causable` item returns a non-deterministic effect.
-    fn evaluate_deterministic_propagation(
+    fn evaluate_deterministic(
         &self,
         effect: &PropagatingEffect,
         logic: &AggregateLogic,
@@ -84,7 +84,7 @@ where
     ///
     /// # Errors
     /// Returns a `CausalityError` if a `ContextualLink` is encountered.
-    fn evaluate_probabilistic_propagation(
+    fn evaluate_probabilistic(
         &self,
         effect: &PropagatingEffect,
         logic: &AggregateLogic,
@@ -115,7 +115,7 @@ where
     /// # Errors
     /// Returns a `CausalityError` if a `ContextualLink` is encountered, as it cannot be
     /// converted to a numerical probability.
-    fn evaluate_mixed_propagation(
+    fn evaluate_mixed(
         &self,
         effect: &PropagatingEffect,
         logic: &AggregateLogic,

deep_causality/tests/extensions/causable/causable_arr_tests.rs

@@ -46,14 +46,14 @@ fn test_evaluate_deterministic_propagation() {
 
     // Case 1: All succeed, chain should be deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res = col.evaluate_deterministic_propagation(&effect_success, &AggregateLogic::All);
+    let res = col.evaluate_deterministic(&effect_success, &AggregateLogic::All);
     assert!(res.is_ok());
     let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 
     // Case 2: One fails, chain should be deterministically false.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res = col.evaluate_deterministic_propagation(&effect_fail, &AggregateLogic::All);
+    let res = col.evaluate_deterministic(&effect_fail, &AggregateLogic::All);
     assert!(res.is_ok());
     let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Deterministic(false));
@@ -64,7 +64,7 @@ fn test_evaluate_probabilistic_propagation() {
     let col = get_test_causality_array(false);
 
     let effect_success = PropagatingEffect::Probabilistic(0.99);
-    let res = col.evaluate_probabilistic_propagation(&effect_success, &AggregateLogic::All, 0.5);
+    let res = col.evaluate_probabilistic(&effect_success, &AggregateLogic::All, 0.5);
     assert!(res.is_ok());
 
     let res_success = res.unwrap();
@@ -73,7 +73,7 @@ fn test_evaluate_probabilistic_propagation() {
     // Case 2: One fails (Deterministic(false) is treated as probability 0.0).
     // The chain should short-circuit and return a cumulative probability of 0.0.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res = col.evaluate_probabilistic_propagation(&effect_fail, &AggregateLogic::All, 0.5);
+    let res = col.evaluate_probabilistic(&effect_fail, &AggregateLogic::All, 0.5);
     assert!(res.is_ok());
     let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Probabilistic(0.0));
@@ -85,15 +85,15 @@ fn test_evaluate_mixed_propagation() {
 
     // Case 1: All succeed, chain remains deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res = col.evaluate_mixed_propagation(&effect_success, &AggregateLogic::All, 0.5);
+    let res = col.evaluate_mixed(&effect_success, &AggregateLogic::All, 0.5);
     assert!(res.is_ok());
     let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 
     // Case 2: One fails, chain becomes deterministically false.
     let effect_fail = PropagatingEffect::Numerical(0.1);
     let res_fail = col
-        .evaluate_mixed_propagation(&effect_fail, &AggregateLogic::All, 0.5)
+        .evaluate_mixed(&effect_fail, &AggregateLogic::All, 0.5)
         .unwrap();
     assert_eq!(res_fail, PropagatingEffect::Deterministic(false));
 }
@@ -103,7 +103,7 @@ fn test_explain() {
     let col = get_test_causality_array(true);
 
     let effect = PropagatingEffect::Numerical(0.99);
-    let res = col.evaluate_deterministic_propagation(&effect, &AggregateLogic::All);
+    let res = col.evaluate_deterministic(&effect, &AggregateLogic::All);
     assert!(res.is_ok());
 
     let res = col.explain();

deep_causality/tests/extensions/causable/causable_btree_map_tests.rs

@@ -87,14 +87,14 @@ fn test_evaluate_deterministic_propagation() {
 
     // Case 1: All succeed, chain should be deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res = map.evaluate_deterministic_propagation(&effect_success, &AggregateLogic::All);
+    let res = map.evaluate_deterministic(&effect_success, &AggregateLogic::All);
     assert!(res.is_ok());
     let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 
     // Case 2: One fails, chain should be deterministically false.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res = map.evaluate_deterministic_propagation(&effect_fail, &AggregateLogic::All);
+    let res = map.evaluate_deterministic(&effect_fail, &AggregateLogic::All);
     assert!(res.is_ok());
     let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Deterministic(false));
@@ -107,15 +107,15 @@ fn test_evaluate_probabilistic_propagation() {
     // Case 1: All succeed (Deterministic(true) is treated as probability 1.0).
     // The cumulative probability should be 1.0.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res = map.evaluate_probabilistic_propagation(&effect_success, &AggregateLogic::All, 0.5);
+    let res = map.evaluate_probabilistic(&effect_success, &AggregateLogic::All, 0.5);
     assert!(res.is_ok());
     let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Probabilistic(1.0));
 
     // Case 2: One fails (Deterministic(false) is treated as probability 0.0).
     // The chain should short-circuit and return a cumulative probability of 0.0.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res = map.evaluate_probabilistic_propagation(&effect_fail, &AggregateLogic::All, 0.5);
+    let res = map.evaluate_probabilistic(&effect_fail, &AggregateLogic::All, 0.5);
     assert!(res.is_ok());
     let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Probabilistic(0.0));
@@ -127,14 +127,14 @@ fn test_evaluate_mixed_propagation() {
 
     // Case 1: All succeed, chain remains deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res = map.evaluate_mixed_propagation(&effect_success, &AggregateLogic::All, 0.5);
+    let res = map.evaluate_mixed(&effect_success, &AggregateLogic::All, 0.5);
     assert!(res.is_ok());
     let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 
     // Case 2: One fails, chain becomes deterministically false.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res = map.evaluate_mixed_propagation(&effect_fail, &AggregateLogic::All, 0.5);
+    let res = map.evaluate_mixed(&effect_fail, &AggregateLogic::All, 0.5);
     assert!(res.is_ok());
     let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Deterministic(false));

deep_causality/tests/extensions/causable/causable_empty_tests.rs

@@ -0,0 +1,45 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+use deep_causality::{AggregateLogic, BaseCausaloid, CausableReasoning, PropagatingEffect};
+
+#[test]
+fn test_get_all_items_empty() {
+    let col: [BaseCausaloid; 0] = [];
+    let exp_len = col.len();
+    assert_eq!(exp_len, 0);
+}
+
+#[test]
+fn test_evaluate_deterministic_propagation_empty() {
+    let col: [BaseCausaloid; 0] = [];
+    let exp_len = col.len();
+    assert_eq!(exp_len, 0);
+
+    let effect_fail = PropagatingEffect::Numerical(0.1);
+    let res = col.evaluate_deterministic(&effect_fail, &AggregateLogic::All);
+    assert!(res.is_err());
+}
+
+#[test]
+fn test_evaluate_probabilistic_propagation_empty() {
+    let col: [BaseCausaloid; 0] = [];
+    let exp_len = col.len();
+    assert_eq!(exp_len, 0);
+
+    let effect_fail = PropagatingEffect::Numerical(0.1);
+    let res = col.evaluate_probabilistic(&effect_fail, &AggregateLogic::All, 0.5);
+    assert!(res.is_err());
+}
+
+#[test]
+fn test_evaluate_probabilistic_mixed_empty() {
+    let col: [BaseCausaloid; 0] = [];
+    let exp_len = col.len();
+    assert_eq!(exp_len, 0);
+
+    let effect_fail = PropagatingEffect::Numerical(0.1);
+    let res = col.evaluate_mixed(&effect_fail, &AggregateLogic::All, 0.5);
+    assert!(res.is_err());
+}

deep_causality/tests/extensions/causable/causable_map_tests.rs

@@ -103,14 +103,14 @@ fn test_evaluate_deterministic_propagation() {
 
     // Case 1: All succeed, chain should be deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res = map.evaluate_deterministic_propagation(&effect_success, &AggregateLogic::All);
+    let res = map.evaluate_deterministic(&effect_success, &AggregateLogic::All);
     assert!(res.is_ok());
     let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 
     // Case 2: One fails, chain should be deterministically false.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res = map.evaluate_deterministic_propagation(&effect_fail, &AggregateLogic::All);
+    let res = map.evaluate_deterministic(&effect_fail, &AggregateLogic::All);
     assert!(res.is_ok());
     let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Deterministic(false));
@@ -123,15 +123,15 @@ fn test_evaluate_probabilistic_propagation() {
     // Case 1: All succeed (Deterministic(true) is treated as probability 1.0).
     // The cumulative probability should be 1.0.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res = map.evaluate_probabilistic_propagation(&effect_success, &AggregateLogic::All, 0.5);
+    let res = map.evaluate_probabilistic(&effect_success, &AggregateLogic::All, 0.5);
     assert!(res.is_ok());
     let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Probabilistic(1.0));
 
     // Case 2: One fails (Deterministic(false) is treated as probability 0.0).
     // The chain should short-circuit and return a cumulative probability of 0.0.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res = map.evaluate_probabilistic_propagation(&effect_fail, &AggregateLogic::All, 0.5);
+    let res = map.evaluate_probabilistic(&effect_fail, &AggregateLogic::All, 0.5);
     assert!(res.is_ok());
     let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Probabilistic(0.0));
@@ -143,7 +143,7 @@ fn test_evaluate_mixed_propagation() {
 
     // Case 1: All succeed, chain remains deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res = map.evaluate_mixed_propagation(&effect_success, &AggregateLogic::All, 0.5);
+    let res = map.evaluate_mixed(&effect_success, &AggregateLogic::All, 0.5);
     assert!(res.is_ok());
     let res_success = res.unwrap();
     // All mixed cased evaluate
@@ -156,7 +156,7 @@ fn test_evaluate_mixed_propagation_err() {
 
     //
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res = map.evaluate_mixed_propagation(&effect_fail, &AggregateLogic::All, 0.5);
+    let res = map.evaluate_mixed(&effect_fail, &AggregateLogic::All, 0.5);
     assert!(res.is_err());
 }