[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

72

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

72

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/FPMatcher.h

#define DECLARE_SPECIAL_CONSTANTS(T)                                           \
   const T neg_inf = T(FPBits::neg_inf());
 
 #define EXPECT_FP_EQ(expected, actual)                                         \
   EXPECT_THAT(                                                                 \
       actual,                                                                  \
       __llvm_libc::testing::getMatcher<__llvm_libc::testing::TestCond::EQ>(    \
           expected))
 
+#define TEST_FP_EQ(expected, actual)                                           \
+  __llvm_libc::testing::getMatcher<__llvm_libc::testing::TestCond::EQ>(        \
+      expected)                                                                \
+      .match(actual)
+
 #define EXPECT_FP_IS_NAN(actual) EXPECT_TRUE((actual) != (actual))
 
 #define ASSERT_FP_EQ(expected, actual)                                         \
   ASSERT_THAT(                                                                 \
       actual,                                                                  \
       __llvm_libc::testing::getMatcher<__llvm_libc::testing::TestCond::EQ>(    \
           expected))
 

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> && (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);
   return "0x" + cpp::string(buf, sizeof(buf));

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
+// char is already specialized to handle character
+template TestLogger &TestLogger::operator<< <short>(short);
 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<< <long long>(long long);
+template TestLogger &TestLogger::operator<< <unsigned char>(unsigned char);
+template TestLogger &TestLogger::operator<< <unsigned short>(unsigned short);
+template TestLogger &TestLogger::operator<< <unsigned int>(unsigned int);
+template TestLogger &TestLogger::operator<< <unsigned long>(unsigned 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/exhaustive/acosf_test.cpp

struct LlvmLibcAcosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Acos, x,
-                                  __llvm_libc::acosf(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Acos, x, __llvm_libc::acosf(x),
+                                0.5, rounding);
     } while (bits++ < stop);
     return result;
   }
 };
 
 static const int NUM_THREADS = std::thread::hardware_concurrency();
 
 // Range: [0, Inf];

libc/test/src/math/exhaustive/acoshf_test.cpp

struct LlvmLibcAcoshfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Acosh, x,
-                                  __llvm_libc::acoshf(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Acosh, x,
     } while (bits++ < stop);
     return result;
   }
 };
 
 static const int NUM_THREADS = std::thread::hardware_concurrency();
 
 // Range: [1, Inf];

libc/test/src/math/exhaustive/asinf_test.cpp

struct LlvmLibcAsinfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Asin, x,
-                                  __llvm_libc::asinf(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Asin, x, __llvm_libc::asinf(x),
+                                0.5, rounding);
       // if (!result) break;
     } while (bits++ < stop);
     return result;
   }
 };
 
 static const int NUM_THREADS = std::thread::hardware_concurrency();
 

libc/test/src/math/exhaustive/asinhf_test.cpp

struct LlvmLibcAsinhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Asinh, x,
-                                  __llvm_libc::asinhf(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Asinh, x,
     } while (bits++ < stop);
     return result;
   }
 };
 
 static const int NUM_THREADS = std::thread::hardware_concurrency();
 
 // Range: [0, Inf];

libc/test/src/math/exhaustive/atanf_test.cpp

struct LlvmLibcAtanfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Atan, x,
-                                  __llvm_libc::atanf(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Atan, x, __llvm_libc::atanf(x),
+                                0.5, rounding);
     } while (bits++ < stop);
     return result;
   }
 };
 
 static const int NUM_THREADS = std::thread::hardware_concurrency();
 
 // Range: [0, 1.0];

libc/test/src/math/exhaustive/atanhf_test.cpp

struct LlvmLibcAtanhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Atanh, x,
-                                  __llvm_libc::atanhf(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Atanh, x,
     } while (bits++ < stop);
     return result;
   }
 };
 
 static const int NUM_THREADS = std::thread::hardware_concurrency();
 
 // Range: [0, 1.0];

libc/test/src/math/exhaustive/cosf_test.cpp

struct LlvmLibcCosfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x),
-                                 0.5, rounding);
+      bool r = TEST_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x),
       result &= r;
     } while (++bits < stop);
     return result;
   }
 };
 
 // Range: [0, +Inf);
 static constexpr uint32_t POS_START = 0x0000'0000U;

libc/test/src/math/exhaustive/coshf_test.cpp

struct LlvmLibcCoshfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Cosh, x,
-                                  __llvm_libc::coshf(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Cosh, x, __llvm_libc::coshf(x),
+                                0.5, rounding);
     } while (bits++ < stop);
     return result;
   }
 };
 
 // Range: [0, 90];
 static constexpr uint32_t POS_START = 0x0000'0000U;
 static constexpr uint32_t POS_STOP = 0x42b4'0000U;

libc/test/src/math/exhaustive/exp10f_test.cpp

struct LlvmLibcExp10fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp10, x,
-                                  __llvm_libc::exp10f(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Exp10, x,
     } while (bits++ < stop);
     return result;
   }
 };
 
 // Range: [0, 89];
 static constexpr uint32_t POS_START = 0x0000'0000U;
 static constexpr uint32_t POS_STOP = 0x42b2'0000U;

libc/test/src/math/exhaustive/exp2f_test.cpp

struct LlvmLibcExp2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x,
-                                  __llvm_libc::exp2f(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x),
+                                0.5, rounding);
     } while (bits++ < stop);
     return result;
   }
 };
 
 // Range: [0, +Inf];
 static constexpr uint32_t POS_START = 0x0000'0000U;
 static constexpr uint32_t POS_STOP = 0x7f80'0000U;

libc/test/src/math/exhaustive/expf_test.cpp

struct LlvmLibcExpfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
-                                  0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
     } while (bits++ < stop);
     return result;
   }
 };
 
 // Range: [0, 89];
 static constexpr uint32_t POS_START = 0x0000'0000U;
 static constexpr uint32_t POS_STOP = 0x42b2'0000U;

libc/test/src/math/exhaustive/expm1f_test.cpp

struct LlvmLibcExpm1fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = stop;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Expm1, x,
-                                  __llvm_libc::expm1f(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Expm1, x,
     } while (bits-- > start);
     return result;
   }
 };
 
 // Range: [0, 89];
 static constexpr uint32_t POS_START = 0x0000'0000U;
 static constexpr uint32_t POS_STOP = 0x42b2'0000U;

libc/test/src/math/exhaustive/hypotf_test.cpp

bool check(uint32_t start, uint32_t stop,
     mpfr::ForceRoundingMode r(rounding);
     uint32_t xbits = start;
     bool result = true;
     do {
       float x = float(FPBits(xbits));
       uint32_t ybits = Y_START;
       do {
         float y = float(FPBits(ybits));
-        result &= EXPECT_FP_EQ(__llvm_libc::fputil::hypot(x, y),
-                               __llvm_libc::hypotf(x, y));
+        result &= TEST_FP_EQ(__llvm_libc::fputil::hypot(x, y),
         // Using MPFR will be much slower.
         // mpfr::BinaryInput<float> input{x, y};
         // EXPECT_MPFR_MATCH(mpfr::Operation::Hypot, input,
         // __llvm_libc::hypotf(x, y), 0.5,
         //                   rounding);
       } while (ybits++ < Y_STOP);
     } while (xbits++ < stop);
     return result;

libc/test/src/math/exhaustive/log10f_test.cpp

struct LlvmLibcLog10fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log10, x,
-                                  __llvm_libc::log10f(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Log10, x,
     } while (bits++ < stop);
     return result;
   }
 };
 
 // Range: All non-negative;
 static constexpr uint32_t START = 0x0000'0000U;
 static constexpr uint32_t STOP = 0x7f80'0000U;

libc/test/src/math/exhaustive/log1pf_test.cpp

struct LlvmLibcLog1pfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log1p, x,
-                                  __llvm_libc::log1pf(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Log1p, x,
     } while (bits++ < stop);
     return result;
   }
 };
 
 // Range: All non-negative;
 static constexpr uint32_t START = 0x0000'0000U;
 static constexpr uint32_t STOP = 0x7f80'0000U;

libc/test/src/math/exhaustive/log2f_test.cpp

struct LlvmLibcLog2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log2, x,
-                                  __llvm_libc::log2f(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Log2, x, __llvm_libc::log2f(x),
+                                0.5, rounding);
     } while (bits++ < stop);
     return result;
   }
 };
 
 TEST_F(LlvmLibcLog2fExhaustiveTest, RoundNearestTieToEven) {
   test_full_range(/*start=*/0U, /*stop=*/0x7f80'0000U,
                   mpfr::RoundingMode::Nearest);

libc/test/src/math/exhaustive/logf_test.cpp

struct LlvmLibcLogfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x),
-                                  0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x),
     } while (bits++ < stop);
     return result;
   }
 };
 
 TEST_F(LlvmLibcLogfExhaustiveTest, RoundNearestTieToEven) {
   test_full_range(/*start=*/0U, /*stop=*/0x7f80'0000U,
                   mpfr::RoundingMode::Nearest);

libc/test/src/math/exhaustive/sincosf_test.cpp

bool check(uint32_t start, uint32_t stop,
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
       float sinx, cosx;
       __llvm_libc::sincosf(x, &sinx, &cosx);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, sinx, 0.5, rounding);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, cosx, 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Sin, x, sinx, 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Cos, x, cosx, 0.5, rounding);
     } while (++bits < stop);
     return result;
   }
 };
 
 // Range: [0, +Inf);
 static constexpr uint32_t POS_START = 0x0000'0000U;
 static constexpr uint32_t POS_STOP = 0x7f80'0000U;

libc/test/src/math/exhaustive/sinf_test.cpp

struct LlvmLibcSinfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x),
-                                 0.5, rounding);
+      bool r = TEST_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x),
       result &= r;
     } while (++bits < stop);
     return result;
   }
 };
 
 // Range: [0, +Inf);
 static constexpr uint32_t POS_START = 0x0000'0000U;

libc/test/src/math/exhaustive/sinhf_test.cpp

struct LlvmLibcSinhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Sinh, x,
-                                  __llvm_libc::sinhf(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Sinh, x, __llvm_libc::sinhf(x),
+                                0.5, rounding);
     } while (bits++ < stop);
     return result;
   }
 };
 
 // Range: [0, 90];
 static constexpr uint32_t POS_START = 0x0000'0000U;
 static constexpr uint32_t POS_STOP = 0x42b4'0000U;

libc/test/src/math/exhaustive/tanf_test.cpp

bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     int tol = TOLERANCE;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      bool r = EXPECT_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tanf(x),
-                                 0.5, rounding);
+      bool r = TEST_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tanf(x),
       result &= r;
       if (!r)
         --tol;
       if (!tol)
         break;
     } while (++bits < stop);
     return result;
   }

libc/test/src/math/exhaustive/tanhf_test.cpp

struct LlvmLibcTanhfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
   bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
     bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Tanh, x,
-                                  __llvm_libc::tanhf(x), 0.5, rounding);
+      result &= TEST_MPFR_MATCH(mpfr::Operation::Tanh, x, __llvm_libc::tanhf(x),
+                                0.5, rounding);
     } while (bits++ < stop);
     return result;
   }
 };
 
 static const int NUM_THREADS = std::thread::hardware_concurrency();
 
 // Range: [0, INF];

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_ROUNDING(op, input, match_value, ulp_tolerance,      \
   EXPECT_THAT(match_value, __llvm_libc::testing::mpfr::get_mpfr_matcher<op>(   \
                                input, match_value, ulp_tolerance, rounding))
 
 #define EXPECT_MPFR_MATCH(...)                                                 \
   GET_MPFR_MACRO(__VA_ARGS__, EXPECT_MPFR_MATCH_ROUNDING,                      \
                  EXPECT_MPFR_MATCH_DEFAULT, GET_MPFR_DUMMY_ARG)                \
   (__VA_ARGS__)
 
+#define TEST_MPFR_MATCH_ROUNDING(op, input, match_value, ulp_tolerance,        \
+                                 rounding)                                     \
+  __llvm_libc::testing::mpfr::get_mpfr_matcher<op>(input, match_value,         \
+                                                   ulp_tolerance, rounding)    \
+      .match(match_value)
+
+#define TEST_MPFR_MATCH(...)                                                   \
+  GET_MPFR_MACRO(__VA_ARGS__, TEST_MPFR_MATCH_ROUNDING,                        \
+                 EXPECT_MPFR_MATCH_DEFAULT, GET_MPFR_DUMMY_ARG)                \
+  (__VA_ARGS__)
+
 #define EXPECT_MPFR_MATCH_ALL_ROUNDING(op, input, match_value, ulp_tolerance)  \
   {                                                                            \
     namespace mpfr = __llvm_libc::testing::mpfr;                               \
     mpfr::ForceRoundingMode __r1(mpfr::RoundingMode::Nearest);                 \
     EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance,                   \
                       mpfr::RoundingMode::Nearest);                            \
     mpfr::ForceRoundingMode __r2(mpfr::RoundingMode::Upward);                  \
     EXPECT_MPFR_MATCH(op, input, match_value, ulp_tolerance,                   \
                       mpfr::RoundingMode::Upward);                             \
     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",