react-native-executorch 0.7.0 → 0.7.1

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

@@ -1,238 +0,0 @@
-#include "BaseModelTests.h"
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/vertical_ocr/VerticalOCR.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 kValidVerticalDetectorPath = "xnnpack_craft_quantized.pte";
-constexpr auto kValidVerticalRecognizerPath = "xnnpack_crnn_english.pte";
-constexpr auto kValidVerticalTestImagePath =
-    "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<VerticalOCR> {
-  using ModelType = VerticalOCR;
-
-  static ModelType createValid() {
-    return ModelType(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                     ENGLISH_SYMBOLS, false,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", kValidVerticalRecognizerPath,
-                     ENGLISH_SYMBOLS, false,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generate(kValidVerticalTestImagePath);
-  }
-};
-} // namespace model_tests
-
-using VerticalOCRTypes = ::testing::Types<VerticalOCR>;
-INSTANTIATE_TYPED_TEST_SUITE_P(VerticalOCR, CommonModelTest, VerticalOCRTypes);
-
-// ============================================================================
-// VerticalOCR-specific tests
-// ============================================================================
-
-// Constructor tests
-TEST(VerticalOCRCtorTests, InvalidRecognizerPathThrows) {
-  EXPECT_THROW(VerticalOCR(kValidVerticalDetectorPath, "nonexistent.pte",
-                           ENGLISH_SYMBOLS, false, createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRCtorTests, EmptySymbolsThrows) {
-  EXPECT_THROW(VerticalOCR(kValidVerticalDetectorPath,
-                           kValidVerticalRecognizerPath, "", false,
-                           createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRCtorTests, IndependentCharsTrueDoesntThrow) {
-  EXPECT_NO_THROW(VerticalOCR(kValidVerticalDetectorPath,
-                              kValidVerticalRecognizerPath, ENGLISH_SYMBOLS,
-                              true, createMockCallInvoker()));
-}
-
-TEST(VerticalOCRCtorTests, IndependentCharsFalseDoesntThrow) {
-  EXPECT_NO_THROW(VerticalOCR(kValidVerticalDetectorPath,
-                              kValidVerticalRecognizerPath, ENGLISH_SYMBOLS,
-                              false, createMockCallInvoker()));
-}
-
-// Generate tests - Independent Characters strategy
-TEST(VerticalOCRGenerateTests, IndependentCharsInvalidImageThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("nonexistent_image.jpg"),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, IndependentCharsEmptyImagePathThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  EXPECT_THROW((void)model.generate(""), RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, IndependentCharsMalformedURIThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("not_a_valid_uri://bad"),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, IndependentCharsValidImageReturnsResults) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  auto results = model.generate(kValidVerticalTestImagePath);
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(VerticalOCRGenerateTests, IndependentCharsDetectionsHaveValidBBoxes) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  auto results = model.generate(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    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(VerticalOCRGenerateTests, IndependentCharsDetectionsHaveValidScores) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  auto results = model.generate(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.score, 0.0f);
-    EXPECT_LE(detection.score, 1.0f);
-  }
-}
-
-TEST(VerticalOCRGenerateTests, IndependentCharsDetectionsHaveNonEmptyText) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  auto results = model.generate(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_FALSE(detection.text.empty());
-  }
-}
-
-// Generate tests - Joint Characters strategy
-TEST(VerticalOCRGenerateTests, JointCharsInvalidImageThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("nonexistent_image.jpg"),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, JointCharsEmptyImagePathThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  EXPECT_THROW((void)model.generate(""), RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, JointCharsMalformedURIThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("not_a_valid_uri://bad"),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, JointCharsValidImageReturnsResults) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  auto results = model.generate(kValidVerticalTestImagePath);
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(VerticalOCRGenerateTests, JointCharsDetectionsHaveValidBBoxes) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  auto results = model.generate(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    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(VerticalOCRGenerateTests, JointCharsDetectionsHaveValidScores) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  auto results = model.generate(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.score, 0.0f);
-    EXPECT_LE(detection.score, 1.0f);
-  }
-}
-
-TEST(VerticalOCRGenerateTests, JointCharsDetectionsHaveNonEmptyText) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  auto results = model.generate(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_FALSE(detection.text.empty());
-  }
-}
-
-// Strategy comparison tests
-TEST(VerticalOCRStrategyTests, BothStrategiesRunSuccessfully) {
-  VerticalOCR independentModel(kValidVerticalDetectorPath,
-                               kValidVerticalRecognizerPath, ENGLISH_SYMBOLS,
-                               true, createMockCallInvoker());
-  VerticalOCR jointModel(kValidVerticalDetectorPath,
-                         kValidVerticalRecognizerPath, ENGLISH_SYMBOLS, false,
-                         createMockCallInvoker());
-
-  EXPECT_NO_THROW((void)independentModel.generate(kValidVerticalTestImagePath));
-  EXPECT_NO_THROW((void)jointModel.generate(kValidVerticalTestImagePath));
-}
-
-TEST(VerticalOCRStrategyTests, BothStrategiesReturnValidResults) {
-  VerticalOCR independentModel(kValidVerticalDetectorPath,
-                               kValidVerticalRecognizerPath, ENGLISH_SYMBOLS,
-                               true, createMockCallInvoker());
-  VerticalOCR jointModel(kValidVerticalDetectorPath,
-                         kValidVerticalRecognizerPath, ENGLISH_SYMBOLS, false,
-                         createMockCallInvoker());
-
-  auto independentResults =
-      independentModel.generate(kValidVerticalTestImagePath);
-  auto jointResults = jointModel.generate(kValidVerticalTestImagePath);
-
-  // Both should return some results (or none if no text detected)
-  EXPECT_GE(independentResults.size(), 0u);
-  EXPECT_GE(jointResults.size(), 0u);
-}

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

@@ -1,99 +0,0 @@
-#include "BaseModelTests.h"
-#include "utils/TestUtils.h"
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::voice_activity_detection;
-using namespace test_utils;
-using namespace model_tests;
-
-constexpr auto kValidVadModelPath = "fsmn-vad_xnnpack.pte";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<VoiceActivityDetection> {
-  using ModelType = VoiceActivityDetection;
-
-  static ModelType createValid() {
-    return ModelType(kValidVadModelPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    auto audio = loadAudioFromFile("test_audio_float.raw");
-    (void)model.generate(audio);
-  }
-};
-} // namespace model_tests
-
-using VADTypes = ::testing::Types<VoiceActivityDetection>;
-INSTANTIATE_TYPED_TEST_SUITE_P(VAD, CommonModelTest, VADTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(VADGenerateTests, SilenceReturnsNoSegments) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto silence = generateSilence(16000 * 5);
-  auto segments = model.generate(silence);
-  EXPECT_TRUE(segments.empty());
-}
-
-TEST(VADGenerateTests, SegmentsHaveValidBounds) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  auto segments = model.generate(audio);
-
-  for (const auto &segment : segments) {
-    EXPECT_LE(segment.start, segment.end);
-    EXPECT_LE(segment.end, audio.size());
-  }
-}
-
-TEST(VADGenerateTests, SegmentsAreNonOverlapping) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  auto segments = model.generate(audio);
-  for (size_t i = 1; i < segments.size(); ++i) {
-    EXPECT_LE(segments[i - 1].end, segments[i].start);
-  }
-}
-
-TEST(VADGenerateTests, LongAudioSegmentBoundsValid) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  auto segments = model.generate(audio);
-
-  for (const auto &segment : segments) {
-    EXPECT_LE(segment.start, segment.end);
-    EXPECT_LE(segment.end, audio.size());
-  }
-}
-
-TEST(VADInheritedTests, GetInputShapeWorks) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_GE(shape.size(), 2u);
-}
-
-TEST(VADInheritedTests, GetAllInputShapesWorks) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(VADInheritedTests, GetMethodMetaWorks) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}

package/common/rnexecutorch/tests/integration/stubs/jsi_stubs.cpp

@@ -1,45 +0,0 @@
-// Stub implementations for JSI and other symbols to satisfy the linker
-// These are never actually called in tests
-
-#include <ReactCommon/CallInvoker.h>
-#include <cstddef>
-#include <functional>
-#include <jsi/jsi.h>
-#include <string>
-#include <vector>
-
-namespace facebook::jsi {
-
-// MutableBuffer destructor - needed by OwningArrayBuffer
-MutableBuffer::~MutableBuffer() {}
-Value::~Value() {}
-Value::Value(Value &&other) noexcept {}
-} // namespace facebook::jsi
-
-namespace facebook::react {
-
-// Needed by LLM test
-class MockCallInvoker : public CallInvoker {
-public:
-  void invokeAsync(CallFunc &&func) noexcept override {}
-
-  void invokeSync(CallFunc &&func) override {}
-};
-
-} // namespace facebook::react
-
-namespace rnexecutorch {
-
-// Stub for fetchUrlFunc - used by ImageProcessing for remote URLs
-// Tests only use local files, so this is never called
-using FetchUrlFunc_t = std::function<std::vector<std::byte>(std::string)>;
-FetchUrlFunc_t fetchUrlFunc = [](std::string) -> std::vector<std::byte> {
-  return {};
-};
-
-// Global mock call invoker for tests
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker() {
-  return std::make_shared<facebook::react::MockCallInvoker>();
-}
-
-} // namespace rnexecutorch

package/common/rnexecutorch/tests/integration/utils/TestUtils.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <fstream>
-#include <string>
-#include <vector>
-
-namespace test_utils {
-
-inline void trimFilePrefix(std::string &filepath) {
-  constexpr std::string_view prefix = "file://";
-  if (filepath.starts_with(prefix)) {
-    filepath.erase(0, prefix.size());
-  }
-}
-
-inline std::vector<float> loadAudioFromFile(const std::string &filepath) {
-  std::ifstream file(filepath, std::ios::binary | std::ios::ate);
-  if (!file.is_open()) {
-    return {};
-  }
-
-  std::streamsize size = file.tellg();
-  file.seekg(0, std::ios::beg);
-
-  size_t numSamples = size / sizeof(float);
-  std::vector<float> buffer(numSamples);
-
-  file.read(reinterpret_cast<char *>(buffer.data()), size);
-  return buffer;
-}
-
-inline std::vector<float> generateSilence(size_t numSamples) {
-  return std::vector<float>(numSamples, 0.0f);
-}
-
-} // namespace test_utils