[libc][test] Remove dependency on sstream in algorithm_test.cpp

[gchatelet]

Summary

Bots have been failing in full build mode because ´#include <sstream>´ would pull pthread which is not possible when code is compiled with ´-freestanding´.

[courbet]

libc/test/src/string/memory_utils/algorithm_test.cpp

11

Is this fine ?

115

maybe std::string to avoid the zero-termination handling ?

[gchatelet]

• Address comments

libc/test/src/string/memory_utils/algorithm_test.cpp

11

It should as this is not testing implementations, only libraries.

libc/test/src/string/memory_utils/CMakeLists.txt

 add_libc_unittest(
   utils_test
   SUITE
     libc_string_unittests
   SRCS
     address_test.cpp
-    # algorithm_test.cpp
+    algorithm_test.cpp
     backend_test.cpp
     elements_test.cpp
     memory_access_test.cpp
     utils_test.cpp
   COMPILE_OPTIONS
     ${LIBC_COMPILE_OPTIONS_NATIVE}
     -ffreestanding
-    -pthread
   DEPENDS
     libc.src.string.memory_utils.memory_utils
     libc.src.__support.CPP.array
     libc.src.__support.CPP.array_ref
 )

libc/test/src/string/memory_utils/algorithm_test.cpp

 #define LLVM_LIBC_USE_BUILTIN_MEMCPY_INLINE 0
 #define LLVM_LIBC_USE_BUILTIN_MEMSET_INLINE 0
 
 #include "utils/UnitTest/Test.h"
 #include <src/__support/CPP/Array.h>
 #include <src/string/memory_utils/algorithm.h>
 #include <src/string/memory_utils/backends.h>
 
-#include <sstream>
+#include <string>
+#include <type_traits>
+#include <vector>
 
 namespace __llvm_libc {
 
 struct alignas(64) Buffer : cpp::Array<char, 128> {
   bool contains(const char *ptr) const {
     return ptr >= data() && ptr < (data() + size());
   }
   size_t getOffset(const char *ptr) const { return ptr - data(); }
   void fill(char c) {
     for (auto itr = begin(); itr != end(); ++itr)
       *itr = c;
   }
 };
 
 static Buffer buffer1;
 static Buffer buffer2;
-static std::ostringstream LOG;
+struct Logger {
+  Logger &operator<<(const char *str) {
+    Buffer.append(str);
+    return *this;
+  }
+  Logger &operator<<(char c) {
+    Buffer.push_back(c);
+    return *this;
+  }
+  template <typename Scalar>
+  std::enable_if_t<std::is_integral<Scalar>::value, Logger &>
+  operator<<(Scalar number) {
+    Buffer.append(std::to_string(number));
+    return *this;
+  }
+  const std::string &str() const { return Buffer; }
+
+private:
+  std::string Buffer;
+} LOG;
 
 struct TestBackend {
   static constexpr bool IS_BACKEND_TYPE = true;
 
   template <typename T> static void log(const char *Action, const char *ptr) {
     LOG << Action << "<" << sizeof(T) << "> ";
     if (buffer1.contains(ptr))
       LOG << "a[" << buffer1.getOffset(ptr) << "]";
struct TestBackend {
   }
 
   template <size_t Size>
   using getNextType = Scalar64BitBackend::getNextType<Size>;
 };
 
 struct LlvmLibcAlgorithm : public testing::Test {
   void SetUp() override {
-    LOG = std::ostringstream();
+    LOG = Logger();
     LOG << '\n';
   }
 
   void fillEqual() {
     buffer1.fill('a');
     buffer2.fill('a');
   }
 
   void fillDifferent() {
     buffer1.fill('a');
     buffer2.fill('b');
   }
 
   const char *getTrace() {
     trace_ = LOG.str();
     return trace_.c_str();
   }
 
-  const char *stripComments(const char *expected) {
+  const char *stripComments(std::string expected) {
     expected_.clear();
-    std::stringstream ss(expected);
-    std::string line;
-    while (std::getline(ss, line, '\n')) {
+    // split expected by lines
+    std::vector<std::string> lines;
+    lines.emplace_back();
+    for (const char c : expected) {
+      if (c == '\n') {
+        lines.emplace_back();
+      } else {
+        lines.back().push_back(c);
+      }
+    }
+    // strip comment for each lines
+    for (const std::string &line : lines) {
       const auto pos = line.find('#');
       if (pos == std::string::npos) {
         expected_ += line;
       } else {
         auto log = line.substr(0, pos);
         while (!log.empty() && std::isspace(log.back()))
           log.pop_back();
         expected_ += log;
       }
-      expected_ += '\n';
+      if (expected_.back() != '\n')
+        expected_.push_back('\n');
     }
     return expected_.c_str();
   }
 
   template <size_t Align = 1> SrcAddr<Align> buf1(size_t offset = 0) const {
     return buffer1.data() + offset;
   }
   template <size_t Align = 1> SrcAddr<Align> buf2(size_t offset = 0) const {