[libc][NFC] Remove the StreamWrapper class and use the new test logger.

[sivachandra]

Update bazel files.

libc/test/ErrnoSetterMatcher.h

template <typename T> class ErrnoSetterMatcher : public Matcher<T> {
   T ActualReturn;
   int ExpectedErrno;
   int ActualErrno;
 
 public:
   ErrnoSetterMatcher(T ExpectedReturn, int ExpectedErrno)
       : ExpectedReturn(ExpectedReturn), ExpectedErrno(ExpectedErrno) {}
 
-  void explainError(testutils::StreamWrapper &OS) override {
+  void explainError() override {
     if (ActualReturn != ExpectedReturn)
-      OS << "Expected return to be " << ExpectedReturn << " but got "
-         << ActualReturn << ".\nExpecte errno to be " << strerror(ExpectedErrno)
-         << " but got " << strerror(ActualErrno) << ".\n";
+      __llvm_libc::testing::tlog
+          << "Expected return to be " << ExpectedReturn << " but got "
+          << ActualReturn << ".\nExpecte errno to be "
+          << strerror(ExpectedErrno) << " but got " << strerror(ActualErrno)
+          << ".\n";
     else
-      OS << "Correct value " << ExpectedReturn
+      __llvm_libc::testing::tlog
+          << "Correct value " << ExpectedReturn
           << " was returned\nBut errno was unexpectely set to "
           << strerror(ActualErrno) << ".\n";
   }
 
   bool match(T Got) {
     ActualReturn = Got;
     ActualErrno = libc_errno;
     libc_errno = 0;
     return Got == ExpectedReturn && ActualErrno == ExpectedErrno;
   }

libc/test/UnitTest/CMakeLists.txt

 add_library(
-  TestLogger
-  TestLogger.cpp
-  TestLogger.h
-)
-target_include_directories(TestLogger PUBLIC ${LIBC_SOURCE_DIR})
-add_dependencies(TestLogger
-  libc.src.__support.CPP.string
-  libc.src.__support.CPP.string_view
-  libc.src.__support.OSUtil.osutil
-)
-
-add_library(
   LibcUnitTest
   Test.h
   LibcTest.cpp
   LibcTest.h
+  TestLogger.cpp
+  TestLogger.h
 )
 target_include_directories(LibcUnitTest PUBLIC ${LIBC_SOURCE_DIR})
 add_dependencies(
   LibcUnitTest
   libc.src.__support.CPP.string
   libc.src.__support.CPP.string_view
   libc.src.__support.CPP.type_traits
-  libc.src.__support.uint128 TestLogger)
-target_link_libraries(LibcUnitTest PUBLIC libc_test_utils TestLogger)
+  libc.src.__support.OSUtil.osutil
+  libc.src.__support.uint128)
+target_link_libraries(LibcUnitTest PUBLIC libc_test_utils)
 
 add_library(
   LibcUnitTestMain
   LibcTestMain.cpp
 )
 
 target_include_directories(LibcUnitTestMain PUBLIC ${LIBC_SOURCE_DIR})
 add_dependencies(LibcUnitTestMain LibcUnitTest)
 target_link_libraries(LibcUnitTestMain PUBLIC LibcUnitTest libc_test_utils)
 
 add_header_library(
   string_utils
   HDRS
   StringUtils.h
   DEPENDS
+    libc.src.__support.CPP.string
     libc.src.__support.CPP.type_traits
 )
 
 add_library(
   LibcFPTestHelpers
   FPExceptMatcher.cpp
   FPExceptMatcher.h
-  FPMatcher.cpp
   FPMatcher.h
 )
 target_include_directories(LibcFPTestHelpers PUBLIC ${LIBC_SOURCE_DIR})
 target_link_libraries(LibcFPTestHelpers LibcUnitTest libc_test_utils)
 add_dependencies(
   LibcFPTestHelpers
   LibcUnitTest
   libc.test.UnitTest.string_utils
   libc.src.__support.FPUtil.fp_bits
   libc.src.__support.FPUtil.fenv_impl
+  libc.test.UnitTest.string_utils
 )
 
 add_library(
   LibcMemoryHelpers
   MemoryMatcher.h
   MemoryMatcher.cpp
 )
 target_include_directories(LibcMemoryHelpers PUBLIC ${LIBC_SOURCE_DIR})

libc/test/UnitTest/FPExceptMatcher.h

template <typename Func> static FunctionCaller *getFunctionCaller(Func func) {
     return new Callable(func);
   }
 
   // Takes ownership of func.
   explicit FPExceptMatcher(FunctionCaller *func);
 
   bool match(bool unused) { return exceptionRaised; }
 
-  void explainError(testutils::StreamWrapper &stream) override {
-    stream << "A floating point exception should have been raised but it "
-           << "wasn't\n";
+  void explainError() override {
+    __llvm_libc::testing::tlog
+        << "A floating point exception should have been raised but it "
   }
 };
 
 } // namespace testing
 } // namespace fputil
 } // namespace __llvm_libc
 
 #define ASSERT_RAISES_FP_EXCEPT(func)                                          \

libc/test/UnitTest/FPMatcher.h

 //===-- FPMatchers.h --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H
 #define LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H
 
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
+#include "test/UnitTest/StringUtils.h"
 #include "test/UnitTest/Test.h"
 #include "utils/testutils/RoundingModeUtils.h"
 
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 namespace testing {
 
-template <typename ValType, typename StreamType>
+template <typename ValType>
 cpp::enable_if_t<cpp::is_floating_point_v<ValType>, void>
-describeValue(const char *label, ValType value, StreamType &stream);
+describeValue(const char *label, ValType value) {
+  __llvm_libc::testing::tlog << label;
+
+  FPBits<ValType> bits(value);
+  if (bits.is_nan()) {
+    __llvm_libc::testing::tlog << "(NaN)";
+  } else if (bits.is_inf()) {
+    if (bits.get_sign())
+      __llvm_libc::testing::tlog << "(-Infinity)";
+    else
+      __llvm_libc::testing::tlog << "(+Infinity)";
+  } else {
+    constexpr int exponentWidthInHex =
+        (fputil::ExponentWidth<ValType>::VALUE - 1) / 4 + 1;
+    constexpr int mantissaWidthInHex =
+        (fputil::MantissaWidth<ValType>::VALUE - 1) / 4 + 1;
+    constexpr int bitsWidthInHex =
+        sizeof(typename fputil::FPBits<ValType>::UIntType) * 2;
+
+    __llvm_libc::testing::tlog
+        << "0x"
+        << int_to_hex<typename fputil::FPBits<ValType>::UIntType>(
+               bits.uintval(), bitsWidthInHex)
+        << ", (S | E | M) = (" << (bits.get_sign() ? '1' : '0') << " | 0x"
+        << int_to_hex<uint16_t>(bits.get_unbiased_exponent(),
+                                exponentWidthInHex)
+        << " | 0x"
+        << int_to_hex<typename fputil::FPBits<ValType>::UIntType>(
+               bits.get_mantissa(), mantissaWidthInHex)
+        << ")";
+  }
+
+  __llvm_libc::testing::tlog << '\n';
+}
 
 template <typename T, __llvm_libc::testing::TestCondition Condition>
 class FPMatcher : public __llvm_libc::testing::Matcher<T> {
   static_assert(__llvm_libc::cpp::is_floating_point_v<T>,
                 "FPMatcher can only be used with floating point values.");
   static_assert(Condition == __llvm_libc::testing::Cond_EQ ||
                     Condition == __llvm_libc::testing::Cond_NE,
                 "Unsupported FPMathcer test condition.");
bool match(T actualValue) {
 
     // If condition == Cond_NE.
     if (actualBits.is_nan())
       return !expectedBits.is_nan();
     return expectedBits.is_nan() ||
            (actualBits.uintval() != expectedBits.uintval());
   }
 
-  void explainError(testutils::StreamWrapper &stream) override {
-    describeValue("Expected floating point value: ", expected, stream);
-    describeValue("  Actual floating point value: ", actual, stream);
+  void explainError() override {
+    describeValue("Expected floating point value: ", expected);
+    describeValue("  Actual floating point value: ", actual);
   }
 };
 
 template <__llvm_libc::testing::TestCondition C, typename T>
 FPMatcher<T, C> getMatcher(T expectedValue) {
   return FPMatcher<T, C>(expectedValue);
 }
 

libc/test/UnitTest/FPMatcher.cpp

-//===-- TestMatchers.cpp ----------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "FPMatcher.h"
-
-#include "src/__support/FPUtil/FPBits.h"
-
-#include "test/UnitTest/StringUtils.h"
-
-#include <sstream>
-#include <string>
-
-namespace __llvm_libc {
-namespace fputil {
-namespace testing {
-
-template <typename ValType, typename StreamType>
-cpp::enable_if_t<cpp::is_floating_point_v<ValType>, void>
-describeValue(const char *label, ValType value, StreamType &stream) {
-  stream << label;
-
-  FPBits<ValType> bits(value);
-  if (bits.is_nan()) {
-    stream << "(NaN)";
-  } else if (bits.is_inf()) {
-    if (bits.get_sign())
-      stream << "(-Infinity)";
-    else
-      stream << "(+Infinity)";
-  } else {
-    constexpr int exponentWidthInHex =
-        (fputil::ExponentWidth<ValType>::VALUE - 1) / 4 + 1;
-    constexpr int mantissaWidthInHex =
-        (fputil::MantissaWidth<ValType>::VALUE - 1) / 4 + 1;
-    constexpr int bitsWidthInHex =
-        sizeof(typename fputil::FPBits<ValType>::UIntType) * 2;
-
-    stream << "0x"
-           << int_to_hex<typename fputil::FPBits<ValType>::UIntType>(
-                  bits.uintval(), bitsWidthInHex)
-           << ", (S | E | M) = (" << (bits.get_sign() ? '1' : '0') << " | 0x"
-           << int_to_hex<uint16_t>(bits.get_unbiased_exponent(),
-                                   exponentWidthInHex)
-           << " | 0x"
-           << int_to_hex<typename fputil::FPBits<ValType>::UIntType>(
-                  bits.get_mantissa(), mantissaWidthInHex)
-           << ")";
-  }
-
-  stream << '\n';
-}
-
-template void describeValue<float>(const char *, float,
-                                   testutils::StreamWrapper &);
-template void describeValue<double>(const char *, double,
-                                    testutils::StreamWrapper &);
-template void describeValue<long double>(const char *, long double,
-                                         testutils::StreamWrapper &);
-
-template void describeValue<float>(const char *, float, std::stringstream &);
-template void describeValue<double>(const char *, double, std::stringstream &);
-template void describeValue<long double>(const char *, long double,
-                                         std::stringstream &);
-
-} // namespace testing
-} // namespace fputil
-} // namespace __llvm_libc

libc/test/UnitTest/LibcTest.h

 // This file can only include headers from src/__support/CPP/ or
 // utils/testutils. No other headers should be included.
 
 #include "PlatformDefs.h"
 
 #include "src/__support/CPP/string.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/type_traits.h"
+#include "test/UnitTest/TestLogger.h"
 #include "utils/testutils/ExecuteFunction.h"
-#include "utils/testutils/StreamWrapper.h"
 
 namespace __llvm_libc {
 namespace testing {
 
 class RunContext;
 
 // Only the following conditions are supported. Notice that we do not have
 // a TRUE or FALSE condition. That is because, C library funtions do not

 bool test(RunContext *Ctx, TestCondition Cond, ValType LHS, ValType RHS,
           const char *LHSStr, const char *RHSStr, const char *File,
           unsigned long Line);
 
 } // namespace internal
 
 struct MatcherBase {
   virtual ~MatcherBase() {}
-  virtual void explainError(testutils::StreamWrapper &OS) {
-    OS << "unknown error\n";
-  }
+  virtual void explainError() { tlog << "unknown error\n"; }
   // Override and return true to skip `explainError` step.
   virtual bool is_silent() const { return false; }
 };
 
 template <typename T> struct Matcher : public MatcherBase {
   bool match(T &t);
 };
 

libc/test/UnitTest/LibcTest.cpp

bool Test::testMatch(bool MatchResult, MatcherBase &Matcher, const char *LHSStr,
                      const char *RHSStr, const char *File, unsigned long Line) {
   if (MatchResult)
     return true;
 
   Ctx->markFail();
   if (!Matcher.is_silent()) {
     tlog << File << ":" << Line << ": FAILURE\n"
          << "Failed to match " << LHSStr << " against " << RHSStr << ".\n";
-    testutils::StreamWrapper OutsWrapper = testutils::outs();
-    Matcher.explainError(OutsWrapper);
+    Matcher.explainError();
   }
   return false;
 }
 
 #ifdef ENABLE_SUBPROCESS_TESTS
 
 bool Test::testProcessKilled(testutils::FunctionCaller *Func, int Signal,
                              const char *LHSStr, const char *RHSStr,

libc/test/UnitTest/MemoryMatcher.h

class MemoryMatcher : public __llvm_libc::testing::Matcher<MemoryView> {
   bool mismatch_size = false;
   size_t mismatch_index = -1;
 
 public:
   MemoryMatcher(MemoryView expectedValue) : expected(expectedValue) {}
 
   bool match(MemoryView actualValue);
 
-  void explainError(testutils::StreamWrapper &stream) override;
+  void explainError() override;
 };
 
 } // namespace __llvm_libc::memory::testing
 
 #define EXPECT_MEM_EQ(expected, actual)                                        \
   EXPECT_THAT(actual, __llvm_libc::memory::testing::MemoryMatcher(expected))
 #define ASSERT_MEM_EQ(expected, actual)                                        \
   ASSERT_THAT(actual, __llvm_libc::memory::testing::MemoryMatcher(expected))
 
 #endif
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_MEMORY_MATCHER_H

libc/test/UnitTest/MemoryMatcher.cpp

 //===-- MemoryMatcher.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "MemoryMatcher.h"
 
+#include "test/UnitTest/Test.h"
+
+using __llvm_libc::testing::tlog;
+
 namespace __llvm_libc {
 namespace memory {
 namespace testing {
 
 template <typename T>
 bool equals(const cpp::span<T> &Span1, const cpp::span<T> &Span2,
             bool &mismatch_size, size_t &mismatch_index) {
   if (Span1.size() != Span2.size()) {
     mismatch_size = true;
     return false;
   }
   for (size_t Index = 0; Index < Span1.size(); ++Index)
     if (Span1[Index] != Span2[Index]) {
       mismatch_index = Index;
       return false;
     }
   return true;
 }
 
 bool MemoryMatcher::match(MemoryView actualValue) {
   actual = actualValue;
   return equals(expected, actual, mismatch_size, mismatch_index);
 }
 
-void display(testutils::StreamWrapper &Stream, char C) {
-  const auto print = [&Stream](unsigned char I) {
-    Stream << static_cast<char>(I < 10 ? '0' + I : 'A' + I - 10);
+static void display(char C) {
+  const auto print = [](unsigned char I) {
+    tlog << static_cast<char>(I < 10 ? '0' + I : 'A' + I - 10);
   };
   print(static_cast<unsigned char>(C) / 16);
   print(static_cast<unsigned char>(C) & 15);
 }
 
-void display(testutils::StreamWrapper &Stream, MemoryView View) {
+static void display(MemoryView View) {
   for (auto C : View) {
-    Stream << ' ';
-    display(Stream, C);
+    tlog << ' ';
+    display(C);
   }
 }
 
-void MemoryMatcher::explainError(testutils::StreamWrapper &Stream) {
+void MemoryMatcher::explainError() {
   if (mismatch_size) {
-    Stream << "Size mismatch :";
-    Stream << "expected : ";
-    Stream << expected.size();
-    Stream << '\n';
-    Stream << "actual   : ";
-    Stream << actual.size();
-    Stream << '\n';
+    tlog << "Size mismatch :";
+    tlog << "expected : ";
+    tlog << expected.size();
+    tlog << '\n';
+    tlog << "actual   : ";
+    tlog << actual.size();
+    tlog << '\n';
   } else {
-    Stream << "Mismatch at position : ";
-    Stream << mismatch_index;
-    Stream << " / ";
-    Stream << expected.size();
-    Stream << "\n";
-    Stream << "expected :";
-    display(Stream, expected);
-    Stream << '\n';
-    Stream << "actual   :";
-    display(Stream, actual);
-    Stream << '\n';
+    tlog << "Mismatch at position : ";
+    tlog << mismatch_index;
+    tlog << " / ";
+    tlog << expected.size();
+    tlog << "\n";
+    tlog << "expected :";
+    display(expected);
+    tlog << '\n';
+    tlog << "actual   :";
+    display(actual);
+    tlog << '\n';
   }
 }
 
 } // namespace testing
 } // namespace memory
 } // namespace __llvm_libc

libc/test/UnitTest/PrintfMatcher.h

class FormatSectionMatcher
   FormatSection expected;
   FormatSection actual;
 
 public:
   FormatSectionMatcher(FormatSection expectedValue) : expected(expectedValue) {}
 
   bool match(FormatSection actualValue);
 
-  void explainError(testutils::StreamWrapper &stream) override;
+  void explainError() override;
 };
 
 } // namespace testing
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #define EXPECT_PFORMAT_EQ(expected, actual)                                    \
   EXPECT_THAT(actual, __llvm_libc::printf_core::testing::FormatSectionMatcher( \
                           expected))
 
 #define ASSERT_PFORMAT_EQ(expected, actual)                                    \
   ASSERT_THAT(actual, __llvm_libc::printf_core::testing::FormatSectionMatcher( \
                           expected))
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_PRINTF_MATCHER_H

libc/test/UnitTest/PrintfMatcher.cpp

 //===-- PrintfMatcher.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrintfMatcher.h"
 
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/stdio/printf_core/core_structs.h"
 
 #include "test/UnitTest/StringUtils.h"
+#include "test/UnitTest/Test.h"
 
 #include <stdint.h>
 
+using __llvm_libc::testing::tlog;
+
 namespace __llvm_libc {
 namespace printf_core {
 namespace testing {
 
 bool FormatSectionMatcher::match(FormatSection actualValue) {
   actual = actualValue;
   return expected == actual;
 }
 
 namespace {
 
 #define IF_FLAG_SHOW_FLAG(flag_name)                                           \
   do {                                                                         \
     if ((form.flags & FormatFlags::flag_name) == FormatFlags::flag_name)       \
-      stream << "\n\t\t" << #flag_name;                                        \
+      tlog << "\n\t\t" << #flag_name;                                          \
   } while (false)
 #define CASE_LM(lm)                                                            \
   case (LengthModifier::lm):                                                   \
-    stream << #lm;                                                             \
+    tlog << #lm;                                                               \
     break
 
-void display(testutils::StreamWrapper &stream, FormatSection form) {
-  stream << "Raw String (len " << form.raw_string.size() << "): \"";
+static void display(FormatSection form) {
+  tlog << "Raw String (len " << form.raw_string.size() << "): \"";
   for (size_t i = 0; i < form.raw_string.size(); ++i) {
-    stream << form.raw_string[i];
+    tlog << form.raw_string[i];
   }
-  stream << "\"";
+  tlog << "\"";
   if (form.has_conv) {
-    stream << "\n\tHas Conv\n\tFlags:";
+    tlog << "\n\tHas Conv\n\tFlags:";
     IF_FLAG_SHOW_FLAG(LEFT_JUSTIFIED);
     IF_FLAG_SHOW_FLAG(FORCE_SIGN);
     IF_FLAG_SHOW_FLAG(SPACE_PREFIX);
     IF_FLAG_SHOW_FLAG(ALTERNATE_FORM);
     IF_FLAG_SHOW_FLAG(LEADING_ZEROES);
-    stream << "\n";
-    stream << "\tmin width: " << form.min_width << "\n";
-    stream << "\tprecision: " << form.precision << "\n";
-    stream << "\tlength modifier: ";
+    tlog << "\n";
+    tlog << "\tmin width: " << form.min_width << "\n";
+    tlog << "\tprecision: " << form.precision << "\n";
+    tlog << "\tlength modifier: ";
     switch (form.length_modifier) {
       CASE_LM(none);
       CASE_LM(l);
       CASE_LM(ll);
       CASE_LM(h);
       CASE_LM(hh);
       CASE_LM(j);
       CASE_LM(z);
       CASE_LM(t);
       CASE_LM(L);
     }
-    stream << "\n";
-    stream << "\tconversion name: " << form.conv_name << "\n";
+    tlog << "\n";
+    tlog << "\tconversion name: " << form.conv_name << "\n";
     if (form.conv_name == 'p' || form.conv_name == 'n' || form.conv_name == 's')
-      stream << "\tpointer value: "
-             << int_to_hex<uintptr_t>(
-                    reinterpret_cast<uintptr_t>(form.conv_val_ptr))
-             << "\n";
+      tlog << "\tpointer value: "
     else if (form.conv_name != '%')
-      stream << "\tvalue: "
-             << int_to_hex<fputil::FPBits<long double>::UIntType>(
-                    form.conv_val_raw)
-             << "\n";
+      tlog << "\tvalue: "
   }
 }
 } // anonymous namespace
 
-void FormatSectionMatcher::explainError(testutils::StreamWrapper &stream) {
-  stream << "expected format section: ";
-  display(stream, expected);
-  stream << '\n';
-  stream << "actual format section  : ";
-  display(stream, actual);
-  stream << '\n';
+void FormatSectionMatcher::explainError() {
+  tlog << "expected format section: ";
+  display(expected);
+  tlog << '\n';
+  tlog << "actual format section  : ";
+  display(actual);
+  tlog << '\n';
 }
 
 } // namespace testing
 } // namespace printf_core
 } // namespace __llvm_libc

libc/test/UnitTest/ScanfMatcher.h

class FormatSectionMatcher
   FormatSection expected;
   FormatSection actual;
 
 public:
   FormatSectionMatcher(FormatSection expectedValue) : expected(expectedValue) {}
 
   bool match(FormatSection actualValue);
 
-  void explainError(testutils::StreamWrapper &stream) override;
+  void explainError() override;
 };
 
 } // namespace testing
 } // namespace scanf_core
 } // namespace __llvm_libc
 
 #define EXPECT_SFORMAT_EQ(expected, actual)                                    \
   EXPECT_THAT(actual, __llvm_libc::scanf_core::testing::FormatSectionMatcher(  \
                           expected))
 
 #define ASSERT_SFORMAT_EQ(expected, actual)                                    \
   ASSERT_THAT(actual, __llvm_libc::scanf_core::testing::FormatSectionMatcher(  \
                           expected))
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_SCANF_MATCHER_H

libc/test/UnitTest/ScanfMatcher.cpp

 //===-- ScanfMatcher.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ScanfMatcher.h"
 
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/stdio/scanf_core/core_structs.h"
 
 #include "test/UnitTest/StringUtils.h"
+#include "test/UnitTest/Test.h"
 
 #include <stdint.h>
 
+using __llvm_libc::testing::tlog;
+
 namespace __llvm_libc {
 namespace scanf_core {
 namespace testing {
 
 bool FormatSectionMatcher::match(FormatSection actualValue) {
   actual = actualValue;
   return expected == actual;
 }
 
 namespace {
 
 #define IF_FLAG_SHOW_FLAG(flag_name)                                           \
   do {                                                                         \
     if ((form.flags & FormatFlags::flag_name) == FormatFlags::flag_name)       \
-      stream << "\n\t\t" << #flag_name;                                        \
+      tlog << "\n\t\t" << #flag_name;                                          \
   } while (false)
 #define CASE_LM(lm)                                                            \
   case (LengthModifier::lm):                                                   \
-    stream << #lm;                                                             \
+    tlog << #lm;                                                               \
     break
 
-void display(testutils::StreamWrapper &stream, FormatSection form) {
-  stream << "Raw String (len " << form.raw_string.size() << "): \"";
+void display(FormatSection form) {
+  tlog << "Raw String (len " << form.raw_string.size() << "): \"";
   for (size_t i = 0; i < form.raw_string.size(); ++i) {
-    stream << form.raw_string[i];
+    tlog << form.raw_string[i];
   }
-  stream << "\"";
+  tlog << "\"";
   if (form.has_conv) {
-    stream << "\n\tHas Conv\n\tFlags:";
+    tlog << "\n\tHas Conv\n\tFlags:";
     IF_FLAG_SHOW_FLAG(NO_WRITE);
     IF_FLAG_SHOW_FLAG(ALLOCATE);
-    stream << "\n";
-    stream << "\tmax width: " << form.max_width << "\n";
-    stream << "\tlength modifier: ";
+    tlog << "\n";
+    tlog << "\tmax width: " << form.max_width << "\n";
+    tlog << "\tlength modifier: ";
     switch (form.length_modifier) {
       CASE_LM(NONE);
       CASE_LM(l);
       CASE_LM(ll);
       CASE_LM(h);
       CASE_LM(hh);
       CASE_LM(j);
       CASE_LM(z);
       CASE_LM(t);
       CASE_LM(L);
     }
-    stream << "\n";
+    tlog << "\n";
     // If the pointer is used (NO_WRITE is not set and the conversion isn't %).
     if (((form.flags & FormatFlags::NO_WRITE) == 0) &&
         (form.conv_name != '%')) {
-      stream << "\tpointer value: "
-             << int_to_hex<uintptr_t>(
-                    reinterpret_cast<uintptr_t>(form.output_ptr))
-             << "\n";
+      tlog << "\tpointer value: "
     }
 
-    stream << "\tconversion name: " << form.conv_name << "\n";
+    tlog << "\tconversion name: " << form.conv_name << "\n";
 
     if (form.conv_name == '[') {
-      stream << "\t\t";
+      tlog << "\t\t";
       for (size_t i = 0; i < 256 /* char max */; ++i) {
         if (form.scan_set.test(i)) {
-          stream << static_cast<char>(i);
+          tlog << static_cast<char>(i);
         }
       }
-      stream << "\n\t]\n";
+      tlog << "\n\t]\n";
     }
   }
 }
 } // anonymous namespace
 
-void FormatSectionMatcher::explainError(testutils::StreamWrapper &stream) {
-  stream << "expected format section: ";
-  display(stream, expected);
-  stream << '\n';
-  stream << "actual format section  : ";
-  display(stream, actual);
-  stream << '\n';
+void FormatSectionMatcher::explainError() {
+  tlog << "expected format section: ";
+  display(expected);
+  tlog << '\n';
+  tlog << "actual format section  : ";
+  display(actual);
+  tlog << '\n';
 }
 
 } // namespace testing
 } // namespace scanf_core
 } // namespace __llvm_libc

libc/test/UnitTest/StringUtils.h

 //===-- String utils for matchers -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H
 #define LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H
 
+#include "src/__support/CPP/string.h"
 #include "src/__support/CPP/type_traits.h"
 
-#include <string>
-
 namespace __llvm_libc {
 
 // Return the first N hex digits of an integer as a string in upper case.
 template <typename T>
-cpp::enable_if_t<cpp::is_integral_v<T>, std::string>
-int_to_hex(T X, size_t Length = sizeof(T) * 2) {
-  std::string s(Length, '0');
-
-  for (auto it = s.rbegin(), end = s.rend(); it != end; ++it, X >>= 4) {
-    unsigned char Mod = static_cast<unsigned char>(X) & 15;
-    *it = (Mod < 10 ? '0' + Mod : 'a' + Mod - 10);
+cpp::enable_if_t<cpp::is_integral_v<T>, cpp::string>
+int_to_hex(T value, size_t length = sizeof(T) * 2) {
+  cpp::string s(length, '0');
+
+  constexpr char HEXADECIMALS[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
+                                     '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+  for (size_t i = 0; i < length; i += 2, value >>= 8) {
+    unsigned char mod = static_cast<unsigned char>(value) & 0xFF;
+    s[length - i] = HEXADECIMALS[mod & 0x0F];
+    s[length - (i + 1)] = HEXADECIMALS[mod & 0x0F];
   }
 
-  return s;
+  return "0x" + s;
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H

libc/test/UnitTest/TestLogger.cpp

 #include "test/UnitTest/TestLogger.h"
 #include "src/__support/CPP/string.h"
 #include "src/__support/CPP/string_view.h"
-#include "src/__support/OSUtil/io.h" //write_to_stderr
+#include "src/__support/OSUtil/io.h" // write_to_stderr
 
+#include <stdint.h>
+
 namespace __llvm_libc {
 namespace testing {
 
 // cpp::string_view specialization
 template <>
 TestLogger &TestLogger::operator<< <cpp::string_view>(cpp::string_view str) {
   __llvm_libc::write_to_stderr(str);
   return *this;
 }
 
 // cpp::string specialization
 template <> TestLogger &TestLogger::operator<< <cpp::string>(cpp::string str) {
   return *this << static_cast<cpp::string_view>(str);
 }
 
 // const char* specialization
 template <> TestLogger &TestLogger::operator<< <const char *>(const char *str) {
   return *this << cpp::string_view(str);
 }
 
+// char* specialization
+template <> TestLogger &TestLogger::operator<< <char *>(char *str) {
+  return *this << cpp::string_view(str);
+}
+
 // char specialization
 template <> TestLogger &TestLogger::operator<<(char ch) {
   return *this << cpp::string_view(&ch, 1);
 }
 
+// void * specialization
+template <> TestLogger &TestLogger::operator<<(void *addr) {
+  return *this << "0x" << cpp::to_string(reinterpret_cast<uintptr_t>(addr));
+}
+
 template <typename T> TestLogger &TestLogger::operator<<(T t) {
   return *this << cpp::to_string(t);
 }
 
 // is_integral specializations
 template TestLogger &TestLogger::operator<< <int>(int);
 template TestLogger &TestLogger::operator<< <unsigned int>(unsigned int);
 template TestLogger &TestLogger::operator<< <long>(long);

libc/test/src/math/log10_test.cpp

 //===-- Unittests for log10 -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/errno/libc_errno.h"
 #include "src/math/log10.h"
 #include "test/UnitTest/FPMatcher.h"
 #include "test/UnitTest/Test.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
-#include "utils/testutils/StreamWrapper.h"
 #include <math.h>
 
 #include <errno.h>
 #include <stdint.h>
 
 namespace mpfr = __llvm_libc::testing::mpfr;
-auto outs = __llvm_libc::testutils::outs();
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(LlvmLibcLog10Test, SpecialNumbers) {
   EXPECT_FP_EQ(aNaN, __llvm_libc::log10(aNaN));
   EXPECT_FP_EQ(inf, __llvm_libc::log10(inf));
   EXPECT_TRUE(FPBits(__llvm_libc::log10(neg_inf)).is_nan());
   EXPECT_FP_EQ(neg_inf, __llvm_libc::log10(0.0));
for (uint64_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
         while (!EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(
             mpfr::Operation::Log10, x, result, tol, rounding_mode)) {
           mx = x;
           mr = result;
           tol *= 2.0;
         }
       }
     }
-    outs << " Log10 failed: " << fails << "/" << count << "/" << cc
-         << " tests.\n";
-    outs << "   Max ULPs is at most: " << tol << ".\n";
     if (fails) {
       EXPECT_MPFR_MATCH(mpfr::Operation::Log10, mx, mr, 0.5, rounding_mode);
     }
   };
 
-  outs << " Test Rounding To Nearest...\n";
   test(mpfr::RoundingMode::Nearest);
 
-  outs << " Test Rounding Downward...\n";
   test(mpfr::RoundingMode::Downward);
 
-  outs << " Test Rounding Upward...\n";
   test(mpfr::RoundingMode::Upward);
 
-  outs << " Test Rounding Toward Zero...\n";
   test(mpfr::RoundingMode::TowardZero);
 }

libc/test/src/time/TmMatcher.h

return (actual.tm_sec == expected.tm_sec ||
             actual.tm_mday == expected.tm_mday ||
             actual.tm_mon == expected.tm_mon ||
             actual.tm_year == expected.tm_year ||
             actual.tm_wday == expected.tm_wday ||
             actual.tm_yday == expected.tm_yday ||
             actual.tm_isdst == expected.tm_isdst);
   }
 
-  void describeValue(const char *label, ::tm value,
-                     __llvm_libc::testutils::StreamWrapper &stream) {
-    stream << label;
-    stream << " sec: " << value.tm_sec;
-    stream << " min: " << value.tm_min;
-    stream << " hour: " << value.tm_hour;
-    stream << " mday: " << value.tm_mday;
-    stream << " mon: " << value.tm_mon;
-    stream << " year: " << value.tm_year;
-    stream << " wday: " << value.tm_wday;
-    stream << " yday: " << value.tm_yday;
-    stream << " isdst: " << value.tm_isdst;
-    stream << '\n';
+  void describeValue(const char *label, ::tm value) {
+    __llvm_libc::testing::tlog << label;
+    __llvm_libc::testing::tlog << " sec: " << value.tm_sec;
+    __llvm_libc::testing::tlog << " min: " << value.tm_min;
+    __llvm_libc::testing::tlog << " hour: " << value.tm_hour;
+    __llvm_libc::testing::tlog << " mday: " << value.tm_mday;
+    __llvm_libc::testing::tlog << " mon: " << value.tm_mon;
+    __llvm_libc::testing::tlog << " year: " << value.tm_year;
+    __llvm_libc::testing::tlog << " wday: " << value.tm_wday;
+    __llvm_libc::testing::tlog << " yday: " << value.tm_yday;
+    __llvm_libc::testing::tlog << " isdst: " << value.tm_isdst;
+    __llvm_libc::testing::tlog << '\n';
   }
 
-  void explainError(__llvm_libc::testutils::StreamWrapper &stream) override {
-    describeValue("Expected tm_struct value: ", expected, stream);
-    describeValue("  Actual tm_struct value: ", actual, stream);
+  void explainError() override {
+    describeValue("Expected tm_struct value: ", expected);
+    describeValue("  Actual tm_struct value: ", actual);
   }
 };
 
 } // namespace testing
 } // namespace tmmatcher
 } // namespace __llvm_libc
 
 #define EXPECT_TM_EQ(expected, actual)                                         \
   EXPECT_THAT((actual),                                                        \
               __llvm_libc::tmmatcher::testing::StructTmMatcher((expected)))
 
 #endif // LLVM_LIBC_TEST_SRC_TIME_TM_MATCHER_H

libc/utils/MPFRWrapper/MPFRUtils.h

bool compare_ternary_operation_one_output(Operation op,
                                           const TernaryInput<T> &input,
                                           T libc_output, double ulp_tolerance,
                                           RoundingMode rounding);
 
 template <typename T>
 void explain_unary_operation_single_output_error(Operation op, T input,
                                                  T match_value,
                                                  double ulp_tolerance,
-                                                 RoundingMode rounding,
-                                                 testutils::StreamWrapper &OS);
+                                                 RoundingMode rounding);
 template <typename T>
 void explain_unary_operation_two_outputs_error(
     Operation op, T input, const BinaryOutput<T> &match_value,
-    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS);
+    double ulp_tolerance, RoundingMode rounding);
 template <typename T>
 void explain_binary_operation_two_outputs_error(
     Operation op, const BinaryInput<T> &input,
     const BinaryOutput<T> &match_value, double ulp_tolerance,
-    RoundingMode rounding, testutils::StreamWrapper &OS);
+    RoundingMode rounding);
 
 template <typename T>
-void explain_binary_operation_one_output_error(
-    Operation op, const BinaryInput<T> &input, T match_value,
-    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS);
+void explain_binary_operation_one_output_error(Operation op,
+                                               const BinaryInput<T> &input,
+                                               T match_value,
+                                               double ulp_tolerance,
+                                               RoundingMode rounding);
 
 template <typename T>
-void explain_ternary_operation_one_output_error(
-    Operation op, const TernaryInput<T> &input, T match_value,
-    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS);
+void explain_ternary_operation_one_output_error(Operation op,
+                                                const TernaryInput<T> &input,
+                                                T match_value,
+                                                double ulp_tolerance,
+                                                RoundingMode rounding);
 
 template <Operation op, bool silent, typename InputType, typename OutputType>
 class MPFRMatcher : public testing::Matcher<OutputType> {
   InputType input;
   OutputType match_value;
   double ulp_tolerance;
   RoundingMode rounding;
 
 public:
   MPFRMatcher(InputType testInput, double ulp_tolerance, RoundingMode rounding)
       : input(testInput), ulp_tolerance(ulp_tolerance), rounding(rounding) {}
 
   bool match(OutputType libcResult) {
     match_value = libcResult;
     return match(input, match_value);
   }
 
   // This method is marked with NOLINT because it the name `explainError`
   // does not confirm to the coding style.
-  void explainError(testutils::StreamWrapper &OS) override { // NOLINT
-    explain_error(input, match_value, OS);
+  void explainError() override { // NOLINT
+    explain_error(input, match_value);
   }
 
   // Whether the `explainError` step is skipped or not.
   bool is_silent() const override { return silent; }
 
 private:
   template <typename T> bool match(T in, T out) {
     return compare_unary_operation_single_output(op, in, out, ulp_tolerance,
return compare_binary_operation_two_outputs(op, in, out, ulp_tolerance,
                                                 rounding);
   }
 
   template <typename T> bool match(const TernaryInput<T> &in, T out) {
     return compare_ternary_operation_one_output(op, in, out, ulp_tolerance,
                                                 rounding);
   }
 
-  template <typename T>
-  void explain_error(T in, T out, testutils::StreamWrapper &OS) {
+  template <typename T> void explain_error(T in, T out) {
     explain_unary_operation_single_output_error(op, in, out, ulp_tolerance,
-                                                rounding, OS);
+                                                rounding);
   }
 
-  template <typename T>
-  void explain_error(T in, const BinaryOutput<T> &out,
-                     testutils::StreamWrapper &OS) {
+  template <typename T> void explain_error(T in, const BinaryOutput<T> &out) {
     explain_unary_operation_two_outputs_error(op, in, out, ulp_tolerance,
-                                              rounding, OS);
+                                              rounding);
   }
 
   template <typename T>
-  void explain_error(const BinaryInput<T> &in, const BinaryOutput<T> &out,
-                     testutils::StreamWrapper &OS) {
+  void explain_error(const BinaryInput<T> &in, const BinaryOutput<T> &out) {
     explain_binary_operation_two_outputs_error(op, in, out, ulp_tolerance,
-                                               rounding, OS);
+                                               rounding);
   }
 
-  template <typename T>
-  void explain_error(const BinaryInput<T> &in, T out,
-                     testutils::StreamWrapper &OS) {
+  template <typename T> void explain_error(const BinaryInput<T> &in, T out) {
     explain_binary_operation_one_output_error(op, in, out, ulp_tolerance,
-                                              rounding, OS);
+                                              rounding);
   }
 
-  template <typename T>
-  void explain_error(const TernaryInput<T> &in, T out,
-                     testutils::StreamWrapper &OS) {
+  template <typename T> void explain_error(const TernaryInput<T> &in, T out) {
     explain_ternary_operation_one_output_error(op, in, out, ulp_tolerance,
-                                               rounding, OS);
+                                               rounding);
   }
 };
 
 } // namespace internal
 
 // Return true if the input and ouput types for the operation op are valid
 // types.
 template <Operation op, typename InputType, typename OutputType>

libc/utils/MPFRWrapper/MPFRUtils.cpp

 //===-- Utils which wrap MPFR ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "MPFRUtils.h"
 
+#include "src/__support/CPP/string.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PlatformDefs.h"
 #include "test/UnitTest/FPMatcher.h"
 
 #include <cmath>
 #include <fenv.h>
 #include <memory>
-#include <sstream>
 #include <stdint.h>
-#include <string>
 
 #ifdef CUSTOM_MPFR_INCLUDER
 // Some downstream repos are monoliths carrying MPFR sources in their third
 // party directory. In such repos, including the MPFR header as
 // `#include <mpfr.h>` is either disallowed or not possible. If that is the
 // case, a file named `CustomMPFRIncluder.h` should be added through which the
 // MPFR header can be included in manner allowed in that repo.
 #include "CustomMPFRIncluder.h"
public:
   }
 
   MPFRNumber fma(const MPFRNumber &b, const MPFRNumber &c) {
     MPFRNumber result(*this);
     mpfr_fma(result.value, value, b.value, c.value, mpfr_rounding);
     return result;
   }
 
-  std::string str() const {
+  cpp::string str() const {
     // 200 bytes should be more than sufficient to hold a 100-digit number
     // plus additional bytes for the decimal point, '-' sign etc.
     constexpr size_t printBufSize = 200;
     char buffer[printBufSize];
     mpfr_snprintf(buffer, printBufSize, "%100.50Rf", value);
     cpp::string_view view(buffer);
     // Trim whitespaces
     const char whitespace = ' ';
     while (!view.empty() && view.front() == whitespace)
       view.remove_prefix(1);
     while (!view.empty() && view.back() == whitespace)
       view.remove_suffix(1);
-    return std::string(view.data());
+    return cpp::string(view.data());
   }
 
   // These functions are useful for debugging.
   template <typename T> T as() const;
 
   void dump(const char *msg) const { mpfr_printf("%s%.128Rf\n", msg, value); }
 
   // Return the ULP (units-in-the-last-place) difference between the
public:
   //    of ULP value for testing.  Morever, most of the fractional parts of
   //    ULP value do not matter much, so using double as the return type
   //    should be good enough.
   // 3. For close enough values (values which don't diff in their exponent by
   //    not more than 1), a ULP difference of N indicates a bit distance
   //    of N between this number and [input].
   // 4. A values of +0.0 and -0.0 are treated as equal.
   template <typename T>
-  cpp::enable_if_t<cpp::is_floating_point_v<T>, double> ulp(T input) {
+  cpp::enable_if_t<cpp::is_floating_point_v<T>, MPFRNumber>
+  ulp_as_mpfr_number(T input) {
     T thisAsT = as<T>();
     if (thisAsT == input)
-      return T(0.0);
+      return MPFRNumber(0.0);
 
     if (is_nan()) {
       if (fputil::FPBits<T>(input).is_nan())
-        return T(0.0);
-      return T(fputil::FPBits<T>::inf());
+        return MPFRNumber(0.0);
+      return MPFRNumber(static_cast<T>(fputil::FPBits<T>::inf()));
     }
 
     int thisExponent = fputil::FPBits<T>(thisAsT).get_exponent();
     int inputExponent = fputil::FPBits<T>(input).get_exponent();
     // Adjust the exponents for denormal numbers.
     if (fputil::FPBits<T>(thisAsT).get_unbiased_exponent() == 0)
       ++thisExponent;
     if (fputil::FPBits<T>(input).get_unbiased_exponent() == 0)
       ++inputExponent;
 
     if (thisAsT * input < 0 || thisExponent == inputExponent) {
       MPFRNumber inputMPFR(input);
       mpfr_sub(inputMPFR.value, value, inputMPFR.value, MPFR_RNDN);
       mpfr_abs(inputMPFR.value, inputMPFR.value, MPFR_RNDN);
       mpfr_mul_2si(inputMPFR.value, inputMPFR.value,
                    -thisExponent + int(fputil::MantissaWidth<T>::VALUE),
                    MPFR_RNDN);
-      return inputMPFR.as<double>();
+      return inputMPFR;
     }
 
     // If the control reaches here, it means that this number and input are
     // of the same sign but different exponent. In such a case, ULP error is
     // calculated as sum of two parts.
     thisAsT = std::abs(thisAsT);
     input = std::abs(input);
     T min = thisAsT > input ? input : thisAsT;
mpfr_mul_2si(minMPFR.value, minMPFR.value,
                  MPFR_RNDN);
 
     mpfr_sub(maxMPFR.value, maxMPFR.value, pivot.value, MPFR_RNDN);
     mpfr_mul_2si(maxMPFR.value, maxMPFR.value,
                  -maxExponent + int(fputil::MantissaWidth<T>::VALUE),
                  MPFR_RNDN);
 
     mpfr_add(minMPFR.value, minMPFR.value, maxMPFR.value, MPFR_RNDN);
-    return minMPFR.as<double>();
+    return minMPFR;
+  }
+
+  template <typename T>
+  cpp::enable_if_t<cpp::is_floating_point_v<T>, cpp::string>
+  ulp_as_string(T input) {
+    MPFRNumber num = ulp_as_mpfr_number(input);
+    return num.str();
+  }
+
+  template <typename T>
+  cpp::enable_if_t<cpp::is_floating_point_v<T>, double> ulp(T input) {
+    MPFRNumber num = ulp_as_mpfr_number(input);
+    return num.as<double>();
   }
 };
 
 template <> float MPFRNumber::as<float>() const {
   return mpfr_get_flt(value, mpfr_rounding);
 }
 
 template <> double MPFRNumber::as<double>() const {

 // Remark: For all the explain_*_error functions, we will use std::stringstream
 // to build the complete error messages before sending it to the outstream `OS`
 // once at the end.  This will stop the error messages from interleaving when
 // the tests are running concurrently.
 template <typename T>
 void explain_unary_operation_single_output_error(Operation op, T input,
                                                  T matchValue,
                                                  double ulp_tolerance,
-                                                 RoundingMode rounding,
-                                                 testutils::StreamWrapper &OS) {
+                                                 RoundingMode rounding) {
   unsigned int precision = get_precision<T>(ulp_tolerance);
   MPFRNumber mpfrInput(input, precision);
   MPFRNumber mpfr_result;
   mpfr_result = unary_operation(op, input, precision, rounding);
   MPFRNumber mpfrMatchValue(matchValue);
-  std::stringstream ss;
-  ss << "Match value not within tolerance value of MPFR result:\n"
+  tlog << "Match value not within tolerance value of MPFR result:\n"
        << "  Input decimal: " << mpfrInput.str() << '\n';
-  __llvm_libc::fputil::testing::describeValue("     Input bits: ", input, ss);
-  ss << '\n' << "  Match decimal: " << mpfrMatchValue.str() << '\n';
-  __llvm_libc::fputil::testing::describeValue("     Match bits: ", matchValue,
-                                              ss);
-  ss << '\n' << "    MPFR result: " << mpfr_result.str() << '\n';
-  __llvm_libc::fputil::testing::describeValue(
-      "   MPFR rounded: ", mpfr_result.as<T>(), ss);
-  ss << '\n';
-  ss << "      ULP error: " << std::to_string(mpfr_result.ulp(matchValue))
-     << '\n';
-  OS << ss.str();
+  __llvm_libc::fputil::testing::describeValue("     Input bits: ", input);
+  tlog << '\n' << "  Match decimal: " << mpfrMatchValue.str() << '\n';
+  __llvm_libc::fputil::testing::describeValue("     Match bits: ", matchValue);
+  tlog << '\n' << "    MPFR result: " << mpfr_result.str() << '\n';
+  __llvm_libc::fputil::testing::describeValue("   MPFR rounded: ",
+                                              mpfr_result.as<T>());
+  tlog << '\n';
+  tlog << "      ULP error: "
+       << mpfr_result.ulp_as_mpfr_number(matchValue).str() << '\n';
 }
 
-template void
-explain_unary_operation_single_output_error<float>(Operation op, float, float,
-                                                   double, RoundingMode,
-                                                   testutils::StreamWrapper &);
+template void explain_unary_operation_single_output_error<float>(Operation op,
+                                                                 float, float,
+                                                                 double,
+                                                                 RoundingMode);
 template void explain_unary_operation_single_output_error<double>(
-    Operation op, double, double, double, RoundingMode,
-    testutils::StreamWrapper &);
+    Operation op, double, double, double, RoundingMode);
 template void explain_unary_operation_single_output_error<long double>(
-    Operation op, long double, long double, double, RoundingMode,
-    testutils::StreamWrapper &);
+    Operation op, long double, long double, double, RoundingMode);
 
 template <typename T>
 void explain_unary_operation_two_outputs_error(
     Operation op, T input, const BinaryOutput<T> &libc_result,
-    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS) {
+    double ulp_tolerance, RoundingMode rounding) {
   unsigned int precision = get_precision<T>(ulp_tolerance);
   MPFRNumber mpfrInput(input, precision);
   int mpfrIntResult;
   MPFRNumber mpfr_result = unary_operation_two_outputs(op, input, mpfrIntResult,
                                                        precision, rounding);
-  std::stringstream ss;
 
   if (mpfrIntResult != libc_result.i) {
-    ss << "MPFR integral result: " << mpfrIntResult << '\n'
+    tlog << "MPFR integral result: " << mpfrIntResult << '\n'
          << "Libc integral result: " << libc_result.i << '\n';
   } else {
-    ss << "Integral result from libc matches integral result from MPFR.\n";
+    tlog << "Integral result from libc matches integral result from MPFR.\n";
   }
 
   MPFRNumber mpfrMatchValue(libc_result.f);
-  ss << "Libc floating point result is not within tolerance value of the MPFR "
+  tlog
+      << "Libc floating point result is not within tolerance value of the MPFR "
       << "result.\n\n";
 
-  ss << "            Input decimal: " << mpfrInput.str() << "\n\n";
+  tlog << "            Input decimal: " << mpfrInput.str() << "\n\n";
 
-  ss << "Libc floating point value: " << mpfrMatchValue.str() << '\n';
-  __llvm_libc::fputil::testing::describeValue(
-      " Libc floating point bits: ", libc_result.f, ss);
-  ss << "\n\n";
-
-  ss << "              MPFR result: " << mpfr_result.str() << '\n';
-  __llvm_libc::fputil::testing::describeValue(
-      "             MPFR rounded: ", mpfr_result.as<T>(), ss);
-  ss << '\n'
+  tlog << "Libc floating point value: " << mpfrMatchValue.str() << '\n';
+  __llvm_libc::fputil::testing::describeValue(" Libc floating point bits: ",
+                                              libc_result.f);
+  tlog << "\n\n";
+
+  tlog << "              MPFR result: " << mpfr_result.str() << '\n';
+  __llvm_libc::fputil::testing::describeValue("             MPFR rounded: ",
+                                              mpfr_result.as<T>());
+  tlog << '\n'
        << "                ULP error: "
-     << std::to_string(mpfr_result.ulp(libc_result.f)) << '\n';
-  OS << ss.str();
+       << mpfr_result.ulp_as_mpfr_number(libc_result.f).str() << '\n';
 }
 
 template void explain_unary_operation_two_outputs_error<float>(
-    Operation, float, const BinaryOutput<float> &, double, RoundingMode,
-    testutils::StreamWrapper &);
+    Operation, float, const BinaryOutput<float> &, double, RoundingMode);
 template void explain_unary_operation_two_outputs_error<double>(
-    Operation, double, const BinaryOutput<double> &, double, RoundingMode,
-    testutils::StreamWrapper &);
+    Operation, double, const BinaryOutput<double> &, double, RoundingMode);
 template void explain_unary_operation_two_outputs_error<long double>(
     Operation, long double, const BinaryOutput<long double> &, double,
-    RoundingMode, testutils::StreamWrapper &);
+    RoundingMode);
 
 template <typename T>
 void explain_binary_operation_two_outputs_error(
     Operation op, const BinaryInput<T> &input,
     const BinaryOutput<T> &libc_result, double ulp_tolerance,
-    RoundingMode rounding, testutils::StreamWrapper &OS) {
+    RoundingMode rounding) {
   unsigned int precision = get_precision<T>(ulp_tolerance);
   MPFRNumber mpfrX(input.x, precision);
   MPFRNumber mpfrY(input.y, precision);
   int mpfrIntResult;
   MPFRNumber mpfr_result = binary_operation_two_outputs(
       op, input.x, input.y, mpfrIntResult, precision, rounding);
   MPFRNumber mpfrMatchValue(libc_result.f);
-  std::stringstream ss;
 
-  ss << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n'
+  tlog << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n'
        << "MPFR integral result: " << mpfrIntResult << '\n'
        << "Libc integral result: " << libc_result.i << '\n'
        << "Libc floating point result: " << mpfrMatchValue.str() << '\n'
        << "               MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
-      "Libc floating point result bits: ", libc_result.f, ss);
+      "Libc floating point result bits: ", libc_result.f);
   __llvm_libc::fputil::testing::describeValue(
-      "              MPFR rounded bits: ", mpfr_result.as<T>(), ss);
-  ss << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result.f)) << '\n';
-  OS << ss.str();
+      "              MPFR rounded bits: ", mpfr_result.as<T>());
+  tlog << "ULP error: " << mpfr_result.ulp_as_mpfr_number(libc_result.f).str()
+       << '\n';
 }
 
 template void explain_binary_operation_two_outputs_error<float>(
     Operation, const BinaryInput<float> &, const BinaryOutput<float> &, double,
-    RoundingMode, testutils::StreamWrapper &);
+    RoundingMode);
 template void explain_binary_operation_two_outputs_error<double>(
     Operation, const BinaryInput<double> &, const BinaryOutput<double> &,
-    double, RoundingMode, testutils::StreamWrapper &);
+    double, RoundingMode);
 template void explain_binary_operation_two_outputs_error<long double>(
     Operation, const BinaryInput<long double> &,
-    const BinaryOutput<long double> &, double, RoundingMode,
-    testutils::StreamWrapper &);
+    const BinaryOutput<long double> &, double, RoundingMode);
 
 template <typename T>
-void explain_binary_operation_one_output_error(
-    Operation op, const BinaryInput<T> &input, T libc_result,
-    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS) {
+void explain_binary_operation_one_output_error(Operation op,
+                                               const BinaryInput<T> &input,
+                                               T libc_result,
+                                               double ulp_tolerance,
+                                               RoundingMode rounding) {
   unsigned int precision = get_precision<T>(ulp_tolerance);
   MPFRNumber mpfrX(input.x, precision);
   MPFRNumber mpfrY(input.y, precision);
   FPBits<T> xbits(input.x);
   FPBits<T> ybits(input.y);
   MPFRNumber mpfr_result =
       binary_operation_one_output(op, input.x, input.y, precision, rounding);
   MPFRNumber mpfrMatchValue(libc_result);
-  std::stringstream ss;
 
-  ss << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n';
-  __llvm_libc::fputil::testing::describeValue("First input bits: ", input.x,
-                                              ss);
-  __llvm_libc::fputil::testing::describeValue("Second input bits: ", input.y,
-                                              ss);
+  tlog << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n';
+  __llvm_libc::fputil::testing::describeValue("First input bits: ", input.x);
+  __llvm_libc::fputil::testing::describeValue("Second input bits: ", input.y);
 
-  ss << "Libc result: " << mpfrMatchValue.str() << '\n'
+  tlog << "Libc result: " << mpfrMatchValue.str() << '\n'
        << "MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
-      "Libc floating point result bits: ", libc_result, ss);
+      "Libc floating point result bits: ", libc_result);
   __llvm_libc::fputil::testing::describeValue(
-      "              MPFR rounded bits: ", mpfr_result.as<T>(), ss);
-  ss << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result)) << '\n';
-  OS << ss.str();
+      "              MPFR rounded bits: ", mpfr_result.as<T>());
+  tlog << "ULP error: " << mpfr_result.ulp_as_mpfr_number(libc_result).str()
+       << '\n';
 }
 
 template void explain_binary_operation_one_output_error<float>(
-    Operation, const BinaryInput<float> &, float, double, RoundingMode,
-    testutils::StreamWrapper &);
+    Operation, const BinaryInput<float> &, float, double, RoundingMode);
 template void explain_binary_operation_one_output_error<double>(
-    Operation, const BinaryInput<double> &, double, double, RoundingMode,
-    testutils::StreamWrapper &);
+    Operation, const BinaryInput<double> &, double, double, RoundingMode);
 template void explain_binary_operation_one_output_error<long double>(
     Operation, const BinaryInput<long double> &, long double, double,
-    RoundingMode, testutils::StreamWrapper &);
+    RoundingMode);
 
 template <typename T>
-void explain_ternary_operation_one_output_error(
-    Operation op, const TernaryInput<T> &input, T libc_result,
-    double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS) {
+void explain_ternary_operation_one_output_error(Operation op,
+                                                const TernaryInput<T> &input,
+                                                T libc_result,
+                                                double ulp_tolerance,
+                                                RoundingMode rounding) {
   unsigned int precision = get_precision<T>(ulp_tolerance);
   MPFRNumber mpfrX(input.x, precision);
   MPFRNumber mpfrY(input.y, precision);
   MPFRNumber mpfrZ(input.z, precision);
   FPBits<T> xbits(input.x);
   FPBits<T> ybits(input.y);
   FPBits<T> zbits(input.z);
   MPFRNumber mpfr_result = ternary_operation_one_output(
       op, input.x, input.y, input.z, precision, rounding);
   MPFRNumber mpfrMatchValue(libc_result);
-  std::stringstream ss;
 
-  ss << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str()
+  tlog << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str()
        << " z: " << mpfrZ.str() << '\n';
-  __llvm_libc::fputil::testing::describeValue("First input bits: ", input.x,
-                                              ss);
-  __llvm_libc::fputil::testing::describeValue("Second input bits: ", input.y,
-                                              ss);
-  __llvm_libc::fputil::testing::describeValue("Third input bits: ", input.z,
-                                              ss);
+  __llvm_libc::fputil::testing::describeValue("First input bits: ", input.x);
+  __llvm_libc::fputil::testing::describeValue("Second input bits: ", input.y);
+  __llvm_libc::fputil::testing::describeValue("Third input bits: ", input.z);
 
-  ss << "Libc result: " << mpfrMatchValue.str() << '\n'
+  tlog << "Libc result: " << mpfrMatchValue.str() << '\n'
        << "MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
-      "Libc floating point result bits: ", libc_result, ss);
+      "Libc floating point result bits: ", libc_result);
   __llvm_libc::fputil::testing::describeValue(
-      "              MPFR rounded bits: ", mpfr_result.as<T>(), ss);
-  ss << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result)) << '\n';
-  OS << ss.str();
+      "              MPFR rounded bits: ", mpfr_result.as<T>());
+  tlog << "ULP error: " << mpfr_result.ulp_as_mpfr_number(libc_result).str()
+       << '\n';
 }
 
 template void explain_ternary_operation_one_output_error<float>(
-    Operation, const TernaryInput<float> &, float, double, RoundingMode,
-    testutils::StreamWrapper &);
+    Operation, const TernaryInput<float> &, float, double, RoundingMode);
 template void explain_ternary_operation_one_output_error<double>(
-    Operation, const TernaryInput<double> &, double, double, RoundingMode,
-    testutils::StreamWrapper &);
+    Operation, const TernaryInput<double> &, double, double, RoundingMode);
 template void explain_ternary_operation_one_output_error<long double>(
     Operation, const TernaryInput<long double> &, long double, double,
-    RoundingMode, testutils::StreamWrapper &);
+    RoundingMode);
 
 template <typename T>
 bool compare_unary_operation_single_output(Operation op, T input, T libc_result,
                                            double ulp_tolerance,
                                            RoundingMode rounding) {
   unsigned int precision = get_precision<T>(ulp_tolerance);
   MPFRNumber mpfr_result;
   mpfr_result = unary_operation(op, input, precision, rounding);

libc/utils/testutils/CMakeLists.txt

 if(CMAKE_HOST_UNIX)
   set(EFFile ExecuteFunctionUnix.cpp)
   set(FDReaderFile FDReaderUnix.cpp)
 endif()
 
 add_library(
   libc_test_utils
-  StreamWrapper.cpp
-  StreamWrapper.h
   ${EFFile}
   ExecuteFunction.h
   ${FDReaderFile}
   FDReader.h
   RoundingModeUtils.cpp
 )

libc/utils/testutils/StreamWrapper.h

-//===-- StreamWrapper.h -----------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_LIBC_UTILS_TESTUTILS_STREAMWRAPPER_H
-#define LLVM_LIBC_UTILS_TESTUTILS_STREAMWRAPPER_H
-
-namespace __llvm_libc {
-namespace testutils {
-
-// StreamWrapper is necessary because llvm/Support/raw_ostream.h includes
-// standard headers so we must provide streams through indirection to not
-// expose the system libc headers.
-class StreamWrapper {
-protected:
-  void *os;
-
-public:
-  StreamWrapper(void *OS) : os(OS) {}
-
-  template <typename T> StreamWrapper &operator<<(T t);
-};
-
-StreamWrapper outs();
-
-class OutputFileStream : public StreamWrapper {
-public:
-  explicit OutputFileStream(const char *FN);
-  ~OutputFileStream();
-};
-
-} // namespace testutils
-} // namespace __llvm_libc
-
-#endif // LLVM_LIBC_UTILS_TESTUTILS_STREAMWRAPPER_H

libc/utils/testutils/StreamWrapper.cpp

-//===-- StreamWrapper.cpp -------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "StreamWrapper.h"
-#include <cassert>
-#include <fstream>
-#include <iostream>
-#include <memory>
-#include <string>
-
-namespace __llvm_libc {
-namespace testutils {
-
-StreamWrapper outs() { return {std::addressof(std::cout)}; }
-
-template <typename T> StreamWrapper &StreamWrapper::operator<<(T t) {
-  assert(os);
-  std::ostream &Stream = *reinterpret_cast<std::ostream *>(os);
-  Stream << t;
-  Stream.flush();
-  return *this;
-}
-
-template StreamWrapper &StreamWrapper::operator<<<void *>(void *t);
-template StreamWrapper &StreamWrapper::operator<<<const char *>(const char *t);
-template StreamWrapper &StreamWrapper::operator<<<char *>(char *t);
-template StreamWrapper &StreamWrapper::operator<<<char>(char t);
-template StreamWrapper &StreamWrapper::operator<<<short>(short t);
-template StreamWrapper &StreamWrapper::operator<<<int>(int t);
-template StreamWrapper &StreamWrapper::operator<<<long>(long t);
-template StreamWrapper &StreamWrapper::operator<<<long long>(long long t);
-template StreamWrapper &
-    StreamWrapper::operator<<<unsigned char>(unsigned char t);
-template StreamWrapper &
-    StreamWrapper::operator<<<unsigned short>(unsigned short t);
-template StreamWrapper &StreamWrapper::operator<<<unsigned int>(unsigned int t);
-template StreamWrapper &
-    StreamWrapper::operator<<<unsigned long>(unsigned long t);
-template StreamWrapper &
-    StreamWrapper::operator<<<unsigned long long>(unsigned long long t);
-template StreamWrapper &StreamWrapper::operator<<<bool>(bool t);
-template StreamWrapper &StreamWrapper::operator<<<std::string>(std::string t);
-template StreamWrapper &StreamWrapper::operator<<<float>(float t);
-template StreamWrapper &StreamWrapper::operator<<<double>(double t);
-
-OutputFileStream::OutputFileStream(const char *FN)
-    : StreamWrapper(new std::ofstream(FN)) {}
-
-OutputFileStream::~OutputFileStream() {
-  delete reinterpret_cast<std::ofstream *>(os);
-}
-
-} // namespace testutils
-} // namespace __llvm_libc

utils/bazel/llvm-project-overlay/libc/test/UnitTest/BUILD.bazel

deps = [
         "//llvm:Support",
     ],
 )
 
 cc_library(
     name = "fp_test_helpers",
     srcs = [
         "FPExceptMatcher.cpp",
-        "FPMatcher.cpp",
     ],
     hdrs = [
         "FPExceptMatcher.h",
         "FPMatcher.h",
     ],
     deps = [
         ":LibcUnitTest",
         ":string_utils",

utils/bazel/llvm-project-overlay/libc/utils/testutils/BUILD.bazel

 # This file is licensed under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 package(default_visibility = ["//visibility:public"])
 
 licenses(["notice"])
 
 cc_library(
     name = "libc_test_utils",
     srcs = [
         "ExecuteFunctionUnix.cpp",
         "FDReaderUnix.cpp",
         "RoundingModeUtils.cpp",
-        "StreamWrapper.cpp",
     ],
     hdrs = [
         "ExecuteFunction.h",
         "FDReader.h",
         "RoundingModeUtils.h",
-        "StreamWrapper.h",
     ],
     deps = [
         "//libc:libc_root",
         "//llvm:Support",
     ],
 )