Setup oss to print bools correctly out-of-the-box & add three tests (#444)

## Description

As in the title, tiny changes in handling boolean values and added two
tests.

### Type of change

- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to not work as expected)
- [ ] Documentation update (improves or adds clarity to existing
documentation)

### Tested on

- [x] iOS
- [ ] Android

### Testing instructions

Run test with provided scripts and check if they pass

### Screenshots

<!-- Add screenshots here, if applicable -->

### Related issues

<!-- Link related issues here using #issue-number -->

### Checklist

- [x] I have performed a self-review of my code
- [x] I have commented my code, particularly in hard-to-understand areas
- [x] I have updated the documentation accordingly
- [x] My changes generate no new warnings

### Additional notes

<!-- Include any additional information, assumptions, or context that
reviewers might need to understand this PR. -->

---------

Co-authored-by: Mateusz Sluszniak <sluszmat@amazon.com>

Author: msluszniak

packages/react-native-executorch/common/rnexecutorch/Log.h

@@ -2,6 +2,7 @@
 #include <cstdint>
 #include <exception>
 #include <filesystem>
+#include <ios>
 #include <iostream>
 #include <iterator>
 #include <memory>
@@ -50,13 +51,28 @@ concept HasPop = requires(T t) {
 };
 
 template <typename T>
-concept HasEmpty = requires(T t) {
-  { t.empty() } -> std::convertible_to<int>;
+concept HasEmpty = requires(const T &t) {
+  { t.empty() } -> std::same_as<bool>;
 };
 
+// These two below are needed apart from TopAccessible and FrontAccessible
+// to guarantee that correct templated is matched
 template <typename T>
-concept Sequencable =
-    HasPop<T> && HasEmpty<T> && (FrontAccessible<T> || TopAccessible<T>);
+concept ReadOnlySequencableFront = requires(const T &t) {
+  { t.front() } -> std::same_as<const typename T::value_type &>;
+} && HasEmpty<T> && !Iterable<T>;
+
+template <typename T>
+concept ReadOnlySequencableTop = requires(const T &t) {
+  { t.top() } -> std::same_as<const typename T::value_type &>;
+} && HasEmpty<T> && !Iterable<T>;
+
+template <typename T>
+concept ReadOnlySequencable =
+    ReadOnlySequencableFront<T> || ReadOnlySequencableTop<T>;
+
+template <typename T>
+concept MutableSequencable = ReadOnlySequencable<T> && HasPop<T>;
 
 template <typename T>
 concept Streamable = requires(std::ostream &os, const T &t) {
@@ -79,13 +95,12 @@ concept WeakPointer = requires(const T &a) {
 };
 
 template <typename T>
-concept Fallback = !Iterable<T> && !Sequencable<T> && !Streamable<T> &&
-                   !SmartPointer<T> && !WeakPointer<T>;
+concept Fallback =
+    !Iterable<T> && !Streamable<T> && !SmartPointer<T> && !WeakPointer<T> &&
+    !ReadOnlySequencable<T> && !MutableSequencable<T>;
 
 } // namespace concepts
 
-void printElement(std::ostream &os, bool value);
-
 template <typename T>
   requires concepts::Streamable<T> && (!concepts::SmartPointer<T>)
 void printElement(std::ostream &os, const T &value);
@@ -103,9 +118,15 @@ template <typename T>
   requires concepts::Iterable<T> && (!concepts::Streamable<T>)
 void printElement(std::ostream &os, const T &container);
 
+template <typename T> void printSequencable(std::ostream &os, T &&container);
+
 template <typename T>
-  requires concepts::Sequencable<T>
-void printElement(std::ostream &os, T container);
+  requires concepts::ReadOnlySequencable<T>
+void printElement(std::ostream &os, const T &container);
+
+template <typename T>
+  requires concepts::MutableSequencable<T>
+void printElement(std::ostream &os, T &&container);
 
 template <typename... Args>
 void printElement(std::ostream &os, const std::tuple<Args...> &tpl);
@@ -132,10 +153,6 @@ void printElement(std::ostream &os,
 template <concepts::Fallback UnsupportedArg>
 void printElement(std::ostream &os, const UnsupportedArg &value);
 
-void printElement(std::ostream &os, bool value) {
-  os << (value ? "true" : "false");
-}
-
 void printElement(std::ostream &os, const std::error_code &ec);
 
 template <typename T>
@@ -189,30 +206,46 @@ void printElement(std::ostream &os, const T &container) {
   os << "]";
 }
 
-template <typename T>
-  requires concepts::Sequencable<T>
-void printElement(
-    std::ostream &os,
-    T container) { // Pass by value to prevent modifications to the original
+template <typename T> void printSequencable(std::ostream &os, T &&container) {
   os << "[";
-
   bool isFirst = true;
-  while (!container.empty()) {
+
+  auto printElementLambda = [&isFirst, &os](auto &&element) {
     if (!isFirst) {
       os << ", ";
     }
+    low_level_log_implementation::printElement(
+        os, std::forward<decltype(element)>(element));
+    isFirst = false;
+  };
+
+  while (!container.empty()) {
     if constexpr (concepts::FrontAccessible<T>) {
-      printElement(os, container.front());
+      printElementLambda(container.front());
     } else if constexpr (concepts::TopAccessible<T>) {
-      printElement(os, container.top());
+      printElementLambda(container.top());
     }
     container.pop();
-    isFirst = false;
   }
 
   os << "]";
 }
 
+template <typename T>
+  requires concepts::ReadOnlySequencable<T>
+void printElement(std::ostream &os, const T &container) {
+  T tempContainer = container; // Make a copy to preserve original container
+  printSequencable(
+      os, std::move(tempContainer)); // Use std::move since tempContainer won't
+                                     // be used again
+}
+
+template <typename T>
+  requires concepts::MutableSequencable<T>
+void printElement(std::ostream &os, T &&container) {
+  printSequencable(os, std::forward<T>(container));
+}
+
 template <typename... Args>
 void printElement(std::ostream &os, const std::tuple<Args...> &tpl) {
   os << "<";
@@ -388,6 +421,12 @@ std::string getBuffer(const std::string &logMessage,
   return logMessage;
 }
 
+std::ostringstream createConfiguredOutputStream() {
+  std::ostringstream oss;
+  oss << std::boolalpha;
+  return oss;
+}
+
 } // namespace high_level_log_implementation
 
 /**
@@ -416,14 +455,15 @@ std::string getBuffer(const std::string &logMessage,
  *    Nothing.
  */
 template <std::size_t MaxLogSize = 1024, typename... Args>
-void log(LOG_LEVEL logLevel, const Args &...args) {
-  std::ostringstream oss;
-  auto space = [&oss](const auto &arg) {
-    low_level_log_implementation::printElement(oss, arg);
+void log(LOG_LEVEL logLevel, Args &&...args) {
+  auto oss = high_level_log_implementation::createConfiguredOutputStream();
+  auto space = [&oss](auto &&arg) {
+    low_level_log_implementation::printElement(
+        oss, std::forward<decltype(arg)>(arg));
     oss << ' ';
   };
 
-  (..., space(args));
+  (..., space(std::forward<Args>(args)));
 
   // Remove the extra space after the last element
   std::string output = oss.str();

packages/react-native-executorch/common/rnexecutorch/tests/LogTest.cpp

@@ -24,6 +24,8 @@ 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) {
@@ -487,12 +489,39 @@ TEST_F(LoggingTest, LoggingDoesNotChangeVector) {
   testLoggingDoesNotChangeContainer(original);
 }
 
-TEST(LoggingTestTemplateArgument, LoggingWithNonDefaultLogSize) {
+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) {