react-native-executorch 0.7.0 → 0.7.1

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

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

@@ -1,135 +0,0 @@
-#include "BaseModelTests.h"
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/object_detection/Constants.h>
-#include <rnexecutorch/models/object_detection/ObjectDetection.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::object_detection;
-using namespace model_tests;
-
-constexpr auto kValidObjectDetectionModelPath =
-    "ssdlite320-mobilenetv3-large.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<ObjectDetection> {
-  using ModelType = ObjectDetection;
-
-  static ModelType createValid() {
-    return ModelType(kValidObjectDetectionModelPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generate(kValidTestImagePath, 0.5);
-  }
-};
-} // namespace model_tests
-
-using ObjectDetectionTypes = ::testing::Types<ObjectDetection>;
-INSTANTIATE_TYPED_TEST_SUITE_P(ObjectDetection, CommonModelTest,
-                               ObjectDetectionTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(ObjectDetectionGenerateTests, InvalidImagePathThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  EXPECT_THROW((void)model.generate("nonexistent_image.jpg", 0.5),
-               RnExecutorchError);
-}
-
-TEST(ObjectDetectionGenerateTests, EmptyImagePathThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  EXPECT_THROW((void)model.generate("", 0.5), RnExecutorchError);
-}
-
-TEST(ObjectDetectionGenerateTests, MalformedURIThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  EXPECT_THROW((void)model.generate("not_a_valid_uri://bad", 0.5),
-               RnExecutorchError);
-}
-
-TEST(ObjectDetectionGenerateTests, NegativeThresholdThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  EXPECT_THROW((void)model.generate(kValidTestImagePath, -0.1),
-               RnExecutorchError);
-}
-
-TEST(ObjectDetectionGenerateTests, ThresholdAboveOneThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  EXPECT_THROW((void)model.generate(kValidTestImagePath, 1.1),
-               RnExecutorchError);
-}
-
-TEST(ObjectDetectionGenerateTests, ValidImageReturnsResults) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  auto results = model.generate(kValidTestImagePath, 0.3);
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(ObjectDetectionGenerateTests, HighThresholdReturnsFewerResults) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  auto lowThresholdResults = model.generate(kValidTestImagePath, 0.1);
-  auto highThresholdResults = model.generate(kValidTestImagePath, 0.9);
-  EXPECT_GE(lowThresholdResults.size(), highThresholdResults.size());
-}
-
-TEST(ObjectDetectionGenerateTests, DetectionsHaveValidBoundingBoxes) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  auto results = model.generate(kValidTestImagePath, 0.3);
-
-  for (const auto &detection : results) {
-    EXPECT_LE(detection.x1, detection.x2);
-    EXPECT_LE(detection.y1, detection.y2);
-    EXPECT_GE(detection.x1, 0.0f);
-    EXPECT_GE(detection.y1, 0.0f);
-  }
-}
-
-TEST(ObjectDetectionGenerateTests, DetectionsHaveValidScores) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  auto results = model.generate(kValidTestImagePath, 0.3);
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.score, 0.0f);
-    EXPECT_LE(detection.score, 1.0f);
-  }
-}
-
-TEST(ObjectDetectionGenerateTests, DetectionsHaveValidLabels) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  auto results = model.generate(kValidTestImagePath, 0.3);
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.label, 0);
-  }
-}
-
-TEST(ObjectDetectionInheritedTests, GetInputShapeWorks) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_EQ(shape.size(), 4);
-  EXPECT_EQ(shape[0], 1);
-  EXPECT_EQ(shape[1], 3);
-}
-
-TEST(ObjectDetectionInheritedTests, GetAllInputShapesWorks) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(ObjectDetectionInheritedTests, GetMethodMetaWorks) {
-  ObjectDetection model(kValidObjectDetectionModelPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}

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

@@ -1,97 +0,0 @@
-#include "BaseModelTests.h"
-#include "utils/TestUtils.h"
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/speech_to_text/SpeechToText.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::speech_to_text;
-using namespace test_utils;
-using namespace model_tests;
-
-constexpr auto kValidEncoderPath = "whisper_tiny_en_encoder_xnnpack.pte";
-constexpr auto kValidDecoderPath = "whisper_tiny_en_decoder_xnnpack.pte";
-constexpr auto kValidTokenizerPath = "whisper_tokenizer.json";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<SpeechToText> {
-  using ModelType = SpeechToText;
-
-  static ModelType createValid() {
-    return ModelType(kValidEncoderPath, kValidDecoderPath, kValidTokenizerPath,
-                     nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", kValidDecoderPath, kValidTokenizerPath,
-                     nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    auto audio = test_utils::loadAudioFromFile("test_audio_float.raw");
-    (void)model.transcribe(audio, "en");
-  }
-};
-} // namespace model_tests
-
-using SpeechToTextTypes = ::testing::Types<SpeechToText>;
-INSTANTIATE_TYPED_TEST_SUITE_P(SpeechToText, CommonModelTest,
-                               SpeechToTextTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(S2TCtorTests, InvalidDecoderPathThrows) {
-  EXPECT_THROW(SpeechToText(kValidEncoderPath, "nonexistent.pte",
-                            kValidTokenizerPath, nullptr),
-               RnExecutorchError);
-}
-
-TEST(S2TCtorTests, InvalidTokenizerPathThrows) {
-  EXPECT_THROW(SpeechToText(kValidEncoderPath, kValidDecoderPath,
-                            "nonexistent.json", nullptr),
-               RnExecutorchError);
-}
-
-TEST(S2TEncodeTests, EncodeReturnsNonNull) {
-  SpeechToText model(kValidEncoderPath, kValidDecoderPath, kValidTokenizerPath,
-                     nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  auto result = model.encode(audio);
-  EXPECT_NE(result, nullptr);
-  EXPECT_GT(result->size(), 0u);
-}
-
-TEST(S2TTranscribeTests, TranscribeReturnsValidChars) {
-  SpeechToText model(kValidEncoderPath, kValidDecoderPath, kValidTokenizerPath,
-                     nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  auto result = model.transcribe(audio, "en");
-  ASSERT_FALSE(result.empty());
-  for (char c : result) {
-    EXPECT_GE(static_cast<unsigned char>(c), 0);
-    EXPECT_LE(static_cast<unsigned char>(c), 127);
-  }
-}
-
-TEST(S2TTranscribeTests, EmptyResultOnSilence) {
-  SpeechToText model(kValidEncoderPath, kValidDecoderPath, kValidTokenizerPath,
-                     nullptr);
-  auto audio = generateSilence(16000 * 5);
-  auto result = model.transcribe(audio, "en");
-  EXPECT_TRUE(result.empty());
-}
-
-TEST(S2TTranscribeTests, InvalidLanguageThrows) {
-  SpeechToText model(kValidEncoderPath, kValidDecoderPath, kValidTokenizerPath,
-                     nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  EXPECT_THROW((void)model.transcribe(audio, "invalid_language_code"),
-               RnExecutorchError);
-}