react-native-executorch 0.7.0 → 0.7.2

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

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

@@ -1,112 +0,0 @@
-#include "BaseModelTests.h"
-#include "utils/TestUtils.h"
-#include <filesystem>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/style_transfer/StyleTransfer.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::style_transfer;
-using namespace model_tests;
-
-constexpr auto kValidStyleTransferModelPath =
-    "style_transfer_candy_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<StyleTransfer> {
-  using ModelType = StyleTransfer;
-
-  static ModelType createValid() {
-    return ModelType(kValidStyleTransferModelPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generate(kValidTestImagePath);
-  }
-};
-} // namespace model_tests
-
-using StyleTransferTypes = ::testing::Types<StyleTransfer>;
-INSTANTIATE_TYPED_TEST_SUITE_P(StyleTransfer, CommonModelTest,
-                               StyleTransferTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(StyleTransferGenerateTests, InvalidImagePathThrows) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW((void)model.generate("nonexistent_image.jpg"),
-               RnExecutorchError);
-}
-
-TEST(StyleTransferGenerateTests, EmptyImagePathThrows) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW((void)model.generate(""), RnExecutorchError);
-}
-
-TEST(StyleTransferGenerateTests, MalformedURIThrows) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW((void)model.generate("not_a_valid_uri://bad"),
-               RnExecutorchError);
-}
-
-TEST(StyleTransferGenerateTests, ValidImageReturnsFilePath) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.generate(kValidTestImagePath);
-  EXPECT_FALSE(result.empty());
-}
-
-TEST(StyleTransferGenerateTests, ResultIsValidFilePath) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.generate(kValidTestImagePath);
-  test_utils::trimFilePrefix(result);
-  EXPECT_TRUE(std::filesystem::exists(result));
-}
-
-TEST(StyleTransferGenerateTests, ResultFileHasContent) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.generate(kValidTestImagePath);
-  test_utils::trimFilePrefix(result);
-  auto fileSize = std::filesystem::file_size(result);
-  EXPECT_GT(fileSize, 0u);
-}
-
-TEST(StyleTransferGenerateTests, MultipleGeneratesWork) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_NO_THROW((void)model.generate(kValidTestImagePath));
-  auto result1 = model.generate(kValidTestImagePath);
-  auto result2 = model.generate(kValidTestImagePath);
-  test_utils::trimFilePrefix(result1);
-  test_utils::trimFilePrefix(result2);
-  EXPECT_TRUE(std::filesystem::exists(result1));
-  EXPECT_TRUE(std::filesystem::exists(result2));
-}
-
-TEST(StyleTransferInheritedTests, GetInputShapeWorks) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_EQ(shape.size(), 4);
-  EXPECT_EQ(shape[0], 1);
-  EXPECT_EQ(shape[1], 3);
-}
-
-TEST(StyleTransferInheritedTests, GetAllInputShapesWorks) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(StyleTransferInheritedTests, GetMethodMetaWorks) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}

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

@@ -1,164 +0,0 @@
-#include "BaseModelTests.h"
-#include <cmath>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/embeddings/text/TextEmbeddings.h>
-#include <string>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::embeddings;
-using namespace model_tests;
-
-constexpr auto kValidTextEmbeddingsModelPath = "all-MiniLM-L6-v2_xnnpack.pte";
-constexpr auto kValidTextEmbeddingsTokenizerPath = "tokenizer.json";
-constexpr size_t kMiniLmEmbeddingDimensions = 384;
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<TextEmbeddings> {
-  using ModelType = TextEmbeddings;
-
-  static ModelType createValid() {
-    return ModelType(kValidTextEmbeddingsModelPath,
-                     kValidTextEmbeddingsTokenizerPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", kValidTextEmbeddingsTokenizerPath,
-                     nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generate("Hello, world!");
-  }
-};
-} // namespace model_tests
-
-using TextEmbeddingsTypes = ::testing::Types<TextEmbeddings>;
-INSTANTIATE_TYPED_TEST_SUITE_P(TextEmbeddings, CommonModelTest,
-                               TextEmbeddingsTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(TextEmbeddingsCtorTests, InvalidTokenizerPathThrows) {
-  EXPECT_THROW(TextEmbeddings(kValidTextEmbeddingsModelPath,
-                              "this_tokenizer_does_not_exist.json", nullptr),
-               std::exception);
-}
-
-TEST(TextEmbeddingsGenerateTests, EmptyStringReturnsResults) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.generate("");
-  EXPECT_NE(result, nullptr);
-  EXPECT_GT(result->size(), 0u);
-}
-
-TEST(TextEmbeddingsGenerateTests, ValidTextReturnsResults) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.generate("Hello, world!");
-  EXPECT_NE(result, nullptr);
-  EXPECT_GT(result->size(), 0u);
-}
-
-TEST(TextEmbeddingsGenerateTests, ResultsHaveCorrectSize) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.generate("This is a test sentence.");
-  size_t numFloats = result->size() / sizeof(float);
-  EXPECT_EQ(numFloats, kMiniLmEmbeddingDimensions);
-}
-
-TEST(TextEmbeddingsGenerateTests, ResultsAreNormalized) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.generate("The quick brown fox jumps over the lazy dog.");
-
-  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(TextEmbeddingsGenerateTests, ResultsContainValidValues) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.generate("Testing valid values.");
-
-  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(TextEmbeddingsGenerateTests, DifferentTextProducesDifferentEmbeddings) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-
-  auto result1 = model.generate("Hello, world!");
-  auto result2 = model.generate("Goodbye, moon!");
-
-  const float *data1 = reinterpret_cast<const float *>(result1->data());
-  const float *data2 = reinterpret_cast<const float *>(result2->data());
-  size_t numFloats = result1->size() / sizeof(float);
-
-  bool allEqual = true;
-  for (size_t i = 0; i < numFloats; ++i) {
-    if (std::abs(data1[i] - data2[i]) > 1e-6f) {
-      allEqual = false;
-      break;
-    }
-  }
-  EXPECT_FALSE(allEqual);
-}
-
-TEST(TextEmbeddingsGenerateTests, SimilarTextProducesSimilarEmbeddings) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-
-  auto result1 = model.generate("I love programming");
-  auto result2 = model.generate("I enjoy coding");
-
-  const float *data1 = reinterpret_cast<const float *>(result1->data());
-  const float *data2 = reinterpret_cast<const float *>(result2->data());
-  size_t numFloats = result1->size() / sizeof(float);
-
-  float dotProduct = 0.0f;
-  for (size_t i = 0; i < numFloats; ++i) {
-    dotProduct += data1[i] * data2[i];
-  }
-  EXPECT_GT(dotProduct, 0.5f);
-}
-
-TEST(TextEmbeddingsInheritedTests, GetInputShapeWorks) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_GE(shape.size(), 2u);
-}
-
-TEST(TextEmbeddingsInheritedTests, GetAllInputShapesWorks) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(TextEmbeddingsInheritedTests, GetMethodMetaWorks) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}

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

@@ -1,149 +0,0 @@
-#include "BaseModelTests.h"
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/text_to_image/TextToImage.h>
-#include <string>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::text_to_image;
-using namespace model_tests;
-
-namespace rnexecutorch {
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker();
-}
-
-constexpr auto kValidTokenizerPath = "t2i_tokenizer.json";
-constexpr auto kValidEncoderPath = "t2i_encoder.pte";
-constexpr auto kValidUnetPath = "t2i_unet.pte";
-constexpr auto kValidDecoderPath = "t2i_decoder.pte";
-
-constexpr float kSchedulerBetaStart = 0.00085f;
-constexpr float kSchedulerBetaEnd = 0.012f;
-constexpr int32_t kSchedulerNumTrainTimesteps = 1000;
-constexpr int32_t kSchedulerStepsOffset = 1;
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<TextToImage> {
-  using ModelType = TextToImage;
-
-  static ModelType createValid() {
-    return ModelType(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                     kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                     kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.json", kValidEncoderPath, kValidUnetPath,
-                     kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                     kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generate("a cat", 128, 1, 42, nullptr);
-  }
-};
-} // namespace model_tests
-
-using TextToImageTypes = ::testing::Types<TextToImage>;
-INSTANTIATE_TYPED_TEST_SUITE_P(TextToImage, CommonModelTest, TextToImageTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(TextToImageCtorTests, InvalidEncoderPathThrows) {
-  EXPECT_THROW(TextToImage(kValidTokenizerPath, "nonexistent.pte",
-                           kValidUnetPath, kValidDecoderPath,
-                           kSchedulerBetaStart, kSchedulerBetaEnd,
-                           kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                           createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(TextToImageCtorTests, InvalidUnetPathThrows) {
-  EXPECT_THROW(TextToImage(kValidTokenizerPath, kValidEncoderPath,
-                           "nonexistent.pte", kValidDecoderPath,
-                           kSchedulerBetaStart, kSchedulerBetaEnd,
-                           kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                           createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(TextToImageCtorTests, InvalidDecoderPathThrows) {
-  EXPECT_THROW(TextToImage(kValidTokenizerPath, kValidEncoderPath,
-                           kValidUnetPath, "nonexistent.pte",
-                           kSchedulerBetaStart, kSchedulerBetaEnd,
-                           kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                           createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(TextToImageGenerateTests, InvalidImageSizeThrows) {
-  TextToImage model(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                    kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                    kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                    createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("a cat", 100, 1, 42, nullptr),
-               RnExecutorchError);
-}
-
-TEST(TextToImageGenerateTests, EmptyPromptThrows) {
-  TextToImage model(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                    kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                    kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                    createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("", 128, 1, 42, nullptr),
-               RnExecutorchError);
-}
-
-TEST(TextToImageGenerateTests, ZeroStepsThrows) {
-  TextToImage model(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                    kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                    kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                    createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("a cat", 128, 0, 42, nullptr),
-               RnExecutorchError);
-}
-
-TEST(TextToImageGenerateTests, GenerateReturnsNonNull) {
-  TextToImage model(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                    kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                    kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                    createMockCallInvoker());
-  auto result = model.generate("a cat", 128, 1, 42, nullptr);
-  EXPECT_NE(result, nullptr);
-}
-
-TEST(TextToImageGenerateTests, GenerateReturnsCorrectSize) {
-  TextToImage model(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                    kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                    kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                    createMockCallInvoker());
-  int32_t imageSize = 128;
-  auto result = model.generate("a cat", imageSize, 1, 42, nullptr);
-  ASSERT_NE(result, nullptr);
-  size_t expectedSize = imageSize * imageSize * 4;
-  EXPECT_EQ(result->size(), expectedSize);
-}
-
-TEST(TextToImageGenerateTests, SameSeedProducesSameResult) {
-  TextToImage model(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                    kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                    kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                    createMockCallInvoker());
-  auto result1 = model.generate("a cat", 128, 1, 42, nullptr);
-  auto result2 = model.generate("a cat", 128, 1, 42, nullptr);
-  ASSERT_NE(result1, nullptr);
-  ASSERT_NE(result2, nullptr);
-  ASSERT_EQ(result1->size(), result2->size());
-
-  auto data1 = static_cast<uint8_t *>(result1->data());
-  auto data2 = static_cast<uint8_t *>(result2->data());
-  for (size_t i = 0; i < result1->size(); i++) {
-    EXPECT_EQ(data1[i], data2[i]) << "at index: " << i;
-  }
-}