[libc] Add a testing macro for MPFR matchers skipping `explainError` calls.

[lntue]

Summary

Adding EXPECT_MPFR_MATCH_ROUNDING_SILENTLY macro that does not call
explainError when the tests fail. This is useful to check the passing or
failing rates, such as hitting percentages of fast passes in math
implementations.

[lntue]

Run clang-format.

[michaelrj]

LGTM

libc/utils/MPFRWrapper/MPFRUtils.h

void explain_binary_operation_one_output_error(
     Operation op, const BinaryInput<T> &input, T match_value,
     double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS);
 
 template <typename T>
 void explain_ternary_operation_one_output_error(
     Operation op, const TernaryInput<T> &input, T match_value,
     double ulp_tolerance, RoundingMode rounding, testutils::StreamWrapper &OS);
 
-template <Operation op, typename InputType, typename OutputType>
+template <Operation op, bool silent, typename InputType, typename OutputType>
 class MPFRMatcher : public testing::Matcher<OutputType> {
   InputType input;
   OutputType match_value;
   double ulp_tolerance;
   RoundingMode rounding;
 
 public:
   MPFRMatcher(InputType testInput, double ulp_tolerance, RoundingMode rounding)
       : input(testInput), ulp_tolerance(ulp_tolerance), rounding(rounding) {}
 
   bool match(OutputType libcResult) {
     match_value = libcResult;
     return match(input, match_value);
   }
 
   // This method is marked with NOLINT because it the name `explainError`
   // does not confirm to the coding style.
   void explainError(testutils::StreamWrapper &OS) override { // NOLINT
     explain_error(input, match_value, OS);
   }
 
+  // Whether the `explainError` step is skipped or not.
+  bool is_silent() const override { return silent; }
+
 private:
   template <typename T> bool match(T in, T out) {
     return compare_unary_operation_single_output(op, in, out, ulp_tolerance,
                                                  rounding);
   }
 
   template <typename T> bool match(T in, const BinaryOutput<T> &out) {
     return compare_unary_operation_two_outputs(op, in, out, ulp_tolerance,
return (Operation::BeginUnaryOperationsSingleOutput < op &&
                                                           OutputType>::VALUE) ||
          (Operation::BeginTernaryOperationsSingleOuput < op &&
           op < Operation::EndTernaryOperationsSingleOutput &&
           cpp::is_floating_point_v<OutputType> &&
           cpp::is_same_v<InputType, TernaryInput<OutputType>>);
 }
 
 template <Operation op, typename InputType, typename OutputType>
-__attribute__((no_sanitize("address")))
-cpp::enable_if_t<is_valid_operation<op, InputType, OutputType>(),
-                 internal::MPFRMatcher<op, InputType, OutputType>>
+__attribute__((no_sanitize("address"))) cpp::enable_if_t<
+    is_valid_operation<op, InputType, OutputType>(),
+    internal::MPFRMatcher<op, /*is_silent*/ false, InputType, OutputType>>
 get_mpfr_matcher(InputType input, OutputType output_unused,
                  double ulp_tolerance, RoundingMode rounding) {
-  return internal::MPFRMatcher<op, InputType, OutputType>(input, ulp_tolerance,
-                                                          rounding);
+  return internal::MPFRMatcher<op, /*is_silent*/ false, InputType, OutputType>(
+      input, ulp_tolerance, rounding);
+}
+
+template <Operation op, typename InputType, typename OutputType>
+__attribute__((no_sanitize("address"))) cpp::enable_if_t<
+    is_valid_operation<op, InputType, OutputType>(),
+    internal::MPFRMatcher<op, /*is_silent*/ true, InputType, OutputType>>
+get_silent_mpfr_matcher(InputType input, OutputType output_unused,
+                        double ulp_tolerance, RoundingMode rounding) {
+  return internal::MPFRMatcher<op, /*is_silent*/ true, InputType, OutputType>(
+      input, ulp_tolerance, rounding);
 }
 
 template <typename T> T round(T x, RoundingMode mode);
 
 template <typename T> bool round_to_long(T x, long &result);
 template <typename T> bool round_to_long(T x, RoundingMode mode, long &result);
 
 } // namespace mpfr
#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 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,      \
                                    rounding)                                   \

libc/utils/UnitTest/LibcTest.h

 
 } // namespace internal
 
 struct MatcherBase {
   virtual ~MatcherBase() {}
   virtual void explainError(testutils::StreamWrapper &OS) {
     OS << "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 {
 private:
protected:
   template <typename ValType,
             cpp::enable_if_t<cpp::is_pointer_v<ValType>, ValType> = nullptr>
   bool test(TestCondition Cond, ValType LHS, ValType RHS, const char *LHSStr,
             const char *RHSStr, const char *File, unsigned long Line) {
     return internal::test(Ctx, Cond, (unsigned long long)LHS,
                           (unsigned long long)RHS, LHSStr, RHSStr, File, Line);
   }
 
-  template <typename ValType,
-            cpp::enable_if_t<
-                cpp::is_same_v<ValType, __llvm_libc::cpp::string_view>, int> = 0>
+  template <
+      typename ValType,
+      cpp::enable_if_t<cpp::is_same_v<ValType, __llvm_libc::cpp::string_view>,
+                       int> = 0>
   bool test(TestCondition Cond, ValType LHS, ValType RHS, const char *LHSStr,
             const char *RHSStr, const char *File, unsigned long Line) {
     return internal::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
   }
 
   bool testStrEq(const char *LHS, const char *RHS, const char *LHSStr,
                  const char *RHSStr, const char *File, unsigned long Line);
 

libc/utils/UnitTest/LibcTest.cpp

template bool test<__uint128_t>(RunContext *Ctx, TestCondition Cond,
                                 const char *File, unsigned long Line);
 #endif
 
 template bool test<__llvm_libc::cpp::UInt<128>>(
     RunContext *Ctx, TestCondition Cond, __llvm_libc::cpp::UInt<128> LHS,
     __llvm_libc::cpp::UInt<128> RHS, const char *LHSStr, const char *RHSStr,
     const char *File, unsigned long Line);
 
-template bool test<__llvm_libc::cpp::string_view>(RunContext *Ctx, TestCondition Cond,
-                                       __llvm_libc::cpp::string_view LHS,
-                                       __llvm_libc::cpp::string_view RHS,
-                                       const char *LHSStr, const char *RHSStr,
-                                       const char *File, unsigned long Line);
+template bool test<__llvm_libc::cpp::string_view>(
+    RunContext *Ctx, TestCondition Cond, __llvm_libc::cpp::string_view LHS,
+    __llvm_libc::cpp::string_view RHS, const char *LHSStr, const char *RHSStr,
 
 } // namespace internal
 
 bool Test::testStrEq(const char *LHS, const char *RHS, const char *LHSStr,
                      const char *RHSStr, const char *File, unsigned long Line) {
   return internal::test(Ctx, Cond_EQ, LHS ? std::string(LHS) : std::string(),
                         RHS ? std::string(RHS) : std::string(), LHSStr, RHSStr,
                         File, Line);
 }
 
 bool Test::testStrNe(const char *LHS, const char *RHS, const char *LHSStr,
                      const char *RHSStr, const char *File, unsigned long Line) {
   return internal::test(Ctx, Cond_NE, LHS ? std::string(LHS) : std::string(),
                         RHS ? std::string(RHS) : std::string(), LHSStr, RHSStr,
                         File, Line);
 }
 
 bool Test::testMatch(bool MatchResult, MatcherBase &Matcher, const char *LHSStr,
                      const char *RHSStr, const char *File, unsigned long Line) {
   if (MatchResult)
     return true;
 
   Ctx->markFail();
+  if (!Matcher.is_silent()) {
     std::cout << File << ":" << Line << ": FAILURE\n"
               << "Failed to match " << LHSStr << " against " << RHSStr << ".\n";
     testutils::StreamWrapper OutsWrapper = testutils::outs();
     Matcher.explainError(OutsWrapper);
+  }
   return false;
 }
 
 #ifdef ENABLE_SUBPROCESS_TESTS
 
 bool Test::testProcessKilled(testutils::FunctionCaller *Func, int Signal,
                              const char *LHSStr, const char *RHSStr,
                              const char *File, unsigned long Line) {