[libc] Improve information printed on failure of a math test which uses MPFR.

[sivachandra]

Summary

A new test matcher class MPFRMatcher is added along with helper macros
EXPECT|ASSERT_MPFR_MATCH.

New type traits classes RemoveCV and IsFloatingPointType have been
added and used to implement the above class and its helpers.

[sivachandra]

Remove the long double instantiation.
Can add it back when we deal with long double in future.

[abrachet]

I don't want to make any suggestions yet because I don't fully understand why we need a MPFR_TEST. Would you mind clarifying the need for TEST_WITH_BASE_CLASS? Instead of MPFR_TEST could we have TEST_EXTENSION's first argument take a class with compare, would that simplify it? I'm by no means a gtest expert, I'm not sure how someone would use gtest to fill these kinds of needs. Maybe they would make their own macros which end up calling FAIL or using matchers. We aren't limited to that though so perhaps these would end up being more complicated than this solution.

libc/utils/CPP/TypeTraits.h

50–52

type -> Type

On that note, we could make an analog to std::type_identity and make this
template <typename T> struct RemoveCV : TypeIdentity<T> {};. No strong preference though.

libc/utils/MPFRWrapper/MPFRUtils.cpp

26–27

Is there a reason that this is not just a static method of MPFRNumber?

79

Might as well use mpfr_snprintf?

113–115

We can just keep streaming instead of ending the statement and calling llvm::outs() again perhaps? That would be stylistically similar to what we have in Test.cpp

libc/utils/MPFRWrapper/MPFRUtils.h

56–58

We aren't enabling another specialization when this isn't true so could we just make this a static_assert?

[sivachandra]

In D79256#2016625, @abrachet wrote:

I don't want to make any suggestions yet because I don't fully understand why we need a MPFR_TEST. Would you mind clarifying the need for TEST_WITH_BASE_CLASS? Instead of MPFR_TEST could we have TEST_EXTENSION's first argument take a class with compare, would that simplify it? I'm by no means a gtest expert, I'm not sure how someone would use gtest to fill these kinds of needs. Maybe they would make their own macros which end up calling FAIL or using matchers. We aren't limited to that though so perhaps these would end up being more complicated than this solution.

Huh! I totally missed that we have matchers now with which we can do the exact same thing as in this patch. Will change it to use the matcher API and update soon.

[sivachandra]

• Use a matcher instead of special test class.
• Addressed relevant comments.

[sivachandra]

libc/utils/CPP/TypeTraits.h

50–52

At the least it avoid typos like the one you found. So, done.

[abrachet]

libc/utils/CPP/TypeTraits.h

57

I believe that typename shouldn't be required and RemoveCV<T>::Type should be enough.

libc/utils/MPFRWrapper/MPFRUtils.cpp

11–12

No longer needed, I believe

32–46

Do these need to be enable if specializations could they just be overloads?

46–47

Could this also be just a static_assert?

libc/utils/MPFRWrapper/MPFRUtils.h

59–61

Can this one also be static_assert?

[sivachandra]

Address comments.

[sivachandra]

libc/utils/CPP/TypeTraits.h

57

RemoveCV<T>::Type is a dependent type and should require typename? I tried your suggestion and that is what the compiler also tells me:

TypeTraits.h:57:44: error: missing 'typename' prior to dependent type name 'RemoveCV<T>::Type'

libc/utils/MPFRWrapper/MPFRUtils.cpp

32–46

Yes. Having explicit enables avoids implicit conversions of the arguments. Implicit conversions can potentially lead of loss of precision. Added a comment saying the same.

46–47

Again, are you suggesting to put a static_assert inside the function body? If yes, it feels a bit odd to error-out with a custom message rather than give a normal compiler message for a constructor.

libc/utils/MPFRWrapper/MPFRUtils.h

59–61

Done, but I assumed you meant we should instead put a static_assert inside the function body? I think that makes sense. But, see my comment at the other place. I don't have any strong preference, but I do see that in this case the static_assert inside the function body is much nicer.

[abrachet]

LGTM

libc/utils/CPP/TypeTraits.h

57

My mistake, I thought it wasn't necessary because the right hand side of a using can only be a type.

libc/utils/MPFRWrapper/MPFRUtils.cpp

46–47

Sounds good to keep it like this then

libc/test/src/math/cosf_test.cpp

TEST(CosfTest, SpecialNumbers) {
   EXPECT_EQ(llvmlibc_errno, EDOM);
 
   llvmlibc_errno = 0;
   EXPECT_TRUE(FloatBits::isNegQNan(
       as_uint32_bits(__llvm_libc::cosf(as_float(FloatBits::NegInf)))));
   EXPECT_EQ(llvmlibc_errno, EDOM);
 }
 
-TEST(CosfTest, InFloatRange) {
+MPFR_TEST(CosfTest, InFloatRange) {
   constexpr uint32_t count = 1000000;
   constexpr uint32_t step = UINT32_MAX / count;
   for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
     float x = as_float(v);
     if (isnan(x) || isinf(x))
       continue;
-    EXPECT_TRUE(mpfr::equalsCos(x, __llvm_libc::cosf(x), tolerance));
+    ASSERT_MPFR_EQ(mpfr::OP_Cos, x, __llvm_libc::cosf(x), tolerance);
   }
 }
 
 // For small values, cos(x) is 1.
-TEST(CosfTest, SmallValues) {
+MPFR_TEST(CosfTest, SmallValues) {
   float x = as_float(0x17800000);
   float result = __llvm_libc::cosf(x);
-  EXPECT_TRUE(mpfr::equalsCos(x, result, tolerance));
+  EXPECT_MPFR_EQ(mpfr::OP_Cos, x, result, tolerance);
   EXPECT_EQ(FloatBits::One, as_uint32_bits(result));
 
-  x = as_float(0x00400000);
+  x = as_float(0x0040000);
   result = __llvm_libc::cosf(x);
-  EXPECT_TRUE(mpfr::equalsCos(x, result, tolerance));
+  EXPECT_MPFR_EQ(mpfr::OP_Cos, x, result, tolerance);
   EXPECT_EQ(FloatBits::One, as_uint32_bits(result));
 }
 
 // SDCOMP-26094: check cosf in the cases for which the range reducer
 // returns values furthest beyond its nominal upper bound of pi/4.
-TEST(CosfTest, SDCOMP_26094) {
+MPFR_TEST(CosfTest, SDCOMP_26094) {
   for (uint32_t v : sdcomp26094Values) {
     float x = as_float(v);
-    EXPECT_TRUE(mpfr::equalsCos(x, __llvm_libc::cosf(x), tolerance));
+    ASSERT_MPFR_EQ(mpfr::OP_Cos, x, __llvm_libc::cosf(x), tolerance);
   }
 }

libc/test/src/math/sincosf_test.cpp

TEST(SinCosfTest, SpecialNumbers) {
 
   llvmlibc_errno = 0;
   __llvm_libc::sincosf(as_float(FloatBits::NegInf), &sin, &cos);
   EXPECT_TRUE(FloatBits::isQNan(as_uint32_bits(cos)));
   EXPECT_TRUE(FloatBits::isQNan(as_uint32_bits(sin)));
   EXPECT_EQ(llvmlibc_errno, EDOM);
 }
 
-TEST(SinCosfTest, InFloatRange) {
+MPFR_TEST(SinCosfTest, InFloatRange) {
   constexpr uint32_t count = 1000000;
   constexpr uint32_t step = UINT32_MAX / count;
   for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
     float x = as_float(v);
     if (isnan(x) || isinf(x))
       continue;
 
     float sin, cos;
     __llvm_libc::sincosf(x, &sin, &cos);
-    EXPECT_TRUE(mpfr::equalsCos(x, cos, tolerance));
-    EXPECT_TRUE(mpfr::equalsSin(x, sin, tolerance));
+    ASSERT_MPFR_EQ(mpfr::OP_Cos, x, cos, tolerance);
+    ASSERT_MPFR_EQ(mpfr::OP_Sin, x, sin, tolerance);
   }
 }
 
 // For small values, cos(x) is 1 and sin(x) is x.
-TEST(SinCosfTest, SmallValues) {
+MPFR_TEST(SinCosfTest, SmallValues) {
   uint32_t bits = 0x17800000;
   float x = as_float(bits);
   float result_cos, result_sin;
   __llvm_libc::sincosf(x, &result_sin, &result_cos);
-  EXPECT_TRUE(mpfr::equalsCos(x, result_cos, tolerance));
-  EXPECT_TRUE(mpfr::equalsSin(x, result_sin, tolerance));
+  EXPECT_MPFR_EQ(mpfr::OP_Cos, x, result_cos, tolerance);
+  EXPECT_MPFR_EQ(mpfr::OP_Sin, x, result_sin, tolerance);
   EXPECT_EQ(FloatBits::One, as_uint32_bits(result_cos));
   EXPECT_EQ(bits, as_uint32_bits(result_sin));
 
   bits = 0x00400000;
   x = as_float(bits);
   __llvm_libc::sincosf(x, &result_sin, &result_cos);
-  EXPECT_TRUE(mpfr::equalsCos(x, result_cos, tolerance));
-  EXPECT_TRUE(mpfr::equalsSin(x, result_sin, tolerance));
+  EXPECT_MPFR_EQ(mpfr::OP_Cos, x, result_cos, tolerance);
+  EXPECT_MPFR_EQ(mpfr::OP_Sin, x, result_sin, tolerance);
   EXPECT_EQ(FloatBits::One, as_uint32_bits(result_cos));
   EXPECT_EQ(bits, as_uint32_bits(result_sin));
 }
 
 // SDCOMP-26094: check sinf in the cases for which the range reducer
 // returns values furthest beyond its nominal upper bound of pi/4.
-TEST(SinCosfTest, SDCOMP_26094) {
+MPFR_TEST(SinCosfTest, SDCOMP_26094) {
   for (uint32_t v : sdcomp26094Values) {
     float x = as_float(v);
     float sin, cos;
     __llvm_libc::sincosf(x, &sin, &cos);
-    EXPECT_TRUE(mpfr::equalsCos(x, cos, tolerance));
-    EXPECT_TRUE(mpfr::equalsSin(x, sin, tolerance));
+    EXPECT_MPFR_EQ(mpfr::OP_Cos, x, cos, tolerance);
+    EXPECT_MPFR_EQ(mpfr::OP_Sin, x, sin, tolerance);
   }
 }

libc/test/src/math/sinf_test.cpp

TEST(SinfTest, SpecialNumbers) {
   EXPECT_EQ(llvmlibc_errno, EDOM);
 
   llvmlibc_errno = 0;
   EXPECT_TRUE(FloatBits::isNegQNan(
       as_uint32_bits(__llvm_libc::sinf(as_float(FloatBits::NegInf)))));
   EXPECT_EQ(llvmlibc_errno, EDOM);
 }
 
-TEST(SinfTest, InFloatRange) {
+MPFR_TEST(SinfTest, InFloatRange) {
   constexpr uint32_t count = 1000000;
   constexpr uint32_t step = UINT32_MAX / count;
   for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
     float x = as_float(v);
     if (isnan(x) || isinf(x))
       continue;
-    EXPECT_TRUE(mpfr::equalsSin(x, __llvm_libc::sinf(x), tolerance));
+    ASSERT_MPFR_EQ(mpfr::OP_Sin, x, __llvm_libc::sinf(x), tolerance);
   }
 }
 
-TEST(SinfTest, SpecificBitPatterns) {
+MPFR_TEST(SinfTest, SpecificBitPatterns) {
   float x = as_float(0xc70d39a1);
-  EXPECT_TRUE(mpfr::equalsSin(x, __llvm_libc::sinf(x), tolerance));
+  EXPECT_MPFR_EQ(mpfr::OP_Sin, x, __llvm_libc::sinf(x), tolerance);
 }
 
 // For small values, sin(x) is x.
-TEST(SinfTest, SmallValues) {
+MPFR_TEST(SinfTest, SmallValues) {
   uint32_t bits = 0x17800000;
   float x = as_float(bits);
   float result = __llvm_libc::sinf(x);
-  EXPECT_TRUE(mpfr::equalsSin(x, result, tolerance));
+  EXPECT_MPFR_EQ(mpfr::OP_Sin, x, result, tolerance);
   EXPECT_EQ(bits, as_uint32_bits(result));
 
   bits = 0x00400000;
   x = as_float(bits);
   result = __llvm_libc::sinf(x);
-  EXPECT_TRUE(mpfr::equalsSin(x, result, tolerance));
+  EXPECT_MPFR_EQ(mpfr::OP_Sin, x, result, tolerance);
   EXPECT_EQ(bits, as_uint32_bits(result));
 }
 
 // SDCOMP-26094: check sinf in the cases for which the range reducer
 // returns values furthest beyond its nominal upper bound of pi/4.
-TEST(SinfTest, SDCOMP_26094) {
+MPFR_TEST(SinfTest, SDCOMP_26094) {
   for (uint32_t v : sdcomp26094Values) {
     float x = as_float(v);
-    EXPECT_TRUE(mpfr::equalsSin(x, __llvm_libc::sinf(x), tolerance));
+    EXPECT_MPFR_EQ(mpfr::OP_Sin, x, __llvm_libc::sinf(x), tolerance);
   }
 }

libc/utils/CPP/TypeTraits.h

 template <> struct IsIntegral<bool> : public TrueValue {};
 
 template <typename T> struct IsPointerType : public FalseValue {};
 template <typename T> struct IsPointerType<T *> : public TrueValue {};
 
 template <typename T1, typename T2> struct IsSame : public FalseValue {};
 template <typename T> struct IsSame<T, T> : public TrueValue {};
 
+template <typename T> struct RemoveCV { typedef T Type; };
+template <typename T> struct RemoveCV<const T> { typedef T type; };
+template <typename T> struct RemoveCV<volatile T> { typedef T type; };
+template <typename T> struct RemoveCV<const volatile T> { typedef T type; };
+
+template <typename T> using RemoveCVType = typename RemoveCV<T>::Type;
+
+template <typename Type> struct IsFloatingPointType {
+  static constexpr bool Value = IsSame<float, RemoveCVType<Type>>::Value ||
+                                IsSame<double, RemoveCVType<Type>>::Value ||
+                                IsSame<long double, RemoveCVType<Type>>::Value;
+};
+
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_CPP_TYPETRAITS_H

libc/utils/MPFRWrapper/CMakeLists.txt

 try_compile(
   LIBC_TESTS_CAN_USE_MPFR
   ${CMAKE_CURRENT_BINARY_DIR}
   SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/check_mpfr.cpp
   LINK_LIBRARIES
     -lmpfr -lgmp
 )
 
 if(LIBC_TESTS_CAN_USE_MPFR)
   add_library(libcMPFRWrapper
     MPFRUtils.cpp
     MPFRUtils.h
   )
-  target_link_libraries(libcMPFRWrapper -lmpfr -lgmp)
+  add_dependencies(libcMPFRWrapper libc.utils.CPP.standalone_cpp LibcUnitTest LLVMSupport)
+  target_link_libraries(libcMPFRWrapper -lmpfr -lgmp LibcUnitTest LLVMSupport)
 else()
   message(WARNING "Math tests using MPFR will be skipped.")
 endif()

libc/utils/MPFRWrapper/MPFRUtils.h

 //===-- MPFRUtils.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_MPFRUTILS_H
 #define LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H
 
+#include "utils/CPP/TypeTraits.h"
+#include "utils/UnitTest/Test.h"
+
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace testing {
 namespace mpfr {
 
 struct Tolerance {
   // Number of bits used to represent the fractional
struct Tolerance {
   unsigned int width; // Number of valid LSB bits in |value|.
 
   // The bits in the tolerance value. The tolerance value will be
   // sum(bits[width - i] * 2 ^ (- basePrecision - i)) for |i| in
   // range [1, width].
   uint32_t bits;
 };
 
-// Return true if |libcOutput| is within the tolerance |t| of the cos(x)
-// value as evaluated by MPFR.
-bool equalsCos(float x, float libcOutput, const Tolerance &t);
-
-// Return true if |libcOutput| is within the tolerance |t| of the sin(x)
-// value as evaluated by MPFR.
-bool equalsSin(float x, float libcOutput, const Tolerance &t);
+enum Operation {
+  OP_Cos,
+  OP_Sin,
+};
+
+namespace internal {
+
+template <typename T>
+bool compare(Operation op, T input, T libcOutput, const Tolerance &t);
+
+} // namespace internal
+
+class Test : public __llvm_libc::testing::Test {
+protected:
+  template <typename T,
+            __llvm_libc::cpp::EnableIfType<
+                __llvm_libc::cpp::IsFloatingPointType<T>::Value, int> = 0>
+  static bool compare(__llvm_libc::testing::mpfr::Operation op, T input,
+                      T libcOutput,
+                      const __llvm_libc::testing::mpfr::Tolerance &t) {
+    return internal::compare(op, input, libcOutput, t);
+  }
+};
 
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc
 
+#define MPFR_TEST(SuiteName, TestName)                                         \
+  TEST_WITH_BASE_CLASS(SuiteName, TestName, __llvm_libc::testing::mpfr::Test)
+
+#define EXPECT_MPFR_EQ(op, input, libcOutput, tolerance)                       \
+  TEST_EXTENSION(__llvm_libc::testing::mpfr::Test::compare(                    \
+                     op, input, libcOutput, tolerance),                        \
+                 true)
+
+#define ASSERT_MPFR_EQ(op, input, libcOutput, tolerance)                       \
+  if (!EXPECT_MPFR_EQ(op, input, libcOutput, tolerance))                       \
+  return
+
 #endif // LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H

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 <iostream>
+#include "llvm/Support/raw_ostream.h"
+
 #include <mpfr.h>
 
 namespace __llvm_libc {
 namespace testing {
 namespace mpfr {
 
 class MPFRNumber {
   // A precision value which allows sufficiently large additional
   // precision even compared to double precision floating point values.
   static constexpr unsigned int mpfrPrecision = 96;
 
   mpfr_t value;
 
+  template <typename T>
+  friend bool internal::compare(Operation, T, T, const Tolerance &);
+
 public:
   MPFRNumber() { mpfr_init2(value, mpfrPrecision); }
 
-  explicit MPFRNumber(float x) {
+  template <typename XType,
+            cpp::EnableIfType<cpp::IsSame<float, XType>::Value, int> = 0>
+  explicit MPFRNumber(XType x) {
     mpfr_init2(value, mpfrPrecision);
     mpfr_set_flt(value, x, MPFR_RNDN);
   }
 
+  template <typename XType,
+            cpp::EnableIfType<cpp::IsSame<double, XType>::Value, int> = 0>
+  explicit MPFRNumber(XType x) {
+    mpfr_init2(value, mpfrPrecision);
+    mpfr_set_d(value, x, MPFR_RNDN);
+  }
+
   MPFRNumber(const MPFRNumber &other) {
     mpfr_set(value, other.value, MPFR_RNDN);
   }
 
   ~MPFRNumber() { mpfr_clear(value); }
 
   // Returns true if |other| is within the tolerance value |t| of this
   // number.
   bool isEqual(const MPFRNumber &other, const Tolerance &t) {
     MPFRNumber tolerance(0.0);
bool isEqual(const MPFRNumber &other, const Tolerance &t) {
     if (mpfr_cmp(value, other.value) >= 0)
       mpfr_sub(difference.value, value, other.value, MPFR_RNDN);
     else
       mpfr_sub(difference.value, other.value, value, MPFR_RNDN);
 
     return mpfr_lessequal_p(difference.value, tolerance.value);
   }
 
+  std::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.
+    char buffer[200];
+    mpfr_sprintf(buffer, "%100.50Rf", value);
+    llvm::StringRef ref(buffer);
+    ref = ref.trim();
+    return ref.str();
+  }
+
   // These functions are useful for debugging.
   float asFloat() const { return mpfr_get_flt(value, MPFR_RNDN); }
   double asDouble() const { return mpfr_get_d(value, MPFR_RNDN); }
   void dump(const char *msg) const { mpfr_printf("%s%.128Rf\n", msg, value); }
+};
 
-public:
-  static MPFRNumber cos(float x) {
-    MPFRNumber result;
-    MPFRNumber mpfrX(x);
-    mpfr_cos(result.value, mpfrX.value, MPFR_RNDN);
-    return result;
-  }
+namespace internal {
 
-  static MPFRNumber sin(float x) {
-    MPFRNumber result;
-    MPFRNumber mpfrX(x);
-    mpfr_sin(result.value, mpfrX.value, MPFR_RNDN);
-    return result;
+template <typename T>
+bool compare(Operation op, T input, T libcResult, const Tolerance &t) {
+  MPFRNumber mpfrResult;
+  MPFRNumber mpfrInput(input);
+  MPFRNumber mpfrLibcResult(libcResult);
+
+  switch (op) {
+  case OP_Cos:
+    mpfr_cos(mpfrResult.value, mpfrInput.value, MPFR_RNDN);
+    break;
+  case OP_Sin:
+    mpfr_sin(mpfrResult.value, mpfrInput.value, MPFR_RNDN);
+    break;
   }
-};
 
-bool equalsCos(float input, float libcOutput, const Tolerance &t) {
-  MPFRNumber mpfrResult = MPFRNumber::cos(input);
-  MPFRNumber libcResult(libcOutput);
-  return mpfrResult.isEqual(libcResult, t);
+  if (!mpfrResult.isEqual(mpfrLibcResult, t)) {
+    llvm::outs() << llvm::raw_ostream::RED
+                 << "Libc result is not within tolerance value of the MPFR "
+                 << "result:\n"
+                 << llvm::raw_ostream::RESET;
+    llvm::outs() << "      Input: " << mpfrInput.str() << '\n';
+    llvm::outs() << "Libc result: " << mpfrLibcResult.str() << '\n';
+    llvm::outs() << "MPFR result: " << mpfrResult.str() << '\n';
+
+    return false;
   }
 
-bool equalsSin(float input, float libcOutput, const Tolerance &t) {
-  MPFRNumber mpfrResult = MPFRNumber::sin(input);
-  MPFRNumber libcResult(libcOutput);
-  return mpfrResult.isEqual(libcResult, t);
+  return true;
 }
 
+template bool compare<float>(Operation, float, float, const Tolerance &);
+template bool compare<double>(Operation, double, double, const Tolerance &);
+
+} // namespace internal
+
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc

libc/utils/UnitTest/Test.h

 enum TestCondition {
   Cond_None,
   Cond_EQ,
   Cond_NE,
   Cond_LT,
   Cond_LE,
   Cond_GT,
   Cond_GE,
+  Cond_Extension
 };
 
 namespace internal {
 
 template <typename ValType>
 bool test(RunContext &Ctx, TestCondition Cond, ValType LHS, ValType RHS,
           const char *LHSStr, const char *RHSStr, const char *File,
           unsigned long Line);
private:
 
   static Test *Start;
   static Test *End;
 };
 
 } // namespace testing
 } // namespace __llvm_libc
 
-#define TEST(SuiteName, TestName)                                              \
-  class SuiteName##_##TestName : public __llvm_libc::testing::Test {           \
+#define TEST_WITH_BASE_CLASS(SuiteName, TestName, BaseClass)                   \
+  class SuiteName##_##TestName : public BaseClass {                            \
   public:                                                                      \
     SuiteName##_##TestName() { addTest(this); }                                \
     void Run(__llvm_libc::testing::RunContext &) override;                     \
     const char *getName() const override { return #SuiteName "." #TestName; }  \
   };                                                                           \
   SuiteName##_##TestName SuiteName##_##TestName##_Instance;                    \
   void SuiteName##_##TestName::Run(__llvm_libc::testing::RunContext &Ctx)
 
+#define TEST(SuiteName, TestName)                                              \
+  TEST_WITH_BASE_CLASS(SuiteName, TestName, __llvm_libc::testing::Test)
 #define TEST_F(SuiteClass, TestName)                                           \
-  class SuiteClass##_##TestName : public SuiteClass {                          \
-  public:                                                                      \
-    SuiteClass##_##TestName() { addTest(this); }                               \
-    void Run(__llvm_libc::testing::RunContext &) override;                     \
-    const char *getName() const override { return #SuiteClass "." #TestName; } \
-  };                                                                           \
-  SuiteClass##_##TestName SuiteClass##_##TestName##_Instance;                  \
-  void SuiteClass##_##TestName::Run(__llvm_libc::testing::RunContext &Ctx)
+  TEST_WITH_BASE_CLASS(SuiteClass, TestName, SuiteClass)
 
 #define EXPECT_EQ(LHS, RHS)                                                    \
   __llvm_libc::testing::Test::test(Ctx, __llvm_libc::testing::Cond_EQ, (LHS),  \
                                    (RHS), #LHS, #RHS, __FILE__, __LINE__)
 #define ASSERT_EQ(LHS, RHS)                                                    \
   if (!EXPECT_EQ(LHS, RHS))                                                    \
   return
 
#define ASSERT_TRUE(VAL)                                                       \
   return
 
 #define EXPECT_FALSE(VAL) EXPECT_EQ((VAL), false)
 
 #define ASSERT_FALSE(VAL)                                                      \
   if (!EXPECT_FALSE(VAL))                                                      \
   return
 
+#define TEST_EXTENSION(LHS, RHS)                                               \
+  __llvm_libc::testing::Test::test(Ctx, __llvm_libc::testing::Cond_Extension,  \
+                                   (LHS), (RHS), #LHS, #RHS, __FILE__,         \
+                                   __LINE__)
+
 #define EXPECT_EXITS(FUNC, EXIT)                                               \
   __llvm_libc::testing::Test::testProcessExits(                                \
       Ctx, __llvm_libc::testing::Test::createCallable(FUNC), EXIT, #FUNC,      \
       #EXIT, __FILE__, __LINE__)
 
 #define ASSERT_EXITS(FUNC, EXIT)                                               \
   if (!EXPECT_EXITS(FUNC, EXIT))                                               \
   return

libc/utils/UnitTest/Test.cpp

case Cond_GE:
 
     Ctx.markFail();
     llvm::outs() << File << ":" << Line << ": FAILURE\n"
                  << "                      Expected: " << LHSStr << '\n'
                  << "                      Which is: " << LHS << '\n'
                  << "To be greater than or equal to: " << RHSStr << '\n'
                  << "                      Which is: " << RHS << '\n';
     return false;
+  case Cond_Extension:
+    if (LHS == RHS)
+      return true;
+    // Silently mark the check as a failure. The extension system is expected to
+    // report appropriate information.
+    Ctx.markFail();
+    llvm::outs() << File << ":" << Line << ": FAILURE\n";
+    return false;
   default:
     Ctx.markFail();
     llvm::outs() << "Unexpected test condition.\n";
     return false;
   }
 }
 
 } // namespace internal