[libc] Enable custom logging in LibcTest

[gchatelet]

Summary

This patch mimics the behavior of Google Test and allow users to log custom messages after all flavors of ASSERT_ / EXPECT_.

[gchatelet]

• Simplify implementation and add documentation

[lntue]

libc/test/UnitTest/LibcTest.h

53

Do you know why the Matcher's interface cannot be const T&? Ideally it should not modify the inputs, right?

[gchatelet]

• match should take a 'const T&' instead of a 'T&'

libc/test/UnitTest/LibcTest.h

53

I traced it down to https://reviews.llvm.org/D75487
I don't see a rationale for this choice so I assume it was just overlooked.

I refrained from fixing it in this patch to prevent noise but since you're mentioning it, here it is.

[sivachandra]

LGTM with one question.

libc/test/UnitTest/TestLogger.cpp

69

Why should we use [u]int<..>_t types? Could it lead to duplicate declaration errors, for example if int64_t == long long?

[gchatelet]

• rebase
• Simplify implementation and add documentation
• match should take a 'const T&' instead of a 'T&'
• Use standard C types for TesLogger specializaions

libc/test/UnitTest/TestLogger.cpp

69

You're right, thx for catching it. I've used the standard C types.

[gchatelet]

Build bots were failing because of a few other bool r = EXPECT_FP_EQ(... and bool r = EXPECT_MPFR_MATCH_ROUNDING(... that I didn't catch.
They were only built when LLVM_LIBC_FULL_BUILD was not defined.

[gchatelet]

• Fix remaining math tests

[gchatelet]

@lntue can you have another look?
Changed lines from last time you gave me LGTM : https://reviews.llvm.org/D152630?vs=531248&id=531265#toc

We should probably submit these math related changes as a separate patch BTW

libc/test/UnitTest/LibcTest.h

 
 // Only the following conditions are supported. Notice that we do not have
 // a TRUE or FALSE condition. That is because, C library functions do not
 // return boolean values, but use integral return values to indicate true or
 // false conditions. Hence, it is more appropriate to use the other comparison
 // conditions for such cases.
 enum class TestCond { EQ, NE, LT, LE, GT, GE };
 
+struct MatcherBase {
+  virtual ~MatcherBase() {}
+  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(const T &t);
+};
+
 namespace internal {
 
+// A simple location object to allow consistent passing of __FILE__ and
+// __LINE__.
 struct Location {
   Location(const char *file, int line) : file(file), line(line) {}
   const char *file;
   int line;
 };
 
+// Supports writing a failing Location to tlog.
 TestLogger &operator<<(TestLogger &logger, Location Loc);
 
-#define LOC() __llvm_libc::testing::internal::Location(__FILE__, __LINE__)
+#define LIBC_TEST_LOC_()                                                       \
+  __llvm_libc::testing::internal::Location(__FILE__, __LINE__)
+
+// Object to forward custom logging after the EXPECT / ASSERT macros.
+struct Message {
+  template <typename T> Message &operator<<(T value) {
+    tlog << value;
+    return *this;
+  }
+};
+
+// A trivial object to catch the Message, this enables custom logging and
+// returning from the test function, see LIBC_TEST_SCAFFOLDING_ below.
+struct Failure {
+  void operator=(Message msg) {}
+};
 
 struct RunContext {
   enum class RunResult : bool { Pass, Fail };
 
   RunResult status() const { return Status; }
 
   void markFail() { Status = RunResult::Fail; }
 
 private:
   RunResult Status = RunResult::Pass;
 };
 
 template <typename ValType>
 bool test(RunContext *Ctx, TestCond Cond, ValType LHS, ValType RHS,
           const char *LHSStr, const char *RHSStr, Location Loc);
 
 } // namespace internal
 
-struct MatcherBase {
-  virtual ~MatcherBase() {}
-  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);
-};
-
 // NOTE: One should not create instances and call methods on them directly. One
 // should use the macros TEST or TEST_F to write test cases.
 class Test {
   Test *Next = nullptr;
   internal::RunContext *Ctx = nullptr;
 
   void setContext(internal::RunContext *C) { Ctx = C; }
 
bool testStrEq(const char *LHS, const char *RHS, const char *LHSStr,
                  const char *RHSStr, internal::Location Loc);
 
   bool testStrNe(const char *LHS, const char *RHS, const char *LHSStr,
                  const char *RHSStr, internal::Location Loc);
 
   bool testMatch(bool MatchResult, MatcherBase &Matcher, const char *LHSStr,
                  const char *RHSStr, internal::Location Loc);
 
+  template <typename MatcherT, typename ValType>
+  bool matchAndExplain(MatcherT &&Matcher, ValType Value,
+                       const char *MatcherStr, const char *ValueStr,
+                       internal::Location Loc) {
+    return testMatch(Matcher.match(Value), Matcher, ValueStr, MatcherStr, Loc);
+  }
+
   bool testProcessExits(testutils::FunctionCaller *Func, int ExitCode,
                         const char *LHSStr, const char *RHSStr,
                         internal::Location Loc);
 
   bool testProcessKilled(testutils::FunctionCaller *Func, int Signal,
                          const char *LHSStr, const char *RHSStr,
                          internal::Location Loc);
 
#define TEST_F(SuiteClass, TestName)                                           \
   public:                                                                      \
     SuiteClass##_##TestName() { addTest(this); }                               \
     void Run() override;                                                       \
     const char *getName() const override { return #SuiteClass "." #TestName; } \
   };                                                                           \
   SuiteClass##_##TestName SuiteClass##_##TestName##_Instance;                  \
   void SuiteClass##_##TestName::Run()
 
-#define EXPECT_EQ(LHS, RHS)                                                    \
-  this->test(__llvm_libc::testing::TestCond::EQ, (LHS), (RHS), #LHS, #RHS,     \
-             LOC())
-#define ASSERT_EQ(LHS, RHS)                                                    \
-  if (!EXPECT_EQ(LHS, RHS))                                                    \
-  return
-
-#define EXPECT_NE(LHS, RHS)                                                    \
-  this->test(__llvm_libc::testing::TestCond::NE, (LHS), (RHS), #LHS, #RHS,     \
-             LOC())
-#define ASSERT_NE(LHS, RHS)                                                    \
-  if (!EXPECT_NE(LHS, RHS))                                                    \
-  return
-
-#define EXPECT_LT(LHS, RHS)                                                    \
-  this->test(__llvm_libc::testing::TestCond::LT, (LHS), (RHS), #LHS, #RHS,     \
-             LOC())
-#define ASSERT_LT(LHS, RHS)                                                    \
-  if (!EXPECT_LT(LHS, RHS))                                                    \
-  return
-
-#define EXPECT_LE(LHS, RHS)                                                    \
-  this->test(__llvm_libc::testing::TestCond::LE, (LHS), (RHS), #LHS, #RHS,     \
-             LOC())
-#define ASSERT_LE(LHS, RHS)                                                    \
-  if (!EXPECT_LE(LHS, RHS))                                                    \
-  return
-
-#define EXPECT_GT(LHS, RHS)                                                    \
-  this->test(__llvm_libc::testing::TestCond::GT, (LHS), (RHS), #LHS, #RHS,     \
-             LOC())
-#define ASSERT_GT(LHS, RHS)                                                    \
-  if (!EXPECT_GT(LHS, RHS))                                                    \
-  return
-
-#define EXPECT_GE(LHS, RHS)                                                    \
-  this->test(__llvm_libc::testing::TestCond::GE, (LHS), (RHS), #LHS, #RHS,     \
-             LOC())
-#define ASSERT_GE(LHS, RHS)                                                    \
-  if (!EXPECT_GE(LHS, RHS))                                                    \
-  return
-
-#define EXPECT_STREQ(LHS, RHS) this->testStrEq((LHS), (RHS), #LHS, #RHS, LOC())
-#define ASSERT_STREQ(LHS, RHS)                                                 \
-  if (!EXPECT_STREQ(LHS, RHS))                                                 \
-  return
-
-#define EXPECT_STRNE(LHS, RHS) this->testStrNe((LHS), (RHS), #LHS, #RHS, LOC())
-#define ASSERT_STRNE(LHS, RHS)                                                 \
-  if (!EXPECT_STRNE(LHS, RHS))                                                 \
-  return
-
-#define EXPECT_TRUE(VAL) EXPECT_EQ((VAL), true)
-
-#define ASSERT_TRUE(VAL)                                                       \
-  if (!EXPECT_TRUE(VAL))                                                       \
-  return
-
-#define EXPECT_FALSE(VAL) EXPECT_EQ((VAL), false)
-
-#define ASSERT_FALSE(VAL)                                                      \
-  if (!EXPECT_FALSE(VAL))                                                      \
-  return
+// The GNU compiler emits a warning if nested "if" statements are followed by
+// an "else" statement and braces are not used to explicitly disambiguate the
+// "else" binding.  This leads to problems with code like:
+//
+//   if (gate)
+//     ASSERT_*(condition) << "Some message";
+//
+// The "switch (0) case 0:" idiom is used to suppress this.
+#define LIBC_AMBIGUOUS_ELSE_BLOCKER_                                           \
+  switch (0)                                                                   \
+  case 0:                                                                      \
+  default:
+
+// If RET_OR_EMPTY is the 'return' keyword we perform an early return which
+// corresponds to an assert. If it is empty the execution continues, this
+// corresponds to an expect.
+//
+// The 'else' clause must not be enclosed into braces so that the << operator
+// can be used to fill the Message.
+//
+// TEST is usually implemented as a function performing checking logic and
+// returning a boolean. This expression is responsible for logging the
+// diagnostic in case of failure.
+#define LIBC_TEST_SCAFFOLDING_(TEST, RET_OR_EMPTY)                             \
+  LIBC_AMBIGUOUS_ELSE_BLOCKER_                                                 \
+  if (TEST)                                                                    \
+    ;                                                                          \
+  else                                                                         \
+    RET_OR_EMPTY __llvm_libc::testing::internal::Failure() =                   \
+        __llvm_libc::testing::internal::Message()
+
+#define LIBC_TEST_BINOP_(COND, LHS, RHS, RET_OR_EMPTY)                         \
+  LIBC_TEST_SCAFFOLDING_(test(__llvm_libc::testing::TestCond::COND, LHS, RHS,  \
+                              #LHS, #RHS, LIBC_TEST_LOC_()),                   \
+                         RET_OR_EMPTY)
+
+////////////////////////////////////////////////////////////////////////////////
+// Binary operations corresponding to the TestCond enum.
+
+#define EXPECT_EQ(LHS, RHS) LIBC_TEST_BINOP_(EQ, LHS, RHS, )
+#define ASSERT_EQ(LHS, RHS) LIBC_TEST_BINOP_(EQ, LHS, RHS, return)
+
+#define EXPECT_NE(LHS, RHS) LIBC_TEST_BINOP_(NE, LHS, RHS, )
+#define ASSERT_NE(LHS, RHS) LIBC_TEST_BINOP_(NE, LHS, RHS, return)
+
+#define EXPECT_LT(LHS, RHS) LIBC_TEST_BINOP_(LT, LHS, RHS, )
+#define ASSERT_LT(LHS, RHS) LIBC_TEST_BINOP_(LT, LHS, RHS, return)
+
+#define EXPECT_LE(LHS, RHS) LIBC_TEST_BINOP_(LE, LHS, RHS, )
+#define ASSERT_LE(LHS, RHS) LIBC_TEST_BINOP_(LE, LHS, RHS, return)
+
+#define EXPECT_GT(LHS, RHS) LIBC_TEST_BINOP_(GT, LHS, RHS, )
+#define ASSERT_GT(LHS, RHS) LIBC_TEST_BINOP_(GT, LHS, RHS, return)
+
+#define EXPECT_GE(LHS, RHS) LIBC_TEST_BINOP_(GE, LHS, RHS, )
+#define ASSERT_GE(LHS, RHS) LIBC_TEST_BINOP_(GE, LHS, RHS, return)
+
+////////////////////////////////////////////////////////////////////////////////
+// Boolean checks are handled as comparison to the true / false values.
+
+#define EXPECT_TRUE(VAL) EXPECT_EQ(VAL, true)
+#define ASSERT_TRUE(VAL) ASSERT_EQ(VAL, true)
+
+#define EXPECT_FALSE(VAL) EXPECT_EQ(VAL, false)
+#define ASSERT_FALSE(VAL) ASSERT_EQ(VAL, false)
+
+////////////////////////////////////////////////////////////////////////////////
+// String checks.
+
+#define LIBC_TEST_STR_(TEST_FUNC, LHS, RHS, RET_OR_EMPTY)                      \
+  LIBC_TEST_SCAFFOLDING_(TEST_FUNC(LHS, RHS, #LHS, #RHS, LIBC_TEST_LOC_()),    \
+                         RET_OR_EMPTY)
+
+#define EXPECT_STREQ(LHS, RHS) LIBC_TEST_STR_(testStrEq, LHS, RHS, )
+#define ASSERT_STREQ(LHS, RHS) LIBC_TEST_STR_(testStrEq, LHS, RHS, return)
+
+#define EXPECT_STRNE(LHS, RHS) LIBC_TEST_STR_(testStrNe, LHS, RHS, )
+#define ASSERT_STRNE(LHS, RHS) LIBC_TEST_STR_(testStrNe, LHS, RHS, return)
+
+////////////////////////////////////////////////////////////////////////////////
+// Subprocess checks.
 
 #ifdef ENABLE_SUBPROCESS_TESTS
 
-#define EXPECT_EXITS(FUNC, EXIT)                                               \
-  this->testProcessExits(__llvm_libc::testing::Test::createCallable(FUNC),     \
-                         EXIT, #FUNC, #EXIT, LOC())
+#define LIBC_TEST_PROCESS_(TEST_FUNC, FUNC, VALUE, RET_OR_EMPTY)               \
+  LIBC_TEST_SCAFFOLDING_(                                                      \
+      TEST_FUNC(__llvm_libc::testing::Test::createCallable(FUNC), VALUE,       \
+                #FUNC, #VALUE, LIBC_TEST_LOC_()),                              \
+      RET_OR_EMPTY)
 
+#define EXPECT_EXITS(FUNC, EXIT)                                               \
+  LIBC_TEST_PROCESS_(testProcessExits, FUNC, EXIT, )
 #define ASSERT_EXITS(FUNC, EXIT)                                               \
-  if (!EXPECT_EXITS(FUNC, EXIT))                                               \
-  return
+  LIBC_TEST_PROCESS_(testProcessExits, FUNC, EXIT, return)
 
 #define EXPECT_DEATH(FUNC, SIG)                                                \
-  this->testProcessKilled(__llvm_libc::testing::Test::createCallable(FUNC),    \
-                          SIG, #FUNC, #SIG, LOC())
-
-#define ASSERT_DEATH(FUNC, EXIT)                                               \
-  if (!EXPECT_DEATH(FUNC, EXIT))                                               \
-  return
+  LIBC_TEST_PROCESS_(testProcessKilled, FUNC, SIG, )
+#define ASSERT_DEATH(FUNC, SIG)                                                \
+  LIBC_TEST_PROCESS_(testProcessKilled, FUNC, SIG, return)
 
 #endif // ENABLE_SUBPROCESS_TESTS
 
-#define __CAT1(a, b) a##b
-#define __CAT(a, b) __CAT1(a, b)
-#define UNIQUE_VAR(prefix) __CAT(prefix, __LINE__)
+////////////////////////////////////////////////////////////////////////////////
+// Custom matcher checks.
 
-#define EXPECT_THAT(MATCH, MATCHER)                                            \
-  [&]() -> bool {                                                              \
-    auto UNIQUE_VAR(__matcher) = (MATCHER);                                    \
-    return this->testMatch(UNIQUE_VAR(__matcher).match((MATCH)),               \
-                           UNIQUE_VAR(__matcher), #MATCH, #MATCHER, LOC());    \
-  }()
+#define LIBC_TEST_MATCH_(MATCHER, MATCH, MATCHER_STR, MATCH_STR, RET_OR_EMPTY) \
+  LIBC_TEST_SCAFFOLDING_(matchAndExplain(MATCHER, MATCH, MATCHER_STR,          \
+                                         MATCH_STR, LIBC_TEST_LOC_()),         \
+                         RET_OR_EMPTY)
 
+#define EXPECT_THAT(MATCH, MATCHER)                                            \
+  LIBC_TEST_MATCH_(MATCHER, MATCH, #MATCHER, #MATCH, )
 #define ASSERT_THAT(MATCH, MATCHER)                                            \
-  do {                                                                         \
-    if (!EXPECT_THAT(MATCH, MATCHER))                                          \
-      return;                                                                  \
-  } while (0)
+  LIBC_TEST_MATCH_(MATCHER, MATCH, #MATCHER, #MATCH, return)
 
 #define WITH_SIGNAL(X) X
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_LIBCTEST_H

libc/test/UnitTest/LibcTest.cpp

 namespace testing {
 
 namespace internal {
 
 TestLogger &operator<<(TestLogger &logger, Location Loc) {
   return logger << Loc.file << ":" << Loc.line << ": FAILURE\n";
 }
 
-// When the value is UInt128, __uint128_t or wider, show its hexadecimal digits.
+// When the value is UInt128, __uint128_t or wider, show its hexadecimal
+// digits.
 template <typename T>
 cpp::enable_if_t<cpp::is_integral_v<T> && cpp::is_unsigned_v<T> &&
                      (sizeof(T) > sizeof(uint64_t)),
                  cpp::string>
 describeValue(T Value) {
   static_assert(sizeof(T) % 8 == 0, "Unsupported size of UInt");
   char buf[IntegerToString::hex_bufsize<T>()];
   IntegerToString::hex(Value, buf, false);

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/UInt128.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace testing {
 
 // cpp::string_view specialization
 template <>
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);
 }
 
+// bool specialization
+template <> TestLogger &TestLogger::operator<<(bool cond) {
+  return *this << (cond ? "true" : "false");
+}
+
 // 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) {
+  if constexpr (cpp::is_integral_v<T> && cpp::is_unsigned_v<T> &&
+                sizeof(T) > sizeof(uint64_t)) {
+    static_assert(sizeof(T) % 8 == 0, "Unsupported size of UInt");
+    char buf[IntegerToString::hex_bufsize<T>()];
+    IntegerToString::hex(t, buf, false);
+    return *this << "0x" << cpp::string_view(buf, sizeof(buf));
+  } else {
     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);
-template TestLogger &TestLogger::operator<< <unsigned long>(unsigned long);
+template TestLogger &TestLogger::operator<< <uint8_t>(uint8_t);
+template TestLogger &TestLogger::operator<< <uint16_t>(uint16_t);
+template TestLogger &TestLogger::operator<< <uint32_t>(uint32_t);
+template TestLogger &TestLogger::operator<< <uint64_t>(uint64_t);
+template TestLogger &TestLogger::operator<< <int8_t>(int8_t);
+template TestLogger &TestLogger::operator<< <int16_t>(int16_t);
+template TestLogger &TestLogger::operator<< <int32_t>(int32_t);
+template TestLogger &TestLogger::operator<< <int64_t>(int64_t);
 template TestLogger &TestLogger::operator<< <long long>(long long);
 template TestLogger &
 TestLogger::operator<< <unsigned long long>(unsigned long long);
 
+#ifdef __SIZEOF_INT128__
+template TestLogger &TestLogger::operator<< <__uint128_t>(__uint128_t);
+#endif
+template TestLogger &TestLogger::operator<< <cpp::UInt<128>>(cpp::UInt<128>);
+template TestLogger &TestLogger::operator<< <cpp::UInt<192>>(cpp::UInt<192>);
+template TestLogger &TestLogger::operator<< <cpp::UInt<256>>(cpp::UInt<256>);
+template TestLogger &TestLogger::operator<< <cpp::UInt<320>>(cpp::UInt<320>);
+
 // TODO: Add floating point formatting once it's supported by StringStream.
 
 TestLogger tlog;
 
 } // namespace testing
 } // namespace __llvm_libc

libc/test/src/math/log10_test.cpp

for (uint64_t i = 0, v = START; i <= COUNT; ++i, v += STEP) {
       libc_errno = 0;
       double result = __llvm_libc::log10(x);
       ++cc;
       if (isnan(result) || isinf(result))
         continue;
 
       ++count;
       // ASSERT_MPFR_MATCH(mpfr::Operation::Log10, x, result, 0.5);
-      if (!EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log10, x,
-                                               result, 0.5, rounding_mode)) {
+      if (!TEST_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log10, x, result,
+                                             0.5, rounding_mode)) {
         ++fails;
-        while (!EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(
-            mpfr::Operation::Log10, x, result, tol, rounding_mode)) {
+        while (!TEST_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log10, x,
+                                                  result, tol, rounding_mode)) {
           mx = x;
           mr = result;
           tol *= 2.0;
         }
       }
     }
     tlog << " Log10 failed: " << fails << "/" << count << "/" << cc
          << " tests.\n";

libc/test/src/math/log1p_test.cpp

for (uint64_t i = 0, v = start; i <= COUNT; ++i, v += step) {
       libc_errno = 0;
       double result = __llvm_libc::log1p(x);
       ++cc;
       if (isnan(result) || isinf(result))
         continue;
 
       ++count;
       // ASSERT_MPFR_MATCH(mpfr::Operation::Log1p, x, result, 0.5);
-      if (!EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log1p, x,
-                                               result, 0.5, rounding_mode)) {
+      if (!TEST_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log1p, x, result,
+                                             0.5, rounding_mode)) {
         ++fails;
-        while (!EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(
-            mpfr::Operation::Log1p, x, result, tol, rounding_mode)) {
+        while (!TEST_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log1p, x,
+                                                  result, tol, rounding_mode)) {
           mx = x;
           mr = result;
           tol *= 2.0;
         }
       }
     }
     tlog << " Log1p failed: " << fails << "/" << count << "/" << cc
          << " tests.\n";

libc/test/src/math/log2_test.cpp

for (uint64_t i = 0, v = START; i <= COUNT; ++i, v += STEP) {
       libc_errno = 0;
       double result = __llvm_libc::log2(x);
       ++cc;
       if (isnan(result) || isinf(result))
         continue;
 
       ++count;
       // ASSERT_MPFR_MATCH(mpfr::Operation::Log2, x, result, 0.5);
-      if (!EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log2, x, result,
-                                               0.5, rounding_mode)) {
+      if (!TEST_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log2, x, result,
         ++fails;
-        while (!EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(
-            mpfr::Operation::Log2, x, result, tol, rounding_mode)) {
+        while (!TEST_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log2, x,
+                                                  result, tol, rounding_mode)) {
           mx = x;
           mr = result;
           tol *= 2.0;
         }
       }
     }
     tlog << " Log2 failed: " << fails << "/" << count << "/" << cc
          << " tests.\n";

libc/test/src/math/log_test.cpp

for (uint64_t i = 0, v = START; i <= COUNT; ++i, v += STEP) {
       libc_errno = 0;
       double result = __llvm_libc::log(x);
       ++cc;
       if (isnan(result) || isinf(result))
         continue;
 
       ++count;
       // ASSERT_MPFR_MATCH(mpfr::Operation::Log, x, result, 0.5);
-      if (!EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log, x, result,
-                                               0.5, rounding_mode)) {
+      if (!TEST_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log, x, result,
         ++fails;
-        while (!EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(
-            mpfr::Operation::Log, x, result, tol, rounding_mode)) {
+        while (!TEST_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Log, x,
+                                                  result, tol, rounding_mode)) {
           mx = x;
           mr = result;
           tol *= 2.0;
         }
       }
     }
     tlog << " Log failed: " << fails << "/" << count << "/" << cc
          << " tests.\n";

libc/test/src/string/bcopy_test.cpp

 
 namespace __llvm_libc {
 
 TEST(LlvmLibcBcopyTest, MoveZeroByte) {
   char Buffer[] = {'a', 'b', 'y', 'z'};
   const char Expected[] = {'a', 'b', 'y', 'z'};
   void *const Dst = Buffer;
   __llvm_libc::bcopy(Buffer + 2, Dst, 0);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 TEST(LlvmLibcBcopyTest, DstAndSrcPointToSameAddress) {
   char Buffer[] = {'a', 'b'};
   const char Expected[] = {'a', 'b'};
   void *const Dst = Buffer;
   __llvm_libc::bcopy(Buffer, Dst, 1);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 TEST(LlvmLibcBcopyTest, DstStartsBeforeSrc) {
   // Set boundary at beginning and end for not overstepping when
   // copy forward or backward.
   char Buffer[] = {'z', 'a', 'b', 'c', 'z'};
   const char Expected[] = {'z', 'b', 'c', 'c', 'z'};
   void *const Dst = Buffer + 1;
   __llvm_libc::bcopy(Buffer + 2, Dst, 2);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 TEST(LlvmLibcBcopyTest, DstStartsAfterSrc) {
   char Buffer[] = {'z', 'a', 'b', 'c', 'z'};
   const char Expected[] = {'z', 'a', 'a', 'b', 'z'};
   void *const Dst = Buffer + 2;
   __llvm_libc::bcopy(Buffer + 1, Dst, 2);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 // e.g. `Dst` follow `src`.
 // str: [abcdefghij]
 //      [__src_____]
 //      [_____Dst__]
 TEST(LlvmLibcBcopyTest, SrcFollowDst) {
   char Buffer[] = {'z', 'a', 'b', 'z'};
   const char Expected[] = {'z', 'b', 'b', 'z'};
   void *const Dst = Buffer + 1;
   __llvm_libc::bcopy(Buffer + 2, Dst, 1);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 TEST(LlvmLibcBcopyTest, DstFollowSrc) {
   char Buffer[] = {'z', 'a', 'b', 'z'};
   const char Expected[] = {'z', 'a', 'a', 'z'};
   void *const Dst = Buffer + 2;
   __llvm_libc::bcopy(Buffer + 1, Dst, 1);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 // Adapt CheckMemmove signature to bcopy.
 static inline void Adaptor(cpp::span<char> dst, cpp::span<char> src,
                            size_t size) {
   __llvm_libc::bcopy(src.begin(), dst.begin(), size);
 }
 

libc/test/src/string/memmem_test.cpp

TEST(LlvmLibcMemmemTest, EmptyHaystackNonEmptyNeedleReturnsNull) {
   void *result = __llvm_libc::memmem(h, 0, n, sizeof(n));
   ASSERT_EQ(result, static_cast<void *>(nullptr));
 }
 
 TEST(LlvmLibcMemmemTest, EmptyNeedleReturnsHaystack) {
   char h[] = {'a', 'b', 'c'};
   char *n = nullptr;
   void *result = __llvm_libc::memmem(h, sizeof(h), n, 0);
-  ASSERT_EQ(static_cast<char *>(result), h);
+  ASSERT_EQ(static_cast<char *>(result), h + 0);
 }
 
 TEST(LlvmLibcMemmemTest, ExactMatchReturnsHaystack) {
   char h[] = {'a', 'b', 'c'};
   char n[] = {'a', 'b', 'c'};
   void *result = __llvm_libc::memmem(h, sizeof(h), n, sizeof(n));
-  ASSERT_EQ(static_cast<char *>(result), h);
+  ASSERT_EQ(static_cast<char *>(result), h + 0);
 }
 
 TEST(LlvmLibcMemmemTest, ReturnFirstMatchOfNeedle) {
   char h[] = {'a', 'a', 'b', 'c'};
   char n[] = {'a'};
   void *result = __llvm_libc::memmem(h, sizeof(h), n, sizeof(n));
-  ASSERT_EQ(static_cast<char *>(result), h);
+  ASSERT_EQ(static_cast<char *>(result), h + 0);
 }
 
 TEST(LlvmLibcMemmemTest, ReturnFirstExactMatchOfNeedle) {
   {
     char h[] = {'a', 'b', 'a', 'c', 'a', 'a'};
     char n[] = {'a', 'a'};
     void *result = __llvm_libc::memmem(h, sizeof(h), n, sizeof(n));
     ASSERT_EQ(static_cast<char *>(result), h + 4);
TEST(LlvmLibcMemmemTest, ReturnNullIfNoExactMatch) {
   }
 }
 
 TEST(LlvmLibcMemmemTest, ReturnMatchOfSpecifiedNeedleLength) {
   {
     char h[] = {'a', 'b', 'c'};
     char n[] = {'x', 'y', 'z'};
     void *result = __llvm_libc::memmem(h, sizeof(h), n, 0);
-    ASSERT_EQ(static_cast<char *>(result), h);
+    ASSERT_EQ(static_cast<char *>(result), h + 0);
   }
   {
     char h[] = {'a', 'b', 'c'};
     char n[] = {'b', 'c', 'a'};
     void *result = __llvm_libc::memmem(h, sizeof(h), n, 2);
     ASSERT_EQ(static_cast<char *>(result), h + 1);
   }
 }

libc/test/src/string/memmove_test.cpp

 namespace __llvm_libc {
 
 TEST(LlvmLibcMemmoveTest, MoveZeroByte) {
   char Buffer[] = {'a', 'b', 'y', 'z'};
   const char Expected[] = {'a', 'b', 'y', 'z'};
   void *const Dst = Buffer;
   void *const Ret = __llvm_libc::memmove(Dst, Buffer + 2, 0);
   EXPECT_EQ(Ret, Dst);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 TEST(LlvmLibcMemmoveTest, DstAndSrcPointToSameAddress) {
   char Buffer[] = {'a', 'b'};
   const char Expected[] = {'a', 'b'};
   void *const Dst = Buffer;
   void *const Ret = __llvm_libc::memmove(Dst, Buffer, 1);
   EXPECT_EQ(Ret, Dst);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 TEST(LlvmLibcMemmoveTest, DstStartsBeforeSrc) {
   // Set boundary at beginning and end for not overstepping when
   // copy forward or backward.
   char Buffer[] = {'z', 'a', 'b', 'c', 'z'};
   const char Expected[] = {'z', 'b', 'c', 'c', 'z'};
   void *const Dst = Buffer + 1;
   void *const Ret = __llvm_libc::memmove(Dst, Buffer + 2, 2);
   EXPECT_EQ(Ret, Dst);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 TEST(LlvmLibcMemmoveTest, DstStartsAfterSrc) {
   char Buffer[] = {'z', 'a', 'b', 'c', 'z'};
   const char Expected[] = {'z', 'a', 'a', 'b', 'z'};
   void *const Dst = Buffer + 2;
   void *const Ret = __llvm_libc::memmove(Dst, Buffer + 1, 2);
   EXPECT_EQ(Ret, Dst);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 // e.g. `Dst` follow `src`.
 // str: [abcdefghij]
 //      [__src_____]
 //      [_____Dst__]
 TEST(LlvmLibcMemmoveTest, SrcFollowDst) {
   char Buffer[] = {'z', 'a', 'b', 'z'};
   const char Expected[] = {'z', 'b', 'b', 'z'};
   void *const Dst = Buffer + 1;
   void *const Ret = __llvm_libc::memmove(Dst, Buffer + 2, 1);
   EXPECT_EQ(Ret, Dst);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 TEST(LlvmLibcMemmoveTest, DstFollowSrc) {
   char Buffer[] = {'z', 'a', 'b', 'z'};
   const char Expected[] = {'z', 'a', 'a', 'z'};
   void *const Dst = Buffer + 2;
   void *const Ret = __llvm_libc::memmove(Dst, Buffer + 1, 1);
   EXPECT_EQ(Ret, Dst);
-  ASSERT_MEM_EQ(Buffer, Expected);
+  ASSERT_MEM_EQ(Buffer, testing::MemoryView(Expected));
 }
 
 // Adapt CheckMemmove signature to op implementation signatures.
 static inline void Adaptor(cpp::span<char> dst, cpp::span<char> src,
                            size_t size) {
   __llvm_libc::memmove(dst.begin(), src.begin(), size);
 }
 

libc/test/src/string/mempcpy_test.cpp

TEST(LlvmLibcMempcpyTest, Simple) {
   ASSERT_EQ(static_cast<char *>(result), dest + 6);
   ASSERT_STREQ(src, dest);
 }
 
 TEST(LlvmLibcMempcpyTest, ZeroCount) {
   const char *src = "12345";
   char dest[10];
   void *result = __llvm_libc::mempcpy(dest, src, 0);
-  ASSERT_EQ(static_cast<char *>(result), dest);
+  ASSERT_EQ(static_cast<char *>(result), dest + 0);
 }

libc/utils/MPFRWrapper/MPFRUtils.h

#define EXPECT_MPFR_MATCH_ALL_ROUNDING(op, input, match_value, ulp_tolerance)  \
     mpfr::ForceRoundingMode __r3(mpfr::RoundingMode::Downward);                \
     EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance,                   \
                       mpfr::RoundingMode::Downward);                           \
     mpfr::ForceRoundingMode __r4(mpfr::RoundingMode::TowardZero);              \
     EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance,                   \
                       mpfr::RoundingMode::TowardZero);                         \
   }
 
-#define EXPECT_MPFR_MATCH_ROUNDING_SILENTLY(op, input, match_value,            \
-                                            ulp_tolerance, rounding)           \
-  EXPECT_THAT(match_value,                                                     \
-              __llvm_libc::testing::mpfr::get_silent_mpfr_matcher<op>(         \
-                  input, match_value, ulp_tolerance, rounding))
+#define TEST_MPFR_MATCH_ROUNDING_SILENTLY(op, input, match_value,              \
+                                          ulp_tolerance, rounding)             \
+  __llvm_libc::testing::mpfr::get_silent_mpfr_matcher<op>(                     \
+      input, match_value, ulp_tolerance, rounding)                             \
+      .match(match_value)
 
 #define ASSERT_MPFR_MATCH_DEFAULT(op, input, match_value, ulp_tolerance)       \
   ASSERT_THAT(match_value,                                                     \
               __llvm_libc::testing::mpfr::get_mpfr_matcher<op>(                \
                   input, match_value, ulp_tolerance,                           \
                   __llvm_libc::testing::mpfr::RoundingMode::Nearest))
 
 #define ASSERT_MPFR_MATCH_ROUNDING(op, input, match_value, ulp_tolerance,      \

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

 cc_library(
     name = "test_logger",
     srcs = ["TestLogger.cpp"],
     hdrs = ["TestLogger.h"],
     deps = [
         "//libc:__support_cpp_string",
         "//libc:__support_cpp_string_view",
         "//libc:__support_osutil_io",
+        "//libc:__support_uint128",
         "//libc:libc_root",
     ],
 )
 
 cc_library(
     name = "LibcUnitTest",
     srcs = [
         "BazelFilePath.cpp",