test(deep_causality_uncertain): Increased test coverage.

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

Author: marvin-hansen

deep_causality_uncertain/src/types/cache/global_cache.rs

@@ -119,9 +119,7 @@ where
     }
     #[cfg(test)]
     {
-        GLOBAL_SAMPLE_CACHE.with(|cache_once_lock| {
-            let cache = cache_once_lock.get_or_init(GlobalSampleCache::new);
-            closure(cache)
-        })
+        GLOBAL_SAMPLE_CACHE
+            .with(|cache_once_lock| closure(cache_once_lock.get_or_init(GlobalSampleCache::new)))
     }
 }

deep_causality_uncertain/src/types/computation/node/node_id.rs

@@ -4,6 +4,7 @@
  */
 
 use crate::types::computation::node::computation_node::NEXT_NODE_ID;
+use std::fmt;
 use std::sync::atomic::Ordering;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -20,3 +21,15 @@ impl Default for NodeId {
         Self::new()
     }
 }
+
+impl From<usize> for NodeId {
+    fn from(item: usize) -> Self {
+        NodeId(item)
+    }
+}
+
+impl fmt::Display for NodeId {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "NodeId({})", self.0)
+    }
+}

deep_causality_uncertain/tests/errors/uncertain_error_tests.rs

@@ -4,11 +4,14 @@
  */
 
 use deep_causality_uncertain::UncertainError;
+// For testing From methods
+use rand_distr::uniform::Error as UniformError;
+use rand_distr::{BernoulliError, NormalError};
+// For testing From impl
+use rusty_fork::rusty_fork_test;
 use std::error::Error;
 // For the Error trait methods
 use ultragraph::GraphError;
-// For testing From impl
-use rusty_fork::rusty_fork_test;
 
 rusty_fork_test! {
     #[test]
@@ -82,4 +85,41 @@ rusty_fork_test! {
         );
         assert!(err.source().is_none());
     }
+
+    #[test]
+    fn test_from_uniform_error() {
+        let err = UniformError::EmptyRange;
+        let uncertain_error: UncertainError = err.into();
+        match uncertain_error {
+            UncertainError::UniformDistributionError(msg) => {
+                assert!(msg.contains("low > high (or equal if exclusive)"));
+            }
+            _ => panic!("Expected UniformDistributionError"),
+        }
+    }
+
+    #[test]
+    fn test_from_bernoulli_error() {
+        let err = BernoulliError::InvalidProbability;
+        let uncertain_error: UncertainError = err.into();
+        match uncertain_error {
+            UncertainError::BernoulliDistributionError(msg) => {
+                assert!(msg.contains("p is outside [0, 1] in Bernoulli distribution"));
+            }
+            _ => panic!("Expected BernoulliDistributionError"),
+        }
+    }
+
+    #[test]
+    fn test_from_normal_error() {
+        let err = NormalError::MeanTooSmall;
+        let uncertain_error: UncertainError = err.into();
+        match uncertain_error {
+            UncertainError::NormalDistributionError(msg) => {
+                assert!(msg.contains("mean < 0 or NaN in log-normal"));
+            }
+            _ => panic!("Expected NormalDistributionError"),
+        }
+    }
+
 }

deep_causality_uncertain/tests/types/cache/cache_tests.rs

@@ -3,7 +3,7 @@
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 
-use deep_causality_uncertain::{SampledValue, Uncertain, with_global_cache};
+use deep_causality_uncertain::{GlobalSampleCache, SampledValue, Uncertain, with_global_cache};
 use rusty_fork::rusty_fork_test;
 
 rusty_fork_test! {
@@ -55,6 +55,21 @@ rusty_fork_test! {
         });
     }
 
+        #[test]
+    fn test_cache_default() {
+                let uncertain_obj = Uncertain::<f64>::point(1.0);
+        let key = (uncertain_obj.id(), 200);
+        let value = SampledValue::Float(123.45);
+
+        let cache = GlobalSampleCache::default();
+
+        cache.insert(key, value);
+        let v = cache.get(&key);
+        assert!(v.is_some());
+        let result = v.unwrap();
+        assert_eq!(result, value);
+    }
+
     #[test]
     fn test_cache_get_and_insert() {
 

deep_causality_uncertain/tests/types/computation/node/mod.rs

@@ -2,4 +2,5 @@
  * SPDX-License-Identifier: MIT
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
+mod node_id_tests;
 mod node_tests;

deep_causality_uncertain/tests/types/computation/node/node_id_tests.rs

@@ -0,0 +1,49 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+use deep_causality_uncertain::NodeId;
+
+use rusty_fork::rusty_fork_test;
+
+rusty_fork_test! {
+
+#[test]
+fn test_new_node_id() {
+    let initial_id = NodeId::new();
+    let node_id1 = NodeId::from(0);
+
+    assert_eq!(initial_id, node_id1);
+}
+
+#[test]
+fn test_default_node_id() {
+    let initial_id = NodeId::default();
+    let node_id = NodeId::from(0);
+    assert_eq!(initial_id, node_id);
+}
+
+#[test]
+fn test_node_id_debug_trait() {
+    let node_id = NodeId::new();
+    let debug_string = format!("{:?}", node_id);
+    assert!(debug_string.contains(&node_id.to_string()));
+    assert!(debug_string.starts_with("NodeId("));
+    assert!(debug_string.ends_with(")"));
+}
+
+#[test]
+fn test_node_id_clone_trait() {
+    let node_id1 = NodeId::new();
+    let node_id2 = node_id1;
+    assert_eq!(node_id1, node_id2);
+}
+
+#[test]
+fn test_node_id_copy_trait() {
+    let node_id1 = NodeId::new();
+    let node_id2 = node_id1; // This is a copy, not a move
+    assert_eq!(node_id1, node_id2);
+}
+
+}

deep_causality_uncertain/tests/types/distribution/distribution_tests.rs

@@ -3,7 +3,8 @@
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 use deep_causality_uncertain::{
-    BernoulliParams, DistributionEnum, NormalDistributionParams, UniformDistributionParams,
+    BernoulliParams, DistributionEnum, NormalDistributionParams, UncertainError,
+    UniformDistributionParams,
 };
 use rand::rng;
 
@@ -130,3 +131,48 @@ fn test_distribution_enum_display() {
         "Distribution: Bernoulli { D: BernoulliParams { p: 0.70 } }"
     );
 }
+
+#[test]
+fn test_sample_f64_unsupported_type_error() {
+    let mut rng = rng();
+    let bernoulli_dist: DistributionEnum<f64> =
+        DistributionEnum::Bernoulli(BernoulliParams { p: 0.5 });
+    let result = bernoulli_dist.sample(&mut rng);
+
+    dbg!(&result);
+
+    assert!(matches!(
+        result,
+        Err(UncertainError::UnsupportedTypeError(_))
+    ));
+}
+
+#[test]
+fn test_sample_bool_unsupported_type_error() {
+    let mut rng = rng();
+    let normal_dist: DistributionEnum<bool> = DistributionEnum::Normal(NormalDistributionParams {
+        mean: 0.0,
+        std_dev: 1.0,
+    });
+    let result = normal_dist.sample(&mut rng);
+
+    dbg!(&result);
+
+    assert!(matches!(
+        result,
+        Err(UncertainError::UnsupportedTypeError(_))
+    ));
+
+    let uniform_dist: DistributionEnum<bool> =
+        DistributionEnum::Uniform(UniformDistributionParams {
+            low: 0.0,
+            high: 1.0,
+        });
+    let result = uniform_dist.sample(&mut rng);
+    dbg!(&result);
+
+    assert!(matches!(
+        result,
+        Err(UncertainError::UnsupportedTypeError(_))
+    ));
+}

deep_causality_uncertain/tests/types/sampler/sequential_sampler_tests.rs

@@ -426,3 +426,143 @@ fn test_sequential_sampler_error_propagation_from_distribution() {
         e => panic!("Expected BernoulliDistributionError, got {:?}", e),
     }
 }
+
+#[test]
+fn test_sequential_sampler_logical_op_not_wrong_number_of_operands() {
+    let sampler = SequentialSampler;
+    let op1 = Arc::new(ComputationNode::LeafBool {
+        node_id: NodeId::new(),
+        dist: DistributionEnum::Point(true),
+    });
+    let op2 = Arc::new(ComputationNode::LeafBool {
+        node_id: NodeId::new(),
+        dist: DistributionEnum::Point(false),
+    });
+    let root_node = Arc::new(ComputationNode::LogicalOp {
+        node_id: NodeId::new(),
+        op: LogicalOperator::Not,
+        operands: vec![Box::new((*op1).clone()), Box::new((*op2).clone())], // Should be 1
+    });
+    let res = sampler.sample(&root_node);
+    assert!(res.is_err());
+    match res.err().unwrap() {
+        UncertainError::UnsupportedTypeError(msg) => {
+            assert_eq!(msg, "NOT expects exactly 1 operand");
+        }
+        e => panic!("Expected UnsupportedTypeError, got {:?}", e),
+    }
+}
+
+#[test]
+fn test_sequential_sampler_logical_op_not_with_zero_operands() {
+    let sampler = SequentialSampler;
+    let root_node = Arc::new(ComputationNode::LogicalOp {
+        node_id: NodeId::new(),
+        op: LogicalOperator::Not,
+        operands: vec![], // Zero operands
+    });
+    let res = sampler.sample(&root_node);
+    assert!(res.is_err());
+    match res.err().unwrap() {
+        UncertainError::UnsupportedTypeError(msg) => {
+            assert_eq!(msg, "NOT expects exactly 1 operand");
+        }
+        e => panic!("Expected UnsupportedTypeError, got {:?}", e),
+    }
+}
+
+#[test]
+fn test_sequential_sampler_logical_op_and_wrong_number_of_operands() {
+    let sampler = SequentialSampler;
+    let op1 = Arc::new(ComputationNode::LeafBool {
+        node_id: NodeId::new(),
+        dist: DistributionEnum::Point(true),
+    });
+    let root_node = Arc::new(ComputationNode::LogicalOp {
+        node_id: NodeId::new(),
+        op: LogicalOperator::And,
+        operands: vec![Box::new((*op1).clone())], // Should be 2
+    });
+    let res = sampler.sample(&root_node);
+    assert!(res.is_err());
+    match res.err().unwrap() {
+        UncertainError::UnsupportedTypeError(msg) => {
+            assert_eq!(msg, "Binary logical op expects exactly 2 operands");
+        }
+        e => panic!("Expected UnsupportedTypeError, got {:?}", e),
+    }
+}
+
+#[test]
+fn test_sequential_sampler_logical_op_or_with_three_operands() {
+    let sampler = SequentialSampler;
+    let op1 = Arc::new(ComputationNode::LeafBool {
+        node_id: NodeId::new(),
+        dist: DistributionEnum::Point(true),
+    });
+    let op2 = Arc::new(ComputationNode::LeafBool {
+        node_id: NodeId::new(),
+        dist: DistributionEnum::Point(false),
+    });
+    let op3 = Arc::new(ComputationNode::LeafBool {
+        node_id: NodeId::new(),
+        dist: DistributionEnum::Point(true),
+    });
+    let root_node = Arc::new(ComputationNode::LogicalOp {
+        node_id: NodeId::new(),
+        op: LogicalOperator::Or,
+        operands: vec![
+            Box::new((*op1).clone()),
+            Box::new((*op2).clone()),
+            Box::new((*op3).clone()),
+        ], // Three operands
+    });
+    let res = sampler.sample(&root_node);
+    assert!(res.is_err());
+    match res.err().unwrap() {
+        UncertainError::UnsupportedTypeError(msg) => {
+            assert_eq!(msg, "Binary logical op expects exactly 2 operands");
+        }
+        e => panic!("Expected UnsupportedTypeError, got {:?}", e),
+    }
+}
+
+#[test]
+fn test_sequential_sampler_logical_op_nor_true() {
+    let sampler = SequentialSampler;
+    let op1 = Arc::new(ComputationNode::LeafBool {
+        node_id: NodeId::new(),
+        dist: DistributionEnum::Point(false),
+    });
+    let op2 = Arc::new(ComputationNode::LeafBool {
+        node_id: NodeId::new(),
+        dist: DistributionEnum::Point(false),
+    });
+    let root_node = Arc::new(ComputationNode::LogicalOp {
+        node_id: NodeId::new(),
+        op: LogicalOperator::NOR,
+        operands: vec![Box::new((*op1).clone()), Box::new((*op2).clone())],
+    });
+    let result = sampler.sample(&root_node).unwrap();
+    assert_eq!(result, SampledValue::Bool(true));
+}
+
+#[test]
+fn test_sequential_sampler_logical_op_nor_false() {
+    let sampler = SequentialSampler;
+    let op1 = Arc::new(ComputationNode::LeafBool {
+        node_id: NodeId::new(),
+        dist: DistributionEnum::Point(true),
+    });
+    let op2 = Arc::new(ComputationNode::LeafBool {
+        node_id: NodeId::new(),
+        dist: DistributionEnum::Point(false),
+    });
+    let root_node = Arc::new(ComputationNode::LogicalOp {
+        node_id: NodeId::new(),
+        op: LogicalOperator::NOR,
+        operands: vec![Box::new((*op1).clone()), Box::new((*op2).clone())],
+    });
+    let result = sampler.sample(&root_node).unwrap();
+    assert_eq!(result, SampledValue::Bool(false));
+}