test: add unit tests for new utility functions

Add comprehensive unit tests for refactoring utilities:

- TensorHelpersTest: Test toSpan<T> for Tensor and EValue conversions
  * Float and int32 tensors
  * Multidimensional tensors
  * Empty tensors
  * Type safety and const correctness

- ComputerVisionProcessingTest: Test extractDetectionData
  * Single and multiple detections
  * Various indices and label formats
  * Edge cases (negative coords, fractional values)

- FrameTransformTest: Test inverseRotateBboxes batch helper
  * Batch rotation of multiple detections
  * Empty containers and single detection
  * Preservation of non-bbox fields

Updated CMakeLists.txt to register new test executables.

Author: benITo47

packages/react-native-executorch/common/rnexecutorch/models/BaseModel.h

@@ -53,84 +53,24 @@ class BaseModel {
 
   std::size_t memorySizeLowerBound{0};
 
-  /**
-   * @brief Ensures the specified method is loaded, unloading any previous
-   * method if necessary.
-   *
-   * This helper is useful for models that support multiple methods with
-   * different input sizes (e.g., "forward_384", "forward_512", "forward_640").
-   *
-   * @param methodName Name of the method to load (e.g., "forward",
-   * "forward_384").
-   * @throws RnExecutorchError if the method cannot be loaded or if methodName
-   * is empty.
-   */
+  /// Loads methodName, unloading any previously loaded method first.
+  /// Useful for multi-method models (e.g., "forward_384", "forward_640").
   void ensureMethodLoaded(const std::string &methodName);
 
-  /**
-   * @brief Validate and get input shape for model
-   *
-   * Validates that the model has at least one input tensor and that the first
-   * input has the minimum required dimensions.
-   *
-   * @param methodName Method to get shapes for (default: "forward")
-   * @param minDimensions Minimum expected dimensions (default: 2)
-   * @throws RnExecutorchError if validation fails (no inputs or insufficient
-   * dimensions)
-   * @return The first input shape vector
-   */
   std::vector<int32_t>
   validateAndGetInputShape(const std::string &methodName = "forward",
                            size_t minDimensions = 2) const;
 
-  /**
-   * @brief Execute forward and throw on error
-   *
-   * Convenience helper that calls forward() and throws RnExecutorchError if
-   * the result is not ok. Reduces error-checking boilerplate in model
-   * implementations.
-   *
-   * @param input Single input value for the forward method
-   * @param contextMessage Custom error message (default: generic message)
-   * @return std::vector<EValue> The successful forward result
-   * @throws RnExecutorchError if forward fails
-   */
   std::vector<EValue>
   forwardOrThrow(const EValue &input,
                  const std::string &contextMessage =
                      "Model forward failed. Ensure input is correct.") const;
 
-  /**
-   * @brief Execute forward with multiple inputs and throw on error
-   *
-   * Convenience helper that calls forward() and throws RnExecutorchError if
-   * the result is not ok. Reduces error-checking boilerplate in model
-   * implementations.
-   *
-   * @param inputs Vector of input values for the forward method
-   * @param contextMessage Custom error message (default: generic message)
-   * @return std::vector<EValue> The successful forward result
-   * @throws RnExecutorchError if forward fails
-   */
   std::vector<EValue>
   forwardOrThrow(const std::vector<EValue> &inputs,
                  const std::string &contextMessage =
                      "Model forward failed. Ensure input is correct.") const;
 
-  /**
-   * @brief Execute named method and throw on error
-   *
-   * Convenience helper that calls execute() and throws RnExecutorchError if
-   * the result is not ok. Reduces error-checking boilerplate in model
-   * implementations.
-   *
-   * @param methodName Name of the method to execute
-   * @param inputs Vector of input values for the method
-   * @param contextMessage Custom error message (default: auto-generated from
-   * method name)
-   * @return std::vector<EValue> The successful execution result
-   * @throws RnExecutorchError if execution fails
-   */
   std::vector<EValue>
   executeOrThrow(const std::string &methodName,
                  const std::vector<EValue> &inputs,

packages/react-native-executorch/common/rnexecutorch/models/VisionModel.h

@@ -85,16 +85,11 @@ class VisionModel : public BaseModel {
   /// Set once by each subclass constructor to avoid per-frame metadata lookups.
   std::vector<int32_t> modelInputShape_;
 
-  /// Normalization mean values (RGB channels).
-  /// Optional: set via initNormalization() for models expecting normalized
-  /// inputs (e.g., ImageNet preprocessing). Leave as nullopt for models with
-  /// built-in normalization or raw pixel input expectations.
+  /// Per-channel normalization mean (RGB). nullopt = no normalization applied.
   std::optional<cv::Scalar> normMean_;
 
-  /// Normalization standard deviation values (RGB channels).
-  /// Optional: set via initNormalization() for models expecting normalized
-  /// inputs (e.g., ImageNet preprocessing). Leave as nullopt for models with
-  /// built-in normalization or raw pixel input expectations.
+  /// Per-channel normalization std-dev (RGB). nullopt = no normalization
+  /// applied.
   std::optional<cv::Scalar> normStd_;
 
   /**
@@ -135,57 +130,30 @@ class VisionModel : public BaseModel {
   virtual cv::Size modelInputSize() const;
 
   /**
-   * @brief Get model input spatial dimensions for a specific method.
+   * @brief Get input size for a specific method (last two shape dims).
    *
    * Useful for multi-method models with different input sizes per method.
-   * Returns the last two dimensions of the input shape as cv::Size.
-   *
-   * @param methodName Method to query (uses currentlyLoadedMethod_ if empty)
-   * @return Size (width, height) of the model input for the specified method
-   * @throws RnExecutorchError if method metadata cannot be retrieved
+   * Falls back to currentlyLoadedMethod_ when methodName is empty.
    */
   cv::Size getModelInputSize(const std::string &methodName = "") const;
 
   /**
-   * @brief Initialize normalization parameters from vectors
-   *
-   * Validates size == 3 and converts to cv::Scalar.
-   * Logs warning if invalid but non-empty. Sets nullopt if empty/invalid.
+   * @brief Set normMean_/normStd_ from float vectors.
    *
-   * @param normMean Mean values for RGB channels (expected size: 3)
-   * @param normStd Standard deviation values for RGB channels (expected size:
-   * 3)
+   * Expects size == 3. Logs a warning and ignores if non-empty but wrong size.
    */
   void initNormalization(const std::vector<float> &normMean,
                          const std::vector<float> &normStd);
 
-  /**
-   * @brief Create input tensor from preprocessed image
-   *
-   * Applies normalization if normMean_ and normStd_ are set.
-   *
-   * @param preprocessed Preprocessed image (resized, RGB format)
-   * @return TensorPtr ready for model input
-   */
+  /// Builds input tensor from a preprocessed image.
+  /// Applies normalization if normMean_/normStd_ are set, skips it otherwise.
   TensorPtr createInputTensor(const cv::Mat &preprocessed) const;
 
-  /**
-   * @brief Load and convert image from path to RGB format
-   *
-   * Common preprocessing: readImage (BGR) → convert to RGB
-   *
-   * @param imageSource Path to the image file
-   * @return cv::Mat in RGB format
-   */
+  /// Reads image from path and converts BGR → RGB.
   cv::Mat loadImageToRGB(const std::string &imageSource) const;
 
-  /**
-   * @brief Process camera frame with rotation support
-   *
-   * @param runtime JSI runtime
-   * @param frameData JSI value containing frame data from VisionCamera
-   * @return Tuple of {rotated RGB frame, orientation info, original size}
-   */
+  /// Extracts a camera frame, applies rotation, and returns
+  /// {rotated frame, orientation, original size}.
   std::tuple<cv::Mat, utils::FrameOrientation, cv::Size>
   loadFrameRotated(jsi::Runtime &runtime, const jsi::Value &frameData) const;
 

packages/react-native-executorch/common/rnexecutorch/tests/CMakeLists.txt

@@ -171,6 +171,13 @@ add_rn_test(FrameTransformTests unit/FrameTransformTest.cpp
     LIBS opencv_deps
 )
 
+add_rn_test(TensorHelpersTest unit/TensorHelpersTest.cpp)
+
+add_rn_test(ComputerVisionProcessingTest unit/ComputerVisionProcessingTest.cpp
+    SOURCES
+        ${RNEXECUTORCH_DIR}/utils/computer_vision/Processing.cpp
+)
+
 add_rn_test(BaseModelTests integration/BaseModelTest.cpp)
 
 add_rn_test(VisionModelTests integration/VisionModelTest.cpp

packages/react-native-executorch/common/rnexecutorch/tests/unit/ComputerVisionProcessingTest.cpp

@@ -0,0 +1,163 @@
+#include <gtest/gtest.h>
+#include <rnexecutorch/utils/computer_vision/Processing.h>
+#include <rnexecutorch/utils/computer_vision/Types.h>
+#include <vector>
+
+using namespace rnexecutorch::utils::computer_vision;
+
+// ============================================================================
+// extractDetectionData — Extract bbox, score, label from raw tensor data
+// ============================================================================
+
+TEST(ExtractDetectionData, SingleDetection) {
+  // Format: bboxData = [x1, y1, x2, y2] per detection
+  //         scoresData = [score, label] per detection
+  std::vector<float> bboxData = {10.0f, 20.0f, 100.0f, 200.0f};
+  std::vector<float> scoresData = {0.95f, 5.0f};
+
+  auto [bbox, score, label] =
+      extractDetectionData(bboxData.data(), scoresData.data(), 0);
+
+  EXPECT_FLOAT_EQ(bbox.x1, 10.0f);
+  EXPECT_FLOAT_EQ(bbox.y1, 20.0f);
+  EXPECT_FLOAT_EQ(bbox.x2, 100.0f);
+  EXPECT_FLOAT_EQ(bbox.y2, 200.0f);
+  EXPECT_FLOAT_EQ(score, 0.95f);
+  EXPECT_EQ(label, 5);
+}
+
+TEST(ExtractDetectionData, MultipleDetections_FirstIndex) {
+  std::vector<float> bboxData = {
+      10.0f,  20.0f,  100.0f, 200.0f, // Detection 0
+      150.0f, 50.0f,  250.0f, 150.0f, // Detection 1
+      300.0f, 100.0f, 400.0f, 300.0f  // Detection 2
+  };
+  std::vector<float> scoresData = {
+      0.95f, 5.0f, // Detection 0: score, label
+      0.85f, 3.0f, // Detection 1
+      0.75f, 12.0f // Detection 2
+  };
+
+  auto [bbox, score, label] =
+      extractDetectionData(bboxData.data(), scoresData.data(), 0);
+
+  EXPECT_FLOAT_EQ(bbox.x1, 10.0f);
+  EXPECT_FLOAT_EQ(bbox.y1, 20.0f);
+  EXPECT_FLOAT_EQ(bbox.x2, 100.0f);
+  EXPECT_FLOAT_EQ(bbox.y2, 200.0f);
+  EXPECT_FLOAT_EQ(score, 0.95f);
+  EXPECT_EQ(label, 5);
+}
+
+TEST(ExtractDetectionData, MultipleDetections_SecondIndex) {
+  std::vector<float> bboxData = {
+      10.0f,  20.0f,  100.0f, 200.0f, // Detection 0
+      150.0f, 50.0f,  250.0f, 150.0f, // Detection 1
+      300.0f, 100.0f, 400.0f, 300.0f  // Detection 2
+  };
+  std::vector<float> scoresData = {
+      0.95f, 5.0f, // Detection 0
+      0.85f, 3.0f, // Detection 1
+      0.75f, 12.0f // Detection 2
+  };
+
+  auto [bbox, score, label] =
+      extractDetectionData(bboxData.data(), scoresData.data(), 1);
+
+  EXPECT_FLOAT_EQ(bbox.x1, 150.0f);
+  EXPECT_FLOAT_EQ(bbox.y1, 50.0f);
+  EXPECT_FLOAT_EQ(bbox.x2, 250.0f);
+  EXPECT_FLOAT_EQ(bbox.y2, 150.0f);
+  EXPECT_FLOAT_EQ(score, 0.85f);
+  EXPECT_EQ(label, 3);
+}
+
+TEST(ExtractDetectionData, MultipleDetections_ThirdIndex) {
+  std::vector<float> bboxData = {
+      10.0f,  20.0f,  100.0f, 200.0f, // Detection 0
+      150.0f, 50.0f,  250.0f, 150.0f, // Detection 1
+      300.0f, 100.0f, 400.0f, 300.0f  // Detection 2
+  };
+  std::vector<float> scoresData = {
+      0.95f, 5.0f, // Detection 0
+      0.85f, 3.0f, // Detection 1
+      0.75f, 12.0f // Detection 2
+  };
+
+  auto [bbox, score, label] =
+      extractDetectionData(bboxData.data(), scoresData.data(), 2);
+
+  EXPECT_FLOAT_EQ(bbox.x1, 300.0f);
+  EXPECT_FLOAT_EQ(bbox.y1, 100.0f);
+  EXPECT_FLOAT_EQ(bbox.x2, 400.0f);
+  EXPECT_FLOAT_EQ(bbox.y2, 300.0f);
+  EXPECT_FLOAT_EQ(score, 0.75f);
+  EXPECT_EQ(label, 12);
+}
+
+TEST(ExtractDetectionData, LowConfidenceDetection) {
+  std::vector<float> bboxData = {50.0f, 60.0f, 150.0f, 160.0f};
+  std::vector<float> scoresData = {0.05f, 1.0f}; // Very low confidence
+
+  auto [bbox, score, label] =
+      extractDetectionData(bboxData.data(), scoresData.data(), 0);
+
+  EXPECT_FLOAT_EQ(score, 0.05f);
+  EXPECT_EQ(label, 1);
+}
+
+TEST(ExtractDetectionData, ZeroBasedLabelIndex) {
+  std::vector<float> bboxData = {0.0f, 0.0f, 100.0f, 100.0f};
+  std::vector<float> scoresData = {0.9f, 0.0f}; // Label index 0
+
+  auto [bbox, score, label] =
+      extractDetectionData(bboxData.data(), scoresData.data(), 0);
+
+  EXPECT_EQ(label, 0);
+}
+
+TEST(ExtractDetectionData, LargeLabelIndex) {
+  std::vector<float> bboxData = {0.0f, 0.0f, 100.0f, 100.0f};
+  std::vector<float> scoresData = {0.9f, 999.0f}; // Large label index
+
+  auto [bbox, score, label] =
+      extractDetectionData(bboxData.data(), scoresData.data(), 0);
+
+  EXPECT_EQ(label, 999);
+}
+
+TEST(ExtractDetectionData, FloatToInt32Conversion) {
+  std::vector<float> bboxData = {0.0f, 0.0f, 100.0f, 100.0f};
+  std::vector<float> scoresData = {0.9f, 42.7f}; // Float label gets truncated
+
+  auto [bbox, score, label] =
+      extractDetectionData(bboxData.data(), scoresData.data(), 0);
+
+  EXPECT_EQ(label, 42); // Should truncate, not round
+}
+
+TEST(ExtractDetectionData, NegativeCoordinates) {
+  std::vector<float> bboxData = {-10.0f, -20.0f, 50.0f, 60.0f};
+  std::vector<float> scoresData = {0.8f, 2.0f};
+
+  auto [bbox, score, label] =
+      extractDetectionData(bboxData.data(), scoresData.data(), 0);
+
+  EXPECT_FLOAT_EQ(bbox.x1, -10.0f);
+  EXPECT_FLOAT_EQ(bbox.y1, -20.0f);
+  EXPECT_FLOAT_EQ(bbox.x2, 50.0f);
+  EXPECT_FLOAT_EQ(bbox.y2, 60.0f);
+}
+
+TEST(ExtractDetectionData, FractionalCoordinates) {
+  std::vector<float> bboxData = {10.5f, 20.75f, 100.25f, 200.9f};
+  std::vector<float> scoresData = {0.88f, 7.0f};
+
+  auto [bbox, score, label] =
+      extractDetectionData(bboxData.data(), scoresData.data(), 0);
+
+  EXPECT_FLOAT_EQ(bbox.x1, 10.5f);
+  EXPECT_FLOAT_EQ(bbox.y1, 20.75f);
+  EXPECT_FLOAT_EQ(bbox.x2, 100.25f);
+  EXPECT_FLOAT_EQ(bbox.y2, 200.9f);
+}