Merge pull request #260 from marvin-hansen/main

Re-orgnized test files

Author: marvin-hansen

deep_causality/src/utils_test/test_utils.rs

@@ -5,6 +5,13 @@
 
 use crate::*;
 
+pub fn get_context() -> BaseContext {
+    let id = 1;
+    let name = "base context";
+    let capacity = 10; // adjust as needed
+    Context::with_capacity(id, name, capacity)
+}
+
 pub fn get_test_assumption_vec() -> Vec<Assumption> {
     let a1 = get_test_assumption();
     let a2 = get_test_assumption();

deep_causality/src/utils_test/test_utils_generator.rs

@@ -2,8 +2,8 @@
  * SPDX-License-Identifier: MIT
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
-
 use crate::*;
+use std::hash::Hash;
 
 // A mock data structure used across multiple tests.
 #[derive(Debug, Clone, Eq, Hash, Copy, PartialEq, Default)]
@@ -68,3 +68,150 @@ pub type TestModel = Model<
     FloatType,
     FloatType,
 >;
+
+// A test processor to act as a destination for the generative output.
+pub struct TestProcessor<D, S, T, ST, SYM, VS, VT>
+where
+    D: Default + Datable + Copy + Clone + Hash + Eq + PartialEq,
+    S: Spatial<VS> + Clone,
+    T: Temporal<VT> + Clone,
+    ST: SpaceTemporal<VS, VT> + Clone,
+    SYM: Symbolic + Clone,
+    VS: Clone,
+    VT: Clone,
+{
+    pub causaloid_dest: Option<Causaloid<D, S, T, ST, SYM, VS, VT>>,
+    pub context_dest: Option<Context<D, S, T, ST, SYM, VS, VT>>,
+}
+
+impl<D, S, T, ST, SYM, VS, VT> Default for TestProcessor<D, S, T, ST, SYM, VS, VT>
+where
+    D: Default + Datable + Copy + Clone + Hash + Eq + PartialEq,
+    S: Spatial<VS> + Clone,
+    T: Temporal<VT> + Clone,
+    ST: SpaceTemporal<VS, VT> + Clone,
+    SYM: Symbolic + Clone,
+    VS: Clone,
+    VT: Clone,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<D, S, T, ST, SYM, VS, VT> TestProcessor<D, S, T, ST, SYM, VS, VT>
+where
+    D: Default + Datable + Copy + Clone + Hash + Eq + PartialEq,
+    S: Spatial<VS> + Clone,
+    T: Temporal<VT> + Clone,
+    ST: SpaceTemporal<VS, VT> + Clone,
+    SYM: Symbolic + Clone,
+    VS: Clone,
+    VT: Clone,
+{
+    pub fn new() -> Self {
+        Self {
+            causaloid_dest: None,
+            context_dest: None,
+        }
+    }
+}
+
+// Implement the processor trait so it can be used to test generators.
+impl<D, S, T, ST, SYM, VS, VT, G> GenerativeProcessor<D, S, T, ST, SYM, VS, VT, G>
+    for TestProcessor<D, S, T, ST, SYM, VS, VT>
+where
+    D: Default + Datable + Copy + Clone + Hash + Eq + PartialEq,
+    S: Spatial<VS> + Clone,
+    T: Temporal<VT> + Clone,
+    ST: SpaceTemporal<VS, VT> + Clone,
+    SYM: Symbolic + Clone,
+    VS: Clone,
+    VT: Clone,
+    G: Generatable<D, S, T, ST, SYM, VS, VT, G>,
+{
+    fn get_causaloid_dest(&mut self) -> &mut Option<Causaloid<D, S, T, ST, SYM, VS, VT>> {
+        &mut self.causaloid_dest
+    }
+
+    fn get_context_dest(&mut self) -> &mut Option<Context<D, S, T, ST, SYM, VS, VT>> {
+        &mut self.context_dest
+    }
+}
+
+// Type alias for brevity in tests
+pub type TestProcessorAlias = TestProcessor<
+    MockData,
+    EuclideanSpace,
+    EuclideanTime,
+    EuclideanSpacetime,
+    BaseSymbol,
+    FloatType,
+    FloatType,
+>;
+
+// Define a dummy generator for testing standalone outputs.
+pub struct DummyGenerator;
+impl
+    Generatable<
+        MockData,
+        EuclideanSpace,
+        EuclideanTime,
+        EuclideanSpacetime,
+        BaseSymbol,
+        FloatType,
+        FloatType,
+        DummyGenerator,
+    > for DummyGenerator
+{
+    fn generate(
+        &mut self,
+        _trigger: &GenerativeTrigger<MockData>,
+        _context: &Context<
+            MockData,
+            EuclideanSpace,
+            EuclideanTime,
+            EuclideanSpacetime,
+            BaseSymbol,
+            FloatType,
+            FloatType,
+        >,
+    ) -> Result<
+        GenerativeOutput<
+            MockData,
+            EuclideanSpace,
+            EuclideanTime,
+            EuclideanSpacetime,
+            BaseSymbol,
+            FloatType,
+            FloatType,
+            DummyGenerator,
+        >,
+        ModelGenerativeError,
+    > {
+        Ok(GenerativeOutput::NoOp)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_dummy_generator_no_op() {
+        let mut generator = DummyGenerator;
+        let trigger = GenerativeTrigger::ManualIntervention("test".to_string());
+
+        // Create a context of the correct type: TestContext (which is Context<MockData, ...>)
+        let context: TestContext = TestContext::with_capacity(1, "Test Context", 10);
+
+        let result = generator.generate(&trigger, &context);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_processor_default() {
+        let proc = TestProcessorAlias::default();
+        assert!(proc.causaloid_dest.is_none());
+    }
+}

deep_causality/tests/BUILD.bazel

@@ -312,7 +312,7 @@ rust_test_suite(
 rust_test_suite(
     name = "traits_tests",
     srcs = glob([
-        "traits/generatable/*_tests.rs",
+        "traits/generatable/generative_processor/*_tests.rs",
     ]),
     tags = [
         "traits_tests",