pre-commit and completing tests

Author: Edwardius

deep_core/CMakeLists.txt

@@ -37,6 +37,8 @@ set(DEEP_CORE_LIB ${PROJECT_NAME}_lib)
 add_library(${DEEP_CORE_LIB} SHARED
   src/deep_node_base.cpp
   src/tensor.cpp
+  src/backend_memory_allocator.cpp
+  src/backend_inference_executor.cpp
 )
 target_include_directories(${DEEP_CORE_LIB} PUBLIC
   $<BUILD_INTERFACE:${include_dir}>

deep_core/include/deep_core/deep_node_base.hpp

@@ -31,7 +31,8 @@
 #include "deep_core/types/tensor.hpp"
 
 // Forward declarations
-namespace bond {
+namespace bond
+{
 class Bond;
 }
 

deep_core/include/deep_core/plugin_interfaces/backend_inference_executor.hpp

@@ -39,26 +39,57 @@ class BackendInferenceExecutor
    * @brief Load a model from file
    * @param model_path Path to the model file
    * @return true if successful, false otherwise
+   * @throws std::invalid_argument if model_path is empty or file doesn't exist
    */
-  virtual bool load_model(const std::filesystem::path & model_path) = 0;
+  bool load_model(const std::filesystem::path & model_path);
 
   /**
    * @brief Run inference on input tensor
    * @param input Input tensor
    * @return Output tensor
+   * @throws std::invalid_argument if input tensor is invalid
+   * @throws std::runtime_error if no model is loaded
    */
-  virtual Tensor run_inference(Tensor input) = 0;
+  Tensor run_inference(Tensor input);
 
   /**
    * @brief Unload the currently loaded model
    */
-  virtual void unload_model() = 0;
+  void unload_model();
+
+  /**
+   * @brief Check if a model is currently loaded
+   * @return true if model is loaded, false otherwise
+   */
+  bool is_model_loaded() const
+  {
+    return model_loaded_;
+  }
 
   /**
    * @brief Get supported model formats
    * @return Vector of supported formats (e.g., "onnx", "pb")
    */
   virtual std::vector<std::string> supported_model_formats() const = 0;
+
+protected:
+  /**
+   * @brief Implementation of load_model (to be overridden by backends)
+   */
+  virtual bool load_model_impl(const std::filesystem::path & model_path) = 0;
+
+  /**
+   * @brief Implementation of run_inference (to be overridden by backends)
+   */
+  virtual Tensor run_inference_impl(Tensor input) = 0;
+
+  /**
+   * @brief Implementation of unload_model (to be overridden by backends)
+   */
+  virtual void unload_model_impl() = 0;
+
+private:
+  bool model_loaded_ = false;
 };
 
 }  // namespace deep_ros

deep_core/include/deep_core/plugin_interfaces/backend_memory_allocator.hpp

@@ -49,25 +49,45 @@ class BackendMemoryAllocator
    * @param dst Destination pointer (allocated by this allocator)
    * @param src Source pointer (host memory)
    * @param bytes Number of bytes to copy
+   * @throws std::invalid_argument if dst or src is nullptr and bytes > 0
    */
-  virtual void copy_from_host(void * dst, const void * src, size_t bytes) = 0;
+  void copy_from_host(void * dst, const void * src, size_t bytes);
 
   /**
    * @brief Copy data from allocated memory to host (CPU) memory
    * @param dst Destination pointer (host memory)
    * @param src Source pointer (allocated by this allocator)
    * @param bytes Number of bytes to copy
+   * @throws std::invalid_argument if dst or src is nullptr and bytes > 0
    */
-  virtual void copy_to_host(void * dst, const void * src, size_t bytes) = 0;
+  void copy_to_host(void * dst, const void * src, size_t bytes);
 
   /**
    * @brief Copy data between two allocations from this allocator
    * @param dst Destination pointer (allocated by this allocator)
    * @param src Source pointer (allocated by this allocator)
    * @param bytes Number of bytes to copy
+   * @throws std::invalid_argument if dst or src is nullptr and bytes > 0
    */
-  virtual void copy_device_to_device(void * dst, const void * src, size_t bytes) = 0;
+  void copy_device_to_device(void * dst, const void * src, size_t bytes);
 
+protected:
+  /**
+   * @brief Implementation of copy_from_host (to be overridden by backends)
+   */
+  virtual void copy_from_host_impl(void * dst, const void * src, size_t bytes) = 0;
+
+  /**
+   * @brief Implementation of copy_to_host (to be overridden by backends)
+   */
+  virtual void copy_to_host_impl(void * dst, const void * src, size_t bytes) = 0;
+
+  /**
+   * @brief Implementation of copy_device_to_device (to be overridden by backends)
+   */
+  virtual void copy_device_to_device_impl(void * dst, const void * src, size_t bytes) = 0;
+
+public:
   /**
    * @brief Check if this allocator manages device (non-host) memory
    * @return true if memory is on device (GPU, etc.), false if host memory

deep_core/src/backend_inference_executor.cpp

@@ -0,0 +1,67 @@
+// Copyright (c) 2025-present WATonomous. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "deep_core/plugin_interfaces/backend_inference_executor.hpp"
+
+#include <filesystem>
+#include <stdexcept>
+#include <utility>
+
+namespace deep_ros
+{
+
+bool BackendInferenceExecutor::load_model(const std::filesystem::path & model_path)
+{
+  // Validate path
+  if (model_path.empty()) {
+    throw std::invalid_argument("Empty model path provided to load_model");
+  }
+
+  // Call implementation and track state
+  bool success = load_model_impl(model_path);
+  model_loaded_ = success;
+  return success;
+}
+
+Tensor BackendInferenceExecutor::run_inference(Tensor input)
+{
+  // Validate input tensor
+  if (input.data() == nullptr) {
+    throw std::invalid_argument("Null data pointer in input tensor");
+  }
+
+  if (input.size() == 0) {
+    throw std::invalid_argument("Empty tensor provided to run_inference");
+  }
+
+  // Check for valid shape
+  if (input.shape().empty()) {
+    throw std::invalid_argument("Tensor has empty shape");
+  }
+
+  // Check if model is loaded
+  if (!model_loaded_) {
+    throw std::runtime_error("No model loaded for inference");
+  }
+
+  return run_inference_impl(std::move(input));
+}
+
+void BackendInferenceExecutor::unload_model()
+{
+  unload_model_impl();
+  model_loaded_ = false;
+}
+
+}  // namespace deep_ros

deep_core/src/backend_memory_allocator.cpp

@@ -0,0 +1,46 @@
+// Copyright (c) 2025-present WATonomous. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "deep_core/plugin_interfaces/backend_memory_allocator.hpp"
+
+#include <stdexcept>
+
+namespace deep_ros
+{
+
+void BackendMemoryAllocator::copy_from_host(void * dst, const void * src, size_t bytes)
+{
+  if (bytes > 0 && (dst == nullptr || src == nullptr)) {
+    throw std::invalid_argument("Null pointer passed to copy_from_host");
+  }
+  copy_from_host_impl(dst, src, bytes);
+}
+
+void BackendMemoryAllocator::copy_to_host(void * dst, const void * src, size_t bytes)
+{
+  if (bytes > 0 && (dst == nullptr || src == nullptr)) {
+    throw std::invalid_argument("Null pointer passed to copy_to_host");
+  }
+  copy_to_host_impl(dst, src, bytes);
+}
+
+void BackendMemoryAllocator::copy_device_to_device(void * dst, const void * src, size_t bytes)
+{
+  if (bytes > 0 && (dst == nullptr || src == nullptr)) {
+    throw std::invalid_argument("Null pointer passed to copy_device_to_device");
+  }
+  copy_device_to_device_impl(dst, src, bytes);
+}
+
+}  // namespace deep_ros

deep_core/src/tensor.cpp

@@ -76,7 +76,7 @@ Tensor::Tensor(const std::vector<size_t> & shape, DataType dtype, std::shared_pt
   if (shape_.empty()) {
     throw std::invalid_argument("Tensor shape cannot be empty");
   }
-  
+
   // Check for zero dimensions
   for (size_t dim : shape_) {
     if (dim == 0) {
@@ -102,7 +102,7 @@ Tensor::Tensor(void * data, const std::vector<size_t> & shape, DataType dtype)
   if (shape_.empty()) {
     throw std::invalid_argument("Tensor shape cannot be empty");
   }
-  
+
   // Check for zero dimensions
   for (size_t dim : shape_) {
     if (dim == 0) {

deep_test/CMakeLists.txt

@@ -102,28 +102,25 @@ if(BUILD_TESTING)
     LIBRARIES
       ${std_msgs_TARGETS}
   )
-  
+
   # Deep core tests - organized by functionality
-  add_deep_test(test_simple_tensor
-    test/test_simple_tensor.cpp
-  )
   add_deep_test(test_tensor
-    test/test_tensor.cpp
+    test/deep_core/test_tensor.cpp
     LIBRARIES
       ${DEEP_TEST_LIB}
   )
   add_deep_test(test_plugin_system
-    test/test_plugin_system.cpp
+    test/deep_core/test_plugin_system.cpp
     LIBRARIES
       ${DEEP_TEST_LIB}
   )
   add_deep_test(test_node_lifecycle
-    test/test_node_lifecycle.cpp
+    test/deep_core/test_node_lifecycle.cpp
     LIBRARIES
       ${DEEP_TEST_LIB}
   )
   add_deep_test(test_integration
-    test/test_integration.cpp
+    test/deep_core/test_integration.cpp
     LIBRARIES
       ${DEEP_TEST_LIB}
   )

deep_test/include/test_fixtures/mock_backend_fixture.hpp

@@ -15,16 +15,18 @@
 #pragma once
 
 #include <memory>
+
 #include <pluginlib/class_loader.hpp>
-#include "deep_core/plugin_interfaces/deep_backend_plugin.hpp"
+
 #include "deep_core/plugin_interfaces/backend_memory_allocator.hpp"
+#include "deep_core/plugin_interfaces/deep_backend_plugin.hpp"
 
 namespace deep_ros::test
 {
 
 /**
  * @brief Mock backend fixture for testing
- * 
+ *
  * Catch2 test fixture that provides access to the mock backend plugin
  * and its allocator for consistent testing across all packages.
  */
@@ -36,8 +38,8 @@ class MockBackendFixture
    */
   MockBackendFixture()
   {
-    loader_ = std::make_unique<pluginlib::ClassLoader<deep_ros::DeepBackendPlugin>>(
-      "deep_core", "deep_ros::DeepBackendPlugin");
+    loader_ =
+      std::make_unique<pluginlib::ClassLoader<deep_ros::DeepBackendPlugin>>("deep_core", "deep_ros::DeepBackendPlugin");
     mock_backend_ = loader_->createSharedInstance("mock_backend");
     allocator_ = mock_backend_->get_allocator();
   }
@@ -66,4 +68,4 @@ class MockBackendFixture
   std::shared_ptr<deep_ros::BackendMemoryAllocator> allocator_;
 };
 
-}  // namespace deep_ros::test
+}  // namespace deep_ros::test

deep_test/include/test_nodes/deep_test_node.hpp

@@ -65,4 +65,4 @@ class DeepTestNode : public DeepNodeBase
 };
 
 }  // namespace test
-}  // namespace deep_ros
+}  // namespace deep_ros