react-native-executorch 0.7.0 → 0.7.1

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

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

@@ -1,98 +0,0 @@
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/TokenizerModule.h>
-
-using namespace rnexecutorch;
-
-constexpr auto kValidTokenizerPath = "tokenizer.json";
-
-TEST(TokenizerCtorTests, InvalidPathThrows) {
-  EXPECT_THROW(TokenizerModule("nonexistent_tokenizer.json", nullptr),
-               RnExecutorchError);
-}
-
-TEST(TokenizerCtorTests, ValidPathDoesntThrow) {
-  EXPECT_NO_THROW(TokenizerModule(kValidTokenizerPath, nullptr));
-}
-
-TEST(TokenizerMemoryTests, MemoryLowerBoundIsPositive) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  EXPECT_GT(tokenizer.getMemoryLowerBound(), 0u);
-}
-
-TEST(TokenizerEncodeTests, EmptyStringReturnsEmptyString) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto tokens = tokenizer.encode("");
-  EXPECT_TRUE(tokens.empty());
-}
-
-TEST(TokenizerEncodeTests, SimpleTextReturnsTokens) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto tokens = tokenizer.encode("Hello world");
-  EXPECT_GT(tokens.size(), 0u);
-}
-
-TEST(TokenizerEncodeTests, SameTextReturnsSameTokens) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto tokens1 = tokenizer.encode("test");
-  auto tokens2 = tokenizer.encode("test");
-  EXPECT_EQ(tokens1, tokens2);
-}
-
-TEST(TokenizerEncodeTests, DifferentTextReturnsDifferentTokens) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto tokens1 = tokenizer.encode("hello");
-  auto tokens2 = tokenizer.encode("goodbye");
-  EXPECT_NE(tokens1, tokens2);
-}
-
-TEST(TokenizerEncodeTests, SpecialCharactersWork) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto tokens = tokenizer.encode("!@#$%^&*()");
-  EXPECT_GT(tokens.size(), 0u);
-}
-
-TEST(TokenizerEncodeTests, VeryLongTextWorks) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  std::string longText(10000, 'a');
-  EXPECT_NO_THROW((void)tokenizer.encode(longText));
-}
-
-TEST(TokenizerDecodeTests, DecodeEncodedTextReturnsOriginal) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  std::string original = "szponcik";
-  auto tokens = tokenizer.encode(original);
-  auto decoded = tokenizer.decode(tokens, true);
-  EXPECT_EQ(decoded, original);
-}
-
-TEST(TokenizerDecodeTests, DecodeEmptyVectorReturnsEmpty) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto decoded = tokenizer.decode({}, true);
-  EXPECT_TRUE(decoded.empty());
-}
-
-TEST(TokenizerIdToTokenTests, ValidIdReturnsToken) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto token = tokenizer.idToToken(0);
-  EXPECT_FALSE(token.empty());
-}
-
-TEST(TokenizerTokenToIdTests, RoundTripWorks) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto token = tokenizer.idToToken(100);
-  auto id = tokenizer.tokenToId(token);
-  EXPECT_EQ(id, 100);
-}
-
-TEST(TokenizerVocabTests, VocabSizeIsPositive) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  EXPECT_GT(tokenizer.getVocabSize(), 0u);
-}
-
-TEST(TokenizerVocabTests, VocabSizeIsReasonable) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto vocabSize = tokenizer.getVocabSize();
-  EXPECT_GT(vocabSize, 1000u);
-  EXPECT_LT(vocabSize, 1000000u);
-}