react-native-executorch 0.7.0 → 0.7.1

package/common/rnexecutorch/tests/unit/LogTest.cpp

@@ -1,529 +0,0 @@
-#include "../Log.h"
-#include <gtest/gtest.h>
-
-#include <array>
-#include <cmath>
-#include <complex>
-#include <deque>
-#include <forward_list>
-#include <fstream>
-#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/unit/NumericalTest.cpp

@@ -1,107 +0,0 @@
-#include "../data_processing/Numerical.h"
-#include <gtest/gtest.h>
-#include <limits>
-#include <rnexecutorch/Error.h>
-#include <span>
-#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); }, RnExecutorchError);
-}
-
-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); }, RnExecutorchError);
-}
-
-} // namespace rnexecutorch::numerical