test(deep_causality_uncertain): Increased test coverage.

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

Author: marvin-hansen

deep_causality_uncertain/tests/extensions/bool_probabilistic_type_tests.rs

@@ -0,0 +1,50 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+use deep_causality_uncertain::{
+    FromSampledValue, IntoSampledValue, ProbabilisticType, SampledValue, UncertainError,
+};
+
+// Tests for IntoSampledValue for bool
+#[test]
+fn test_bool_into_sampled_value_true() {
+    let val = true;
+    assert_eq!(val.into_sampled_value(), SampledValue::Bool(true));
+}
+
+#[test]
+fn test_bool_into_sampled_value_false() {
+    let val = false;
+    assert_eq!(val.into_sampled_value(), SampledValue::Bool(false));
+}
+
+// Tests for FromSampledValue for bool
+#[test]
+fn test_bool_from_sampled_value_bool() {
+    let sampled = SampledValue::Bool(true);
+    let result = bool::from_sampled_value(sampled);
+    assert!(result.is_ok());
+    let val = result.unwrap();
+    assert!(val);
+}
+
+#[test]
+fn test_bool_from_sampled_value_float_err() {
+    let sampled = SampledValue::Float(0.42);
+    let result = bool::from_sampled_value(sampled);
+    // Ensure the correct error type and message is returned
+    assert!(matches!(
+        result,
+        Err(UncertainError::UnsupportedTypeError(_))
+    ));
+    if let Err(UncertainError::UnsupportedTypeError(msg)) = result {
+        assert_eq!(msg, "Expected bool SampledValue");
+    }
+}
+
+// Test for ProbabilisticType for bool
+#[test]
+fn test_bool_default_value() {
+    assert!(!bool::default_value());
+}

deep_causality_uncertain/tests/extensions/f64_probabilistic_type_tests.rs

@@ -0,0 +1,44 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+use deep_causality_uncertain::{
+    FromSampledValue, IntoSampledValue, ProbabilisticType, SampledValue, UncertainError,
+};
+
+// Test for IntoSampledValue for f64
+#[test]
+fn test_f64_into_sampled_value() {
+    let val = 42.0;
+    assert_eq!(val.into_sampled_value(), SampledValue::Float(42.0));
+}
+
+// Tests for FromSampledValue for f64
+#[test]
+fn test_f64_from_sampled_value_float() {
+    let sampled = SampledValue::Float(42.0);
+    let result = f64::from_sampled_value(sampled);
+    assert!(result.is_ok());
+    let val = result.unwrap();
+    assert_eq!(val, 42.0);
+}
+
+#[test]
+fn test_f64_from_sampled_value_bool_err() {
+    let sampled = SampledValue::Bool(true);
+    let result = f64::from_sampled_value(sampled);
+    // Ensure the correct error type and message is returned
+    assert!(matches!(
+        result,
+        Err(UncertainError::UnsupportedTypeError(_))
+    ));
+    if let Err(UncertainError::UnsupportedTypeError(msg)) = result {
+        assert_eq!(msg, "Expected f64 SampledValue");
+    }
+}
+
+// Test for ProbabilisticType for f64
+#[test]
+fn test_f64_default_value() {
+    assert_eq!(f64::default_value(), 0.0);
+}

deep_causality_uncertain/tests/extensions/mod.rs

@@ -0,0 +1,6 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+mod bool_probabilistic_type_tests;
+mod f64_probabilistic_type_tests;

deep_causality_uncertain/tests/mod.rs

@@ -5,5 +5,6 @@
 
 mod algos;
 mod errors;
+mod extensions;
 mod integration_tests;
 mod types;

deep_causality_uncertain/tests/types/cache/sampled_value_tests.rs

@@ -2,7 +2,9 @@
  * SPDX-License-Identifier: MIT
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
-use deep_causality_uncertain::SampledValue;
+use deep_causality_uncertain::{
+    FromSampledValue, IntoSampledValue, ProbabilisticType, SampledValue,
+};
 
 #[test]
 fn test_sampled_value_float_display() {
@@ -54,3 +56,37 @@ fn test_sampled_value_float_copy() {
     let copied_val = val; // Copy happens implicitly
     assert_eq!(val, copied_val);
 }
+
+// Tests for IntoSampledValue implementation
+#[test]
+fn test_into_sampled_value_float() {
+    let value = SampledValue::Float(42.0);
+    assert_eq!(value.into_sampled_value(), SampledValue::Float(42.0));
+}
+
+#[test]
+fn test_into_sampled_value_bool() {
+    let value = SampledValue::Bool(true);
+    assert_eq!(value.into_sampled_value(), SampledValue::Bool(true));
+}
+
+// Tests for FromSampledValue implementation
+#[test]
+fn test_from_sampled_value_float() {
+    let value = SampledValue::Float(42.0);
+    let result = SampledValue::from_sampled_value(value).unwrap();
+    assert_eq!(result, SampledValue::Float(42.0));
+}
+
+#[test]
+fn test_from_sampled_value_bool() {
+    let value = SampledValue::Bool(true);
+    let result = SampledValue::from_sampled_value(value).unwrap();
+    assert_eq!(result, SampledValue::Bool(true));
+}
+
+// Test for ProbabilisticType implementation
+#[test]
+fn test_default_value() {
+    assert_eq!(SampledValue::default_value(), SampledValue::Float(0.0));
+}