react-native-executorch 0.7.0 → 0.7.1

package/common/rnexecutorch/tests/integration/BaseModelTest.cpp

@@ -1,207 +0,0 @@
-#include "BaseModelTests.h"
-#include <executorch/extension/tensor/tensor.h>
-#include <gtest/gtest.h>
-#include <limits>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/BaseModel.h>
-#include <vector>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models;
-using namespace executorch::extension;
-using namespace model_tests;
-using executorch::runtime::EValue;
-
-constexpr auto kValidStyleTransferModelPath =
-    "style_transfer_candy_xnnpack.pte";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<BaseModel> {
-  using ModelType = BaseModel;
-
-  static ModelType createValid() {
-    return ModelType(kValidStyleTransferModelPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    std::vector<int32_t> shape = {1, 3, 640, 640};
-    size_t numElements = 1 * 3 * 640 * 640;
-    std::vector<float> inputData(numElements, 0.5f);
-    auto tensorPtr = make_tensor_ptr(shape, inputData.data());
-    EValue input(*tensorPtr);
-    (void)model.forward(input);
-  }
-};
-} // namespace model_tests
-
-using BaseModelTypes = ::testing::Types<BaseModel>;
-INSTANTIATE_TYPED_TEST_SUITE_P(BaseModel, CommonModelTest, BaseModelTypes);
-
-// ============================================================================
-// BaseModel-specific tests (methods not in all models)
-// ============================================================================
-
-TEST(BaseModelGetInputShapeTests, ValidMethodCorrectShape) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  auto forwardShape = model.getInputShape("forward", 0);
-  std::vector<int32_t> expectedShape = {1, 3, 640, 640};
-  EXPECT_EQ(forwardShape, expectedShape);
-}
-
-TEST(BaseModelGetInputShapeTests, InvalidMethodThrows) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW((void)model.getInputShape("this_method_does_not_exist", 0),
-               RnExecutorchError);
-}
-
-TEST(BaseModelGetInputShapeTests, ValidMethodInvalidIndexThrows) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW(
-      (void)model.getInputShape("forward", std::numeric_limits<int32_t>::min()),
-      RnExecutorchError);
-}
-
-TEST(BaseModelGetAllInputShapesTests, ValidMethodReturnsShapes) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  auto allShapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(allShapes.empty());
-  std::vector<int32_t> expectedFirstShape = {1, 3, 640, 640};
-  EXPECT_EQ(allShapes[0], expectedFirstShape);
-}
-
-TEST(BaseModelGetAllInputShapesTests, InvalidMethodThrows) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW(model.getAllInputShapes("non_existent_method"),
-               RnExecutorchError);
-}
-
-TEST(BaseModelGetMethodMetaTests, ValidMethodReturnsOk) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}
-
-TEST(BaseModelGetMethodMetaTests, InvalidMethodReturnsError) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.getMethodMeta("non_existent_method");
-  EXPECT_FALSE(result.ok());
-}
-
-TEST(BaseModelForwardTests, ForwardWithValidInputReturnsOk) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-  auto tensorPtr = make_tensor_ptr(shape, inputData.data());
-  EValue input(*tensorPtr);
-
-  auto result = model.forward(input);
-  EXPECT_TRUE(result.ok());
-}
-
-TEST(BaseModelForwardTests, ForwardWithVectorInputReturnsOk) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-  auto tensorPtr = make_tensor_ptr(shape, inputData.data());
-  std::vector<EValue> inputs;
-  inputs.emplace_back(*tensorPtr);
-
-  auto result = model.forward(inputs);
-  EXPECT_TRUE(result.ok());
-}
-
-TEST(BaseModelForwardTests, ForwardReturnsCorrectOutputShape) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-  auto tensorPtr = make_tensor_ptr(shape, inputData.data());
-  EValue input(*tensorPtr);
-
-  auto result = model.forward(input);
-  ASSERT_TRUE(result.ok());
-  ASSERT_FALSE(result->empty());
-
-  auto &outputTensor = result->at(0).toTensor();
-  auto outputSizes = outputTensor.sizes();
-  EXPECT_EQ(outputSizes.size(), 4);
-  EXPECT_EQ(outputSizes[0], 1);
-  EXPECT_EQ(outputSizes[1], 3);
-  EXPECT_EQ(outputSizes[2], 640);
-  EXPECT_EQ(outputSizes[3], 640);
-}
-
-TEST(BaseModelForwardTests, ForwardAfterUnloadThrows) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  model.unload();
-
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-  auto tensorPtr = make_tensor_ptr(shape, inputData.data());
-  EValue input(*tensorPtr);
-
-  EXPECT_THROW(model.forward(input), RnExecutorchError);
-}
-
-TEST(BaseModelForwardJSTests, ForwardJSWithValidInputReturnsOutput) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-
-  JSTensorViewIn tensorView;
-  tensorView.dataPtr = inputData.data();
-  tensorView.sizes = shape;
-  tensorView.scalarType = executorch::aten::ScalarType::Float;
-
-  std::vector<JSTensorViewIn> inputs = {tensorView};
-  auto outputs = model.forwardJS(inputs);
-
-  EXPECT_FALSE(outputs.empty());
-}
-
-TEST(BaseModelForwardJSTests, ForwardJSReturnsCorrectOutputShape) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-
-  JSTensorViewIn tensorView;
-  tensorView.dataPtr = inputData.data();
-  tensorView.sizes = shape;
-  tensorView.scalarType = executorch::aten::ScalarType::Float;
-
-  std::vector<JSTensorViewIn> inputs = {tensorView};
-  auto outputs = model.forwardJS(inputs);
-
-  ASSERT_EQ(outputs.size(), 1);
-  std::vector<int32_t> expectedShape = {1, 3, 640, 640};
-  EXPECT_EQ(outputs[0].sizes, expectedShape);
-}
-
-TEST(BaseModelForwardJSTests, ForwardJSAfterUnloadThrows) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  model.unload();
-
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-
-  JSTensorViewIn tensorView;
-  tensorView.dataPtr = inputData.data();
-  tensorView.sizes = shape;
-  tensorView.scalarType = executorch::aten::ScalarType::Float;
-
-  std::vector<JSTensorViewIn> inputs = {tensorView};
-  EXPECT_THROW((void)model.forwardJS(inputs), RnExecutorchError);
-}

package/common/rnexecutorch/tests/integration/BaseModelTests.h

@@ -1,120 +0,0 @@
-#pragma once
-
-#include "gtest/gtest.h"
-#include <rnexecutorch/Error.h>
-
-namespace facebook::react {
-class CallInvoker;
-}
-
-namespace rnexecutorch {
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker();
-}
-
-namespace model_tests {
-
-inline auto getMockInvoker() { return rnexecutorch::createMockCallInvoker(); }
-
-/// Helper macro to access Traits in typed tests
-#define SETUP_TRAITS() using Traits = typename TestFixture::Traits
-
-/// Trait struct that each model must specialize
-/// This defines how to construct and test each model type
-template <typename T> struct ModelTraits;
-
-/// Example of what a specialization looks like:
-///
-/// template<>
-/// struct ModelTraits<Classification> {
-///   using ModelType = Classification;
-///
-///   // Create valid model instance
-///   static ModelType createValid() {
-///     return ModelType("valid_model.pte", nullptr);
-///   }
-///
-///   // Create invalid model instance (should throw in constructor)
-///   static ModelType createInvalid() {
-///     return ModelType("nonexistent.pte", nullptr);
-///   }
-///
-///   // Call the model's generate/forward function with valid input
-///   // Used to test that generate throws after unload
-///  static void callGenerate(ModelType& model) {
-///     (void)model.generate("valid_input.jpg");
-///   }
-/// };
-// Typed test fixture for common model tests
-template <typename T> class CommonModelTest : public ::testing::Test {
-protected:
-  using Traits = ModelTraits<T>;
-  using ModelType = typename Traits::ModelType;
-};
-
-// Define the test suite
-TYPED_TEST_SUITE_P(CommonModelTest);
-
-// Constructor tests
-TYPED_TEST_P(CommonModelTest, InvalidPathThrows) {
-  SETUP_TRAITS();
-  EXPECT_THROW(Traits::createInvalid(), rnexecutorch::RnExecutorchError);
-}
-
-TYPED_TEST_P(CommonModelTest, ValidPathDoesntThrow) {
-  SETUP_TRAITS();
-  EXPECT_NO_THROW(Traits::createValid());
-}
-
-// Memory tests
-TYPED_TEST_P(CommonModelTest, GetMemoryLowerBoundValue) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  EXPECT_GT(model.getMemoryLowerBound(), 0u);
-}
-
-TYPED_TEST_P(CommonModelTest, GetMemoryLowerBoundConsistent) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  auto bound1 = model.getMemoryLowerBound();
-  auto bound2 = model.getMemoryLowerBound();
-  EXPECT_EQ(bound1, bound2);
-}
-
-// Unload tests
-TYPED_TEST_P(CommonModelTest, UnloadDoesntThrow) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  EXPECT_NO_THROW(model.unload());
-}
-
-TYPED_TEST_P(CommonModelTest, MultipleUnloadsSafe) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  EXPECT_NO_THROW(model.unload());
-  EXPECT_NO_THROW(model.unload());
-  EXPECT_NO_THROW(model.unload());
-}
-
-TYPED_TEST_P(CommonModelTest, GenerateAfterUnloadThrows) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  model.unload();
-  EXPECT_THROW(Traits::callGenerate(model), rnexecutorch::RnExecutorchError);
-}
-
-TYPED_TEST_P(CommonModelTest, MultipleGeneratesWork) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  EXPECT_NO_THROW(Traits::callGenerate(model));
-  EXPECT_NO_THROW(Traits::callGenerate(model));
-  EXPECT_NO_THROW(Traits::callGenerate(model));
-}
-
-// Register all tests in the suite
-REGISTER_TYPED_TEST_SUITE_P(CommonModelTest, InvalidPathThrows,
-                            ValidPathDoesntThrow, GetMemoryLowerBoundValue,
-                            GetMemoryLowerBoundConsistent, UnloadDoesntThrow,
-                            MultipleUnloadsSafe, GenerateAfterUnloadThrows,
-                            MultipleGeneratesWork);
-
-} // namespace model_tests

package/common/rnexecutorch/tests/integration/ClassificationTest.cpp

@@ -1,117 +0,0 @@
-#include "BaseModelTests.h"
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/classification/Classification.h>
-#include <rnexecutorch/models/classification/Constants.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::classification;
-using namespace model_tests;
-
-constexpr auto kValidClassificationModelPath = "efficientnet_v2_s_xnnpack.pte";
-constexpr auto kValidTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/test_image.jpg";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<Classification> {
-  using ModelType = Classification;
-
-  static ModelType createValid() {
-    return ModelType(kValidClassificationModelPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generate(kValidTestImagePath);
-  }
-};
-} // namespace model_tests
-
-using ClassificationTypes = ::testing::Types<Classification>;
-INSTANTIATE_TYPED_TEST_SUITE_P(Classification, CommonModelTest,
-                               ClassificationTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(ClassificationGenerateTests, InvalidImagePathThrows) {
-  Classification model(kValidClassificationModelPath, nullptr);
-  EXPECT_THROW((void)model.generate("nonexistent_image.jpg"),
-               RnExecutorchError);
-}
-
-TEST(ClassificationGenerateTests, EmptyImagePathThrows) {
-  Classification model(kValidClassificationModelPath, nullptr);
-  EXPECT_THROW((void)model.generate(""), RnExecutorchError);
-}
-
-TEST(ClassificationGenerateTests, MalformedURIThrows) {
-  Classification model(kValidClassificationModelPath, nullptr);
-  EXPECT_THROW((void)model.generate("not_a_valid_uri://bad"),
-               RnExecutorchError);
-}
-
-TEST(ClassificationGenerateTests, ValidImageReturnsResults) {
-  Classification model(kValidClassificationModelPath, nullptr);
-  auto results = model.generate(kValidTestImagePath);
-  EXPECT_FALSE(results.empty());
-}
-
-TEST(ClassificationGenerateTests, ResultsHaveCorrectSize) {
-  Classification model(kValidClassificationModelPath, nullptr);
-  auto results = model.generate(kValidTestImagePath);
-  auto expectedNumClasses = constants::kImagenet1kV1Labels.size();
-  EXPECT_EQ(results.size(), expectedNumClasses);
-}
-
-TEST(ClassificationGenerateTests, ResultsContainValidProbabilities) {
-  Classification model(kValidClassificationModelPath, nullptr);
-  auto results = model.generate(kValidTestImagePath);
-
-  float sum = 0.0f;
-  for (const auto &[label, prob] : results) {
-    EXPECT_GE(prob, 0.0f);
-    EXPECT_LE(prob, 1.0f);
-    sum += prob;
-  }
-  EXPECT_NEAR(sum, 1.0f, 0.01f);
-}
-
-TEST(ClassificationGenerateTests, TopPredictionHasReasonableConfidence) {
-  Classification model(kValidClassificationModelPath, nullptr);
-  auto results = model.generate(kValidTestImagePath);
-
-  float maxProb = 0.0f;
-  for (const auto &[label, prob] : results) {
-    if (prob > maxProb) {
-      maxProb = prob;
-    }
-  }
-  EXPECT_GT(maxProb, 0.0f);
-}
-
-TEST(ClassificationInheritedTests, GetInputShapeWorks) {
-  Classification model(kValidClassificationModelPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_EQ(shape.size(), 4);
-  EXPECT_EQ(shape[0], 1);
-  EXPECT_EQ(shape[1], 3);
-}
-
-TEST(ClassificationInheritedTests, GetAllInputShapesWorks) {
-  Classification model(kValidClassificationModelPath, nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(ClassificationInheritedTests, GetMethodMetaWorks) {
-  Classification model(kValidClassificationModelPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}

package/common/rnexecutorch/tests/integration/ImageEmbeddingsTest.cpp

@@ -1,122 +0,0 @@
-#include "BaseModelTests.h"
-#include <cmath>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/embeddings/image/ImageEmbeddings.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::embeddings;
-using namespace model_tests;
-
-constexpr auto kValidImageEmbeddingsModelPath =
-    "clip-vit-base-patch32-vision_xnnpack.pte";
-constexpr auto kValidTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/test_image.jpg";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<ImageEmbeddings> {
-  using ModelType = ImageEmbeddings;
-
-  static ModelType createValid() {
-    return ModelType(kValidImageEmbeddingsModelPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generate(kValidTestImagePath);
-  }
-};
-} // namespace model_tests
-
-using ImageEmbeddingsTypes = ::testing::Types<ImageEmbeddings>;
-INSTANTIATE_TYPED_TEST_SUITE_P(ImageEmbeddings, CommonModelTest,
-                               ImageEmbeddingsTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(ImageEmbeddingsGenerateTests, InvalidImagePathThrows) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  EXPECT_THROW((void)model.generate("nonexistent_image.jpg"),
-               RnExecutorchError);
-}
-
-TEST(ImageEmbeddingsGenerateTests, EmptyImagePathThrows) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  EXPECT_THROW((void)model.generate(""), RnExecutorchError);
-}
-
-TEST(ImageEmbeddingsGenerateTests, MalformedURIThrows) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  EXPECT_THROW((void)model.generate("not_a_valid_uri://bad"),
-               RnExecutorchError);
-}
-
-TEST(ImageEmbeddingsGenerateTests, ValidImageReturnsResults) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto result = model.generate(kValidTestImagePath);
-  EXPECT_NE(result, nullptr);
-  EXPECT_GT(result->size(), 0u);
-}
-
-TEST(ImageEmbeddingsGenerateTests, ResultsHaveCorrectSize) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto result = model.generate(kValidTestImagePath);
-  size_t numFloats = result->size() / sizeof(float);
-  constexpr size_t kClipEmbeddingDimensions = 512;
-  EXPECT_EQ(numFloats, kClipEmbeddingDimensions);
-}
-
-TEST(ImageEmbeddingsGenerateTests, ResultsAreNormalized) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto result = model.generate(kValidTestImagePath);
-
-  const float *data = reinterpret_cast<const float *>(result->data());
-  size_t numFloats = result->size() / sizeof(float);
-
-  float sumOfSquares = 0.0f;
-  for (size_t i = 0; i < numFloats; ++i) {
-    sumOfSquares += data[i] * data[i];
-  }
-  float norm = std::sqrt(sumOfSquares);
-  EXPECT_NEAR(norm, 1.0f, 0.01f);
-}
-
-TEST(ImageEmbeddingsGenerateTests, ResultsContainValidValues) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto result = model.generate(kValidTestImagePath);
-
-  const float *data = reinterpret_cast<const float *>(result->data());
-  size_t numFloats = result->size() / sizeof(float);
-
-  for (size_t i = 0; i < numFloats; ++i) {
-    EXPECT_FALSE(std::isnan(data[i]));
-    EXPECT_FALSE(std::isinf(data[i]));
-  }
-}
-
-TEST(ImageEmbeddingsInheritedTests, GetInputShapeWorks) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_EQ(shape.size(), 4);
-  EXPECT_EQ(shape[0], 1);
-  EXPECT_EQ(shape[1], 3);
-}
-
-TEST(ImageEmbeddingsInheritedTests, GetAllInputShapesWorks) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(ImageEmbeddingsInheritedTests, GetMethodMetaWorks) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}