react-native-executorch 0.7.0 → 0.7.2

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());
-}

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

@@ -1,152 +0,0 @@
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/image_segmentation/Constants.h>
-#include <rnexecutorch/models/image_segmentation/ImageSegmentation.h>
-#include <string>
-#include <vector>
-
-#include <executorch/extension/tensor/tensor.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::image_segmentation;
-using executorch::extension::make_tensor_ptr;
-using executorch::extension::TensorPtr;
-using executorch::runtime::EValue;
-
-constexpr auto kValidImageSegmentationModelPath = "deeplabV3_xnnpack_fp32.pte";
-
-// Test fixture for tests that need dummy input data
-class ImageSegmentationForwardTest : public ::testing::Test {
-protected:
-  void SetUp() override {
-    model = std::make_unique<ImageSegmentation>(
-        kValidImageSegmentationModelPath, nullptr);
-    auto shapes = model->getAllInputShapes("forward");
-    ASSERT_FALSE(shapes.empty());
-    shape = shapes[0];
-
-    size_t numElements = 1;
-    for (auto dim : shape) {
-      numElements *= dim;
-    }
-    dummyData = std::vector<float>(numElements, 0.5f);
-
-    sizes = std::vector<int32_t>(shape.begin(), shape.end());
-    inputTensor =
-        make_tensor_ptr(sizes, dummyData.data(), exec_aten::ScalarType::Float);
-  }
-
-  std::unique_ptr<ImageSegmentation> model;
-  std::vector<int32_t> shape;
-  std::vector<float> dummyData;
-  std::vector<int32_t> sizes;
-  TensorPtr inputTensor;
-};
-
-TEST(ImageSegmentationCtorTests, InvalidPathThrows) {
-  EXPECT_THROW(ImageSegmentation("this_file_does_not_exist.pte", nullptr),
-               RnExecutorchError);
-}
-
-TEST(ImageSegmentationCtorTests, ValidPathDoesntThrow) {
-  EXPECT_NO_THROW(ImageSegmentation(kValidImageSegmentationModelPath, nullptr));
-}
-
-TEST_F(ImageSegmentationForwardTest, ForwardWithValidTensorSucceeds) {
-  auto result = model->forward(EValue(inputTensor));
-  EXPECT_TRUE(result.ok());
-}
-
-TEST_F(ImageSegmentationForwardTest, ForwardOutputHasCorrectDimensions) {
-  auto result = model->forward(EValue(inputTensor));
-  ASSERT_TRUE(result.ok());
-
-  auto &outputs = result.get();
-  ASSERT_FALSE(outputs.empty());
-
-  auto outputTensor = outputs[0].toTensor();
-  EXPECT_EQ(outputTensor.dim(), 4); // NCHW format
-}
-
-TEST_F(ImageSegmentationForwardTest, ForwardOutputHas21Classes) {
-  auto result = model->forward(EValue(inputTensor));
-  ASSERT_TRUE(result.ok());
-
-  auto &outputs = result.get();
-  ASSERT_FALSE(outputs.empty());
-
-  auto outputTensor = outputs[0].toTensor();
-  EXPECT_EQ(outputTensor.size(1), 21); // DeepLabV3 has 21 classes
-}
-
-TEST_F(ImageSegmentationForwardTest, MultipleForwardsWork) {
-  auto result1 = model->forward(EValue(inputTensor));
-  EXPECT_TRUE(result1.ok());
-
-  auto result2 = model->forward(EValue(inputTensor));
-  EXPECT_TRUE(result2.ok());
-}
-
-TEST_F(ImageSegmentationForwardTest, ForwardAfterUnloadThrows) {
-  model->unload();
-  EXPECT_THROW((void)model->forward(EValue(inputTensor)), RnExecutorchError);
-}
-
-TEST(ImageSegmentationInheritedTests, GetInputShapeWorks) {
-  ImageSegmentation model(kValidImageSegmentationModelPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_EQ(shape.size(), 4);
-  EXPECT_EQ(shape[0], 1); // Batch size
-  EXPECT_EQ(shape[1], 3); // RGB channels
-}
-
-TEST(ImageSegmentationInheritedTests, GetAllInputShapesWorks) {
-  ImageSegmentation model(kValidImageSegmentationModelPath, nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(ImageSegmentationInheritedTests, GetMethodMetaWorks) {
-  ImageSegmentation model(kValidImageSegmentationModelPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}
-
-TEST(ImageSegmentationInheritedTests, GetMemoryLowerBoundReturnsPositive) {
-  ImageSegmentation model(kValidImageSegmentationModelPath, nullptr);
-  EXPECT_GT(model.getMemoryLowerBound(), 0u);
-}
-
-TEST(ImageSegmentationInheritedTests, InputShapeIsSquare) {
-  ImageSegmentation model(kValidImageSegmentationModelPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_EQ(shape[2], shape[3]); // Height == Width for DeepLabV3
-}
-
-TEST(ImageSegmentationConstantsTests, ClassLabelsHas21Entries) {
-  EXPECT_EQ(constants::kDeeplabV3Resnet50Labels.size(), 21u);
-}
-
-TEST(ImageSegmentationConstantsTests, ClassLabelsContainExpectedClasses) {
-  auto &labels = constants::kDeeplabV3Resnet50Labels;
-  bool hasBackground = false;
-  bool hasPerson = false;
-  bool hasCat = false;
-  bool hasDog = false;
-
-  for (const auto &label : labels) {
-    if (label == "BACKGROUND")
-      hasBackground = true;
-    if (label == "PERSON")
-      hasPerson = true;
-    if (label == "CAT")
-      hasCat = true;
-    if (label == "DOG")
-      hasDog = true;
-  }
-
-  EXPECT_TRUE(hasBackground);
-  EXPECT_TRUE(hasPerson);
-  EXPECT_TRUE(hasCat);
-  EXPECT_TRUE(hasDog);
-}

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

@@ -1,155 +0,0 @@
-#include "BaseModelTests.h"
-#include <gtest/gtest.h>
-#include <memory>
-#include <string>
-
-#include <ReactCommon/CallInvoker.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/llm/LLM.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::llm;
-using namespace model_tests;
-
-constexpr auto kValidModelPath = "smolLm2_135M_8da4w.pte";
-constexpr auto kValidTokenizerPath = "smollm_tokenizer.json";
-constexpr auto kSystemPrompt = "You are a helpful assistant. Assist the user "
-                               "to the best of your abilities.";
-
-// Forward declaration from jsi_stubs.cpp
-namespace rnexecutorch {
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker();
-}
-
-// Helper to format prompt in ChatML format for SmolLM2
-std::string formatChatML(const std::string &systemPrompt,
-                         const std::string &userMessage) {
-  return "<|im_start|>system\n" + systemPrompt + "<|im_end|>\n" +
-         "<|im_start|>user\n" + userMessage + "<|im_end|>\n" +
-         "<|im_start|>assistant\n";
-}
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<LLM> {
-  using ModelType = LLM;
-
-  static ModelType createValid() {
-    return ModelType(kValidModelPath, kValidTokenizerPath,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", kValidTokenizerPath,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static void callGenerate(ModelType &model) {
-    std::string prompt = formatChatML(kSystemPrompt, "Hello");
-    (void)model.generate(prompt, nullptr);
-  }
-};
-} // namespace model_tests
-
-using LLMTypes = ::testing::Types<LLM>;
-INSTANTIATE_TYPED_TEST_SUITE_P(LLM, CommonModelTest, LLMTypes);
-
-// ============================================================================
-// LLM-specific fixture tests
-// ============================================================================
-class LLMTest : public ::testing::Test {
-protected:
-  std::shared_ptr<facebook::react::CallInvoker> mockInvoker_;
-
-  void SetUp() override { mockInvoker_ = createMockCallInvoker(); }
-};
-
-TEST(LLMCtorTests, InvalidTokenizerPathThrows) {
-  EXPECT_THROW(LLM(kValidModelPath, "nonexistent_tokenizer.json",
-                   createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST_F(LLMTest, GetGeneratedTokenCountInitiallyZero) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  EXPECT_EQ(model.getGeneratedTokenCount(), 0);
-}
-
-TEST_F(LLMTest, SetTemperature) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  // Should not throw for valid values
-  EXPECT_NO_THROW(model.setTemperature(0.5f));
-  EXPECT_NO_THROW(model.setTemperature(1.0f));
-  EXPECT_NO_THROW(model.setTemperature(0.0f));
-}
-
-TEST_F(LLMTest, SetTemperatureNegativeThrows) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  EXPECT_THROW(model.setTemperature(-0.1f), RnExecutorchError);
-}
-
-TEST_F(LLMTest, SetTopp) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  EXPECT_NO_THROW(model.setTopp(0.9f));
-  EXPECT_NO_THROW(model.setTopp(0.5f));
-  EXPECT_NO_THROW(model.setTopp(1.0f));
-}
-
-TEST_F(LLMTest, SetToppInvalidThrows) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  EXPECT_THROW(model.setTopp(-0.1f), RnExecutorchError);
-  EXPECT_THROW(model.setTopp(1.1f), RnExecutorchError);
-}
-
-TEST_F(LLMTest, SetCountInterval) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  EXPECT_NO_THROW(model.setCountInterval(5));
-  EXPECT_NO_THROW(model.setCountInterval(10));
-}
-
-TEST_F(LLMTest, SetTimeInterval) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  EXPECT_NO_THROW(model.setTimeInterval(100));
-  EXPECT_NO_THROW(model.setTimeInterval(500));
-}
-
-TEST_F(LLMTest, InterruptThrowsWhenUnloaded) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  model.unload();
-  EXPECT_THROW(model.interrupt(), RnExecutorchError);
-}
-
-TEST_F(LLMTest, SettersThrowWhenUnloaded) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  model.unload();
-  // All setters should throw when model is unloaded
-  EXPECT_THROW(model.setTemperature(0.5f), RnExecutorchError);
-  EXPECT_THROW(model.setTopp(0.9f), RnExecutorchError);
-  EXPECT_THROW(model.setCountInterval(5), RnExecutorchError);
-  EXPECT_THROW(model.setTimeInterval(100), RnExecutorchError);
-}
-
-TEST_F(LLMTest, GenerateProducesValidOutput) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  model.setTemperature(0.0f);
-  std::string prompt =
-      formatChatML(kSystemPrompt, "Repeat exactly this: `naszponcilem testy`");
-  std::string output = model.generate(prompt, nullptr);
-  EXPECT_EQ(output, "`naszponcilem testy`<|im_end|>");
-}
-
-TEST_F(LLMTest, GenerateUpdatesTokenCount) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  EXPECT_EQ(model.getGeneratedTokenCount(), 0);
-  std::string prompt =
-      formatChatML(kSystemPrompt, "Repeat exactly this: 'naszponcilem testy'");
-  model.generate(prompt, nullptr);
-  EXPECT_GT(model.getGeneratedTokenCount(), 0);
-}
-
-TEST_F(LLMTest, EmptyPromptThrows) {
-  LLM model(kValidModelPath, kValidTokenizerPath, mockInvoker_);
-  EXPECT_THROW((void)model.generate("", nullptr), RnExecutorchError);
-}

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

@@ -1,128 +0,0 @@
-#include "BaseModelTests.h"
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/ocr/OCR.h>
-#include <string>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::ocr;
-using namespace model_tests;
-
-namespace rnexecutorch {
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker();
-}
-
-constexpr auto kValidDetectorPath = "xnnpack_craft_quantized.pte";
-constexpr auto kValidRecognizerPath = "xnnpack_crnn_english.pte";
-constexpr auto kValidTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/we_are_software_mansion.jpg";
-
-// English alphabet symbols (must match alphabets.english from symbols.ts)
-const std::string ENGLISH_SYMBOLS =
-    "0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ "
-    "\xE2\x82\xAC" // Euro sign (€)
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<OCR> {
-  using ModelType = OCR;
-
-  static ModelType createValid() {
-    return ModelType(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", kValidRecognizerPath, ENGLISH_SYMBOLS,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generate(kValidTestImagePath);
-  }
-};
-} // namespace model_tests
-
-using OCRTypes = ::testing::Types<OCR>;
-INSTANTIATE_TYPED_TEST_SUITE_P(OCR, CommonModelTest, OCRTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(OCRCtorTests, InvalidRecognizerPathThrows) {
-  EXPECT_THROW(OCR(kValidDetectorPath, "nonexistent.pte", ENGLISH_SYMBOLS,
-                   createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(OCRCtorTests, EmptySymbolsThrows) {
-  EXPECT_THROW(OCR(kValidDetectorPath, kValidRecognizerPath, "",
-                   createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(OCRGenerateTests, InvalidImagePathThrows) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("nonexistent_image.jpg"),
-               RnExecutorchError);
-}
-
-TEST(OCRGenerateTests, EmptyImagePathThrows) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  EXPECT_THROW((void)model.generate(""), RnExecutorchError);
-}
-
-TEST(OCRGenerateTests, MalformedURIThrows) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("not_a_valid_uri://bad"),
-               RnExecutorchError);
-}
-
-TEST(OCRGenerateTests, ValidImageReturnsResults) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  auto results = model.generate(kValidTestImagePath);
-  // May or may not have detections depending on image content
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(OCRGenerateTests, DetectionsHaveValidBoundingBoxes) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  auto results = model.generate(kValidTestImagePath);
-
-  for (const auto &detection : results) {
-    // Each bbox should have 4 points
-    EXPECT_EQ(detection.bbox.size(), 4u);
-    for (const auto &point : detection.bbox) {
-      EXPECT_GE(point.x, 0.0f);
-      EXPECT_GE(point.y, 0.0f);
-    }
-  }
-}
-
-TEST(OCRGenerateTests, DetectionsHaveValidScores) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  auto results = model.generate(kValidTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.score, 0.0f);
-    EXPECT_LE(detection.score, 1.0f);
-  }
-}
-
-TEST(OCRGenerateTests, DetectionsHaveNonEmptyText) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  auto results = model.generate(kValidTestImagePath);
-  for (const auto &detection : results) {
-    EXPECT_FALSE(detection.text.empty());
-  }
-}