react-native-executorch 0.4.9 → 0.5.0-nightly-6f4dd53-20251211

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/NumericalTest.cpp

@@ -0,0 +1,110 @@
+#include "../data_processing/Numerical.h"
+#include <gtest/gtest.h>
+#include <limits>
+#include <span>
+#include <stdexcept>
+#include <vector>
+
+namespace rnexecutorch::numerical {
+
+// Helper function to check if two float vectors are approximately equal
+void expect_vectors_eq(const std::vector<float> &vector1,
+                       const std::vector<float> &vector2, float atol = 1.0e-6F) {
+  ASSERT_EQ(vector1.size(), vector2.size());
+  for (size_t i = 0; i < vector1.size(); i++) {
+    EXPECT_NEAR(vector1[i], vector2[i], atol);
+  }
+}
+
+TEST(SoftmaxTests, SoftmaxBasic) {
+  std::vector<float> input = {1.0F, 2.0F, 3.0F};
+  softmax(input);
+  const std::vector<float> expected = {0.09003057F, 0.24472847F, 0.66524095F};
+  expect_vectors_eq(input, expected);
+}
+
+TEST(SoftmaxTests, SoftmaxWithBigValues) {
+  std::vector<float> input = {100000.0F, 100000.0F, 100000.0F};
+  softmax(input);
+  const std::vector<float> expected = {0.3333333F, 0.3333333F, 0.3333333F};
+  expect_vectors_eq(input, expected);
+}
+
+TEST(SoftmaxTests, SoftmaxOfEmptyVector) {
+  std::vector<float> emptyVector{};
+  EXPECT_NO_THROW(softmax(emptyVector));
+}
+
+TEST(NormalizeTests, NormalizeBasic) {
+  std::vector<float> input = {1.0F, 2.0F, 3.0F};
+  normalize(input);
+  const auto normOfInput = std::sqrtf(14.0F);
+  const std::vector<float> expected = {1.0F / normOfInput, 2.0F / normOfInput,
+                                       3.0F / normOfInput};
+  expect_vectors_eq(input, expected);
+}
+
+TEST(NormalizeTests, NormalizationOfExtremelySmallValues) {
+  constexpr auto epsilon = std::numeric_limits<float>::epsilon();
+  std::vector<float> input(3, epsilon);
+  const auto normOfInput = std::sqrtf(3.0F);
+  const std::vector<float> expected(3, 1.0F / normOfInput);
+  normalize(input);
+  expect_vectors_eq(input, expected);
+}
+
+TEST(NormalizeTests, NormalizationOfZeroVector) {
+  std::vector<float> zeroVector(3, 0.0F);
+  EXPECT_NO_THROW(normalize(zeroVector));
+}
+
+TEST(NormalizeTests, NormalizationOfEmptyVector) {
+  std::vector<float> emptyVector{};
+  EXPECT_NO_THROW(normalize(emptyVector));
+}
+
+TEST(MeanPoolingTests, MeanPoolingBasic) {
+  const std::vector<float> modelOutputVec = {1.0F, 2.0F, 3.0F,
+                                             4.0F, 5.0F, 6.0F};
+  const std::vector<int64_t> attnMaskVec = {1, 1, 0};
+
+  std::span<const float> modelOutput(modelOutputVec);
+  std::span<const int64_t> attnMask(attnMaskVec);
+
+  const auto result = meanPooling(modelOutput, attnMask);
+  const std::vector<float> expected = {2.0F, 3.0F};
+  expect_vectors_eq(result, expected);
+}
+
+TEST(MeanPoolingTests, MeanPoolingWithZeroAttentionMask) {
+  const std::vector<float> modelOutputVec = {1.0F, 2.0F, 3.0F,
+                                             4.0F, 5.0F, 6.0F};
+  const std::vector<int64_t> attnMaskVec = {0, 0, 0};
+
+  std::span<const float> modelOutput(modelOutputVec);
+  std::span<const int64_t> attnMask(attnMaskVec);
+
+  const auto result = meanPooling(modelOutput, attnMask);
+  const std::vector<float> expected = {0.0F, 0.0F};
+  expect_vectors_eq(result, expected);
+}
+
+TEST(MeanPoolingTests, InvalidDimensionSize) {
+  const std::vector<float> modelOutput = {1.0F, 2.0F, 3.0F, 4.0F};
+  const std::vector<int64_t> attnMask = {1, 1, 1};
+
+  EXPECT_THROW(
+      { meanPooling(modelOutput, attnMask); },
+      std::invalid_argument);
+}
+
+TEST(MeanPoolingTests, EmptyAttentionMask) {
+  const std::vector<float> modelOutput = {1.0F, 2.0F, 3.0F, 4.0F};
+  const std::vector<int64_t> attnMask = {};
+
+  EXPECT_THROW(
+      { meanPooling(modelOutput, attnMask); },
+      std::invalid_argument);
+}
+
+} // namespace rnexecutorch::numerical

package/common/rnexecutorch/tests/README.md

@@ -0,0 +1,37 @@
+## 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's a flexible tool for creating unit tests.
+
+### Installation
+The googletest is already in repo in `react-native-executorch/third-party/googletest`. Firstly, you need to fetch googletest locally, run from root directory of project:
+* `git submodule update --init --recursive third-party/googletest`
+
+### Build Test Files
+To run tests navigate tests directory namely:
+* `cd packages/react-native-executorch/common/rnexecutorch/tests` 
+and then type:
+* `mkdir build && cd build`
+* `cmake ..`
+* `make`
+
+### Run Tests
+To run tests use the following command in `packages/react-native-executorch/common/rnexecutorch/tests/build`:
+* `ctest --verbose`
+
+Every time you updated the source code, you need to recompile the test files using: `cmake .. && make`.
+
+### How to add a new test
+To add new test you need to:
+* Place `*.cpp` file with tests using googletest in this directory.
+* In `CMakeLists.txt`, add all executables and link them with googletest, e.g.:
+    ```
+    set(SOURCE_FILES ${CMAKE_SOURCE_DIR}/../data_processing/Numerical.cpp)
+    add_executable(NumericalTests tests/NumericalTest.cpp ${SOURCE_FILES})
+    target_link_libraries(NumericalTests gtest gtest_main)
+    ```
+* Add test execution, e.g.:
+    ```
+    add_test(NAME NumericalTests COMMAND NumericalTests)
+    ```