react-native-executorch 0.4.7 → 0.5.1-rc.0

package/common/rnexecutorch/tests/LogTest.cpp

@@ -0,0 +1,530 @@
+#include "../Log.h"
+#include <gtest/gtest.h>
+
+#include <array>
+#include <cmath>
+#include <complex>
+#include <deque>
+#include <forward_list>
+#include <fstream>
+#include <functional>
+#include <list>
+#include <map>
+#include <queue>
+#include <regex>
+#include <set>
+#include <stack>
+#include <stdexcept>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace low_level_log_implementation {
+
+class TestValue : public ::testing::Test {
+protected:
+  TestValue() { oss << std::boolalpha; }
+
+  template <typename T>
+  void testValueViaComparison(const T &value,
+                              const std::string &expectedOutput) {
+    printElement(oss, value);
+    EXPECT_EQ(oss.str(), expectedOutput);
+    clearOutputStream(oss);
+  }
+
+  template <typename T>
+  void testValueViaRegex(const T &value, const std::string &expectedPattern) {
+    printElement(oss, value);
+    const std::regex pattern(expectedPattern);
+    EXPECT_TRUE(std::regex_search(oss.str(), pattern))
+        << "Expected pattern not found: " << expectedPattern;
+    clearOutputStream(oss);
+  }
+
+  void setOutputStreamPresicion(int precision) noexcept {
+    oss << std::fixed << std::setprecision(precision);
+  }
+
+private:
+  std::ostringstream oss;
+  void clearOutputStream(std::ostringstream &os) noexcept {
+    oss.str("");
+    oss.clear();
+  }
+};
+
+class DirectStreamableElementsPrintTest : public TestValue {};
+
+class ContainerPrintTest : public TestValue {};
+
+class NestedContainerPrintTest : public TestValue {};
+
+class EgdeCasesPrintTest : public TestValue {};
+
+class SmartPointerPrintTest : public TestValue {};
+
+class OptionalPrintTest : public TestValue {};
+
+class VariantPrintTest : public TestValue {};
+
+class ErrorHandlingPrintTest : public TestValue {};
+
+class FileSystemPrintTest : public TestValue {};
+
+class UnsupportedLoggingTest : public ::testing::Test {};
+
+class Point final {
+public:
+  explicit constexpr Point(int x, int y) noexcept : x(x), y(y) {}
+
+  // Overloading the << operator to make Point directly streamable
+  friend std::ostream &operator<<(std::ostream &os, const Point &pt) noexcept {
+    os << "Point(" << pt.x << ", " << pt.y << ")";
+    return os;
+  }
+
+private:
+  int x, y;
+};
+
+TEST_F(DirectStreamableElementsPrintTest, HandlesIntegers) {
+  testValueViaComparison(123, "123");
+}
+
+TEST_F(DirectStreamableElementsPrintTest, HandlesStrings) {
+  testValueViaComparison(std::string("Hello World"), "Hello World");
+}
+
+TEST_F(DirectStreamableElementsPrintTest, HandlesStringViews) {
+  testValueViaComparison(std::string_view("Hello World"), "Hello World");
+}
+
+TEST_F(DirectStreamableElementsPrintTest, HandlesDoubles) {
+  constexpr double roughlyPi = 3.14159;
+  testValueViaComparison(roughlyPi, "3.14159");
+}
+
+TEST_F(DirectStreamableElementsPrintTest, HandlesBooleans) {
+  testValueViaComparison(true, "true");
+  testValueViaComparison(false, "false");
+}
+
+TEST_F(DirectStreamableElementsPrintTest, HandlesChar) {
+  testValueViaComparison('a', "a");
+}
+
+TEST_F(DirectStreamableElementsPrintTest, HandlesCharPointer) {
+  const char *word = "Hello World";
+  testValueViaComparison(word, "Hello World");
+}
+
+TEST_F(DirectStreamableElementsPrintTest, HandlesComplexNumbers) {
+  using namespace std::complex_literals;
+  constexpr int presision = 1;
+  setOutputStreamPresicion(presision);
+  const std::complex<double> complexNumber = std::pow(1i, 2);
+  testValueViaComparison(complexNumber, "(-1.0,0.0)");
+}
+
+TEST_F(DirectStreamableElementsPrintTest, HandlesPoint) {
+  constexpr Point point(3, 4);
+  testValueViaComparison(point, "Point(3, 4)");
+}
+
+// log handles operator<<(&ostream) for std::pair
+TEST_F(DirectStreamableElementsPrintTest, HandlesStdPair) {
+  std::pair<int, std::string> pairOfIntAndString = {42, "Hello"};
+  testValueViaComparison(pairOfIntAndString, "(42, Hello)");
+
+  // Testing edge cases with pairs
+  const std::pair<std::string, std::string> emptyPair = {"", ""};
+  testValueViaComparison(emptyPair, "(, )");
+}
+
+TEST_F(DirectStreamableElementsPrintTest, handlesStaticArrayOfChars) {
+  constexpr char staticCharArray[] = "prompt tokens:";
+  testValueViaComparison(staticCharArray, "prompt tokens:");
+}
+
+// log handles operator<<(&ostream) for std::tuple
+TEST_F(DirectStreamableElementsPrintTest, HandlesStdTuple) {
+  const std::tuple<int, std::string, double> tupleOfDifferentTypes = {
+      42, "Tuple", 3.14};
+  testValueViaComparison(tupleOfDifferentTypes, "<42, Tuple, 3.14>");
+
+  // All empty or zero-initialized elements of tuple
+  const std::tuple<std::string, int, float> zeroInitializedTuple = {"", 0,
+                                                                    0.0f};
+  testValueViaComparison(zeroInitializedTuple, "<, 0, 0>");
+
+  // Nested tuple
+  const std::tuple<int, std::pair<std::string, bool>, float> nestedTuple = {
+      1, {"nested", true}, 2.5};
+  testValueViaComparison(nestedTuple, "<1, (nested, true), 2.5>");
+}
+
+TEST_F(ContainerPrintTest, VectorIntTest) {
+  const std::vector<int> vectorOfInts = {1, 2, 3, 4};
+  testValueViaComparison(vectorOfInts, "[1, 2, 3, 4]");
+}
+
+TEST_F(ContainerPrintTest, ListDoubleTest) {
+  const std::list<double> listOfDoubles = {1.1, 2.2, 3.3};
+  testValueViaComparison(listOfDoubles, "[1.1, 2.2, 3.3]");
+}
+
+TEST_F(ContainerPrintTest, DequeStringTest) {
+  const std::deque<std::string> dequeOfStrings = {"hello", "world"};
+  testValueViaComparison(dequeOfStrings, "[hello, world]");
+}
+
+TEST_F(ContainerPrintTest, SetTest) {
+  const std::set<std::string> setOfStrings = {"apple", "banana", "cherry"};
+  testValueViaComparison(setOfStrings,
+                         "[apple, banana, cherry]"); // Note: Sets are sorted
+}
+
+TEST_F(ContainerPrintTest, MapTest) {
+  const std::map<std::string, int> mapStringToInt = {{"one", 1}, {"two", 2}};
+  testValueViaComparison(mapStringToInt, "[(one, 1), (two, 2)]");
+}
+
+TEST_F(ContainerPrintTest, HandlesUnorderedSet) {
+  const std::unordered_set<int> unorderedSetOfInts = {4, 3, 2, 1};
+  // Pattern expects to find each element at least once in any order
+  testValueViaRegex(unorderedSetOfInts, R"(.*1.*2.*3.*4.*)");
+}
+
+TEST_F(ContainerPrintTest, HandlesUnorderedMultimap) {
+  const std::unordered_multimap<std::string, int> unorderedMultimapStringToInt =
+      {{"one", 1}, {"one", 2}, {"two", 2}};
+  std::string pattern = R"(\[\s*)";
+  // construct regex by adding each permutation
+  pattern += R"((?:\(one, 1\),\s*\(one, 2\),\s*\(two, 2\)|)";
+  pattern += R"(\(one, 1\),\s*\(two, 2\),\s*\(one, 2\)|)";
+  pattern += R"(\(one, 2\),\s*\(one, 1\),\s*\(two, 2\)|)";
+  pattern += R"(\(one, 2\),\s*\(two, 2\),\s*\(one, 1\)|)";
+  pattern += R"(\(two, 2\),\s*\(one, 1\),\s*\(one, 2\)|)";
+  pattern += R"(\(two, 2\),\s*\(one, 2\),\s*\(one, 1\))\s*\])";
+
+  testValueViaRegex(unorderedMultimapStringToInt, pattern);
+}
+
+TEST_F(ContainerPrintTest, StackTest) {
+  std::stack<int> stackOfInts;
+  stackOfInts.push(1);
+  stackOfInts.push(2);
+  stackOfInts.push(3);
+  testValueViaComparison(stackOfInts, "[3, 2, 1]"); // LIFO order
+}
+
+TEST_F(ContainerPrintTest, QueueTest) {
+  std::queue<int> queueOfInts;
+  queueOfInts.push(1);
+  queueOfInts.push(2);
+  queueOfInts.push(3);
+  testValueViaComparison(queueOfInts, "[1, 2, 3]"); // FIFO order
+}
+
+TEST_F(ContainerPrintTest, PriorityQueueTest) {
+  std::priority_queue<int> priorityQueueOfInts;
+  priorityQueueOfInts.push(3);
+  priorityQueueOfInts.push(1);
+  priorityQueueOfInts.push(2);
+  testValueViaComparison(priorityQueueOfInts,
+                         "[3, 2, 1]"); // Output based on internal max-heap
+}
+
+TEST_F(ContainerPrintTest, HandlesArray) {
+  constexpr std::array<int, 3> arrayOfInts = {1, 2, 3};
+  testValueViaComparison(arrayOfInts, "[1, 2, 3]");
+}
+
+TEST_F(ContainerPrintTest, HandlesForwardList) {
+  const std::forward_list<int> forwardListOfInts = {1, 2, 3};
+  testValueViaComparison(forwardListOfInts, "[1, 2, 3]");
+}
+
+TEST_F(ContainerPrintTest, HandlesMultiset) {
+  const std::multiset<int> multisetOfInts = {3, 2, 1, 2};
+  testValueViaComparison(multisetOfInts,
+                         "[1, 2, 2, 3]"); // Multiset elements are sorted
+}
+
+TEST_F(ContainerPrintTest, HandlesMultimap) {
+  const std::multimap<std::string, int> multimapStringToInt = {
+      {"one", 1}, {"one", 2}, {"two", 2}};
+  testValueViaComparison(multimapStringToInt, "[(one, 1), (one, 2), (two, 2)]");
+}
+
+TEST_F(ContainerPrintTest, HandlesSpan) {
+  std::vector<int> vectorOfInts = {1, 2, 3, 4};
+  const std::span<int> spanOnVector(
+      vectorOfInts.begin(), vectorOfInts.end()); // Create a span from a vector
+  testValueViaComparison(spanOnVector, "[1, 2, 3, 4]");
+}
+
+TEST_F(ContainerPrintTest, HandlesStaticArray) {
+  constexpr int staticArray[] = {1, 2, 3, 4, 5};
+  testValueViaComparison(staticArray, "[1, 2, 3, 4, 5]");
+}
+
+TEST_F(NestedContainerPrintTest, HandlesListOfQueuesOfPoints) {
+  std::list<std::queue<Point>> listOfQueues = {std::queue<Point>()};
+  listOfQueues.front().push(Point(1, 1));
+  listOfQueues.front().push(Point(2, 2));
+  listOfQueues.front().push(Point(3, 3));
+  testValueViaComparison(listOfQueues,
+                         "[[Point(1, 1), Point(2, 2), Point(3, 3)]]");
+}
+
+TEST_F(NestedContainerPrintTest, HandlesNestedVectors) {
+  const std::vector<std::vector<int>> nestedVector = {{1, 2}, {3, 4, 5}};
+  testValueViaComparison(nestedVector, "[[1, 2], [3, 4, 5]]");
+}
+
+TEST_F(NestedContainerPrintTest, HandlesMapOfVectorOfPoints) {
+  const std::map<std::string, std::vector<Point>> mapOfVectors = {
+      {"first", {Point(1, 2)}}, {"second", {Point(3, 4), Point(5, 6)}}};
+  testValueViaComparison(
+      mapOfVectors,
+      "[(first, [Point(1, 2)]), (second, [Point(3, 4), Point(5, 6)])]");
+}
+
+TEST_F(NestedContainerPrintTest, HandlesVectorOfMaps) {
+  const std::vector<std::map<std::string, int>> vectorOfMaps = {
+      {{"one", 1}, {"two", 2}}, {{"three", 3}, {"four", 4}}};
+  // word "three" is lexicographically smaller than "four"
+  testValueViaComparison(vectorOfMaps,
+                         "[[(one, 1), (two, 2)], [(four, 4), (three, 3)]]");
+}
+
+TEST_F(NestedContainerPrintTest, HandlesComplexNestedStructures) {
+  const std::vector<std::map<std::string, std::list<std::set<int>>>>
+      complexNested = {{{"first", {{1, 2}, {3}}}, {"second", {{4}}}}};
+  testValueViaComparison(complexNested,
+                         "[[(first, [[1, 2], [3]]), (second, [[4]])]]");
+}
+
+TEST_F(EgdeCasesPrintTest, HandleEmptyContainer) {
+  const std::vector<int> emptyVector{};
+  testValueViaComparison(emptyVector, "[]");
+}
+
+TEST_F(SmartPointerPrintTest, HandlesSharedPtr) {
+  const auto sharedPointer = std::make_shared<int>(10);
+  testValueViaComparison(sharedPointer, "10");
+}
+
+TEST_F(SmartPointerPrintTest, HandlesWeakPtr) {
+  auto sharedPointer = std::make_shared<int>(20);
+  std::weak_ptr<int> weakPointer = sharedPointer;
+  testValueViaComparison(weakPointer, "20");
+
+  sharedPointer.reset(); // Reset shared_ptr to make the weak_ptr expire
+  testValueViaComparison(weakPointer,
+                         "expired"); // Test after the weak pointer has expired
+}
+
+TEST_F(SmartPointerPrintTest, HandlesUniquePtr) {
+  const auto uniquePointer = std::make_unique<int>(30);
+  testValueViaComparison(uniquePointer, "30");
+}
+
+TEST_F(OptionalPrintTest, HandlesOptional) {
+  std::optional<int> optionalInt{40};
+  testValueViaComparison(optionalInt, "Optional(40)");
+  optionalInt.reset();
+  testValueViaComparison(optionalInt, "nullopt");
+}
+
+TEST_F(VariantPrintTest, HandlesVariant) {
+  std::variant<int, std::string> variantIntOrString = 10;
+  testValueViaComparison(variantIntOrString, "Variant(10)");
+  variantIntOrString = "Hello";
+  testValueViaComparison(variantIntOrString, "Variant(Hello)");
+}
+
+TEST_F(ErrorHandlingPrintTest, HandlesErrorCode) {
+  const auto errorCodeValue =
+      std::make_error_code(std::errc::function_not_supported).value();
+  const std::error_code errorCode =
+      make_error_code(std::errc::function_not_supported);
+  testValueViaComparison(
+      errorCode, "ErrorCode(" + std::to_string(errorCodeValue) + ", generic)");
+}
+
+TEST_F(ErrorHandlingPrintTest, HandlesExceptionPtr) {
+  try {
+    throw std::runtime_error("test error");
+  } catch (...) {
+    const std::exception_ptr exceptionPointer = std::current_exception();
+    testValueViaComparison(exceptionPointer, "ExceptionPtr(\"test error\")");
+  }
+}
+
+TEST_F(FileSystemPrintTest, HandlesPath) {
+  const std::filesystem::path filePath = "/path/to/some/file.txt";
+  testValueViaComparison(filePath, "Path(\"/path/to/some/file.txt\")");
+}
+
+TEST_F(FileSystemPrintTest, HandlesDirectoryIterator) {
+  // Setup a temporary directory and files within
+  std::filesystem::path directory =
+      std::filesystem::temp_directory_path() / "test_dir";
+  std::filesystem::create_directory(directory);
+
+  std::ofstream(directory / "file1.txt");
+  std::ofstream(directory / "file2.txt");
+
+  std::filesystem::directory_iterator begin(directory);
+
+  testValueViaRegex(
+      begin,
+      R"(Directory\["file1.txt", "file2.txt"\]|Directory\["file2.txt", "file1.txt"\])");
+
+  // Cleanup
+  std::filesystem::remove_all(directory);
+}
+
+TEST_F(UnsupportedLoggingTest, TestLoggingUnsupportedType) {
+  std::ostringstream oss;
+  class UnsupportedClass {};
+  const auto x = UnsupportedClass();
+
+  ASSERT_THROW({ printElement(oss, x); }, std::runtime_error);
+}
+
+} // namespace low_level_log_implementation
+
+namespace rnexecutorch {
+
+namespace high_level_log_implementation {
+
+class BufferTest : public ::testing::Test {
+protected:
+  // Helper to validate the final output
+  void validateBuffer(const std::string &result, const std::string &expected,
+                      std::size_t expectedSize) {
+    EXPECT_EQ(result, expected);
+    EXPECT_EQ(result.size(), expectedSize);
+    if (result.size() > expected.size()) {
+      EXPECT_EQ(result.substr(expected.size()), "...");
+    }
+  }
+};
+
+TEST_F(BufferTest, MessageShorterThanLimit) {
+  constexpr std::size_t smallLogLimit = 20;
+  const std::string message = "Short message";
+  auto result = getBuffer(message, smallLogLimit);
+  validateBuffer(result, message, message.size());
+}
+
+TEST_F(BufferTest, MessageExactlyAtLimit) {
+  // Creating a string with 1024 'a' characters
+  constexpr std::size_t defaultLogLimit = 1024;
+  const std::string message(defaultLogLimit, 'a');
+  auto result = getBuffer(message, defaultLogLimit);
+  validateBuffer(result, message, message.size());
+}
+
+TEST_F(BufferTest, MessageLongerThanLimit) {
+  constexpr std::size_t defaultLogLimit = 1024;
+  constexpr std::size_t sizeAboveLimit = 1050;
+  // Creating a string longer than the limit
+  const std::string message(sizeAboveLimit, 'a');
+  const auto expected = std::string(defaultLogLimit, 'a') + "...";
+  const auto result = getBuffer(message, defaultLogLimit);
+  validateBuffer(result, expected, expected.size());
+}
+
+} // namespace high_level_log_implementation
+
+class LoggingTest : public ::testing::Test {
+protected:
+  template <typename T>
+  void testLoggingDoesNotChangeContainer(const T &original) {
+    const auto copy = original; // Make a copy of the container
+    log(LOG_LEVEL::Info, original);
+    ASSERT_TRUE(check_if_same_content(original, copy))
+        << "Logging modified the content of the container.";
+  }
+
+private:
+  // == op for smart pointers compare addresses, check content maunally
+  template <typename T>
+  bool check_if_same_content(const std::shared_ptr<T> &a,
+                             const std::shared_ptr<T> &b) const noexcept {
+    if (!a || !b) {
+      return a == b;
+    }
+    return *a == *b;
+  }
+
+  template <typename T>
+  bool check_if_same_content(const T &original, const T &after) const noexcept {
+    // Requires that T has an equality operator (operator==)
+    return original == after;
+  }
+};
+
+TEST_F(LoggingTest, LoggingDoesNotChangeSharedPtr) {
+  const auto original = std::make_shared<int>(42);
+  testLoggingDoesNotChangeContainer(original);
+}
+
+TEST_F(LoggingTest, LoggingDoesNotChangeQueue) {
+  std::queue<int> original;
+  original.push(1);
+  original.push(2);
+  original.push(3);
+  testLoggingDoesNotChangeContainer(original);
+}
+
+TEST_F(LoggingTest, LoggingDoesNotChangeVector) {
+  const std::vector<int> original = {1, 2, 3, 4, 5};
+  testLoggingDoesNotChangeContainer(original);
+}
+
+TEST(LogFunctionTest, LoggingBasic) {
+  EXPECT_NO_THROW(log(LOG_LEVEL::Debug, "Test123"));
+}
+
+TEST(LogFunctionTest, LoggingWithNonDefaultLogSize) {
+  constexpr std::size_t sizeBiggerThanDefault = 2048;
+  const auto testString = std::string(sizeBiggerThanDefault, 'a');
+  EXPECT_NO_THROW(log<sizeBiggerThanDefault>(LOG_LEVEL::Info, testString));
+}
+
+TEST(LogFunctionTest, LoggingMoreThanOneElement) {
+  constexpr auto testStringLiteral = "Test123";
+  const auto testVector = std::vector<int>{1, 2, 3, 4};
+  const auto testPair = std::pair<int, double>(1, 2.0);
+  EXPECT_NO_THROW(
+      log(LOG_LEVEL::Debug, testStringLiteral, testVector, testPair));
+}
+
+TEST(MovingSequencable, MovingSequencableTest) {
+  std::priority_queue<int> q;
+  q.push(1);
+  q.push(2);
+  q.push(3);
+
+  log(LOG_LEVEL::Debug, q);
+  ASSERT_EQ(q.size(), 3);
+  const auto &cq = q;
+  log(LOG_LEVEL::Debug, cq);
+  ASSERT_EQ(cq.size(), 3);
+  log(LOG_LEVEL::Debug, std::move(q));
+  ASSERT_EQ(q.size(), 0);
+}
+
+} // namespace rnexecutorch
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}

package/common/rnexecutorch/tests/README.md

@@ -0,0 +1,20 @@
+## Native Test
+This guide provide information on how functions are tested, how to install all needed dependencies and how to run tests.
+
+### Used Tools
+To test the native code we use [`googletest`](https://github.com/google/googletest). It is a flexible tool for creating unit tests.
+
+### Installation
+The easiest way to install `googletest` is following:
+* Clone repo locally and checkout on newest release: 
+  `git clone git@github.com:google/googletest.git && cd googletest && git switch --detach v1.17.0`
+* Build library files:
+  * `mkdir build && cd build`
+  * `cmake ..`
+  * `make`
+* Add `/usr/local/include` and `/usr/local/lib` to your path if not already there.
+
+### Usage
+To run tests please use:
+* `run_test.sh` if you want to run one specific test, e.g. `run_test.sh LogTest.cpp`.
+* `run_all_tests.sh` if you want to run all tests in the `tests` directory.

package/common/rnexecutorch/tests/run_all_tests.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+# Get the directory where the script is located
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &> /dev/null && pwd)"
+
+# Loop through all .cpp files in that directory
+for file in "$SCRIPT_DIR"/*.cpp
+do
+    if [ -f "$file" ]; then
+        file_name=$(basename "$file")
+        echo "Processing $file_name"
+        "$SCRIPT_DIR"/run_test.sh "$file"
+    fi
+done

package/common/rnexecutorch/tests/run_test.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# Check if a file name is provided
+if [ "$#" -ne 1 ]; then
+  echo "Usage: $0 <cpp_file>"
+  exit 1
+fi
+
+file_name="$1"
+
+# Compile the file with specified libraries
+g++ -std=c++20 -o test_executable "$file_name" -lgtest -lgtest_main -lpthread
+
+# Execute the binary
+./test_executable
+
+# Remove the executable
+rm -f test_executable

package/ios/ExecutorchLib.xcframework/Info.plist

@@ -8,7 +8,7 @@
 			<key>BinaryPath</key>
 			<string>ExecutorchLib.framework/ExecutorchLib</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>ExecutorchLib.framework</string>
 			<key>SupportedArchitectures</key>
@@ -17,14 +17,12 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>ExecutorchLib.framework/ExecutorchLib</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64-simulator</string>
 			<key>LibraryPath</key>
 			<string>ExecutorchLib.framework</string>
 			<key>SupportedArchitectures</key>
@@ -33,6 +31,8 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/ios/RnExecutorch/ETInstaller.h

@@ -0,0 +1,8 @@
+#import <React/RCTCallInvokerModule.h>
+#import <React/RCTEventEmitter.h>
+#import <RnExecutorchSpec/RnExecutorchSpec.h>
+
+@interface ETInstaller
+    : RCTEventEmitter <NativeETInstallerSpec, RCTCallInvokerModule>
+
+@end

package/ios/RnExecutorch/ETInstaller.mm

@@ -0,0 +1,56 @@
+#import "ETInstaller.h"
+
+#import <React/RCTBridge+Private.h>
+
+#import <React/RCTCallInvoker.h>
+#import <ReactCommon/RCTTurboModule.h>
+#include <rnexecutorch/RnExecutorchInstaller.h>
+#include <stdexcept>
+
+using namespace facebook::react;
+
+@interface RCTBridge (JSIRuntime)
+- (void *)runtime;
+@end
+
+@implementation ETInstaller
+
+@synthesize callInvoker = _callInvoker;
+
+RCT_EXPORT_MODULE(ETInstaller);
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+  auto jsiRuntime =
+      reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
+  auto jsCallInvoker = _callInvoker.callInvoker;
+
+  assert(jsiRuntime != nullptr);
+
+  auto fetchUrl = [](std::string url) {
+    @try {
+      NSString *nsUrlStr =
+          [NSString stringWithCString:url.c_str()
+                             encoding:[NSString defaultCStringEncoding]];
+      NSURL *nsUrl = [NSURL URLWithString:nsUrlStr];
+      NSData *data = [NSData dataWithContentsOfURL:nsUrl];
+      const std::byte *bytePtr =
+          reinterpret_cast<const std::byte *>(data.bytes);
+      int bufferLength = [data length];
+      return std::vector<std::byte>(bytePtr, bytePtr + bufferLength);
+    } @catch (NSException *exception) {
+      throw std::runtime_error("Error fetching data from a url");
+    }
+  };
+  rnexecutorch::RnExecutorchInstaller::injectJSIBindings(
+      jsiRuntime, jsCallInvoker, fetchUrl);
+
+  NSLog(@"Successfully installed JSI bindings for react-native-executorch!");
+  return @true;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeETInstallerSpecJSI>(params);
+}
+
+@end