[libc] Let exhaustive tests indicate each interval PASSED/FAILED.

[lntue]

Summary

Let exhaustive tests indicate each interval PASSED/FAILED.

[sivachandra]

libc/test/src/math/exhaustive/exhaustive_test.h

25

Since its a bool value, would it better as a return value instead of reference argument?

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

31

If you use EXPECT_<...> macro as opposed to ASSERT_<...> macro, wouldn't result always get set to true?

[lntue]

Let EXPECT_THAT return boolean results.

[lntue]

libc/test/src/math/exhaustive/exhaustive_test.h

25

Updated to return to bool value.

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

31

Fixed EXPECT_<...> macros to return bool values.

[sivachandra]

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

31

This pattern seems to have a logic flaw. For example, since we use an EXPECT_<> macro, a following success/failure can overwrite the previous failure/success. You probably want result &&= <...> on line 28?

libc/utils/UnitTest/LibcTest.h

401

To math the pattern of other ASSERT_<> macros, can we construct ASSERT_THAT using EXPECT_THAT?

[lntue]

Address comments.

[lntue]

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

31

Good catch!

libc/utils/UnitTest/LibcTest.h

401

Look like we need to have another patch to wrap other ASSERT_<> in do { ... } while (0) to make it not stealing else clause if being used inside other if statement.

[lntue]

Sync.

[sivachandra]

libc/utils/UnitTest/LibcTest.h

401

They are not compound statements so shouldn't require a do {...} while (0) treatment?

[lntue]

libc/utils/UnitTest/LibcTest.h

401

What I'm thinking is in the case that we have something like:

if (cond)
  ASSERT_<>(...);
else
  ASSERT_<>(...);

then without the do { ... } while (0) treatment, it will silently do the wrong branching due to the else is stolen from the first ASSERT.
Maybe we should not have that pattern but it might be inevitable sometime.

libc/test/src/math/exhaustive/exhaustive_test.h

 
 template <typename T>
 struct LlvmLibcExhaustiveTest : public __llvm_libc::testing::Test {
   // Break [start, stop) into `nthreads` subintervals and apply *check to each
   // subinterval in parallel.
   void test_full_range(T start, T stop, int nthreads,
                        mpfr::RoundingMode rounding);
 
-  virtual void check(T start, T stop, mpfr::RoundingMode rounding,
-                     bool &result) = 0;
+  virtual bool check(T start, T stop, mpfr::RoundingMode rounding) = 0;
 };

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

void LlvmLibcExhaustiveTest<T>::test_full_range(T start, T stop, int nthreads,
   for (int i = 0; i < nthreads; ++i) {
     thread_list.emplace_back([this, begin, end, rounding]() {
       std::stringstream msg;
       msg << "-- Testing from " << begin << " to " << end << " [0x" << std::hex
           << begin << ", 0x" << end << ") ..." << std::endl;
       std::cout << msg.str();
       msg.str("");
 
-      bool result;
-      check(begin, end, rounding, result);
+      bool result = check(begin, end, rounding);
 
       msg << "** Finished testing from " << std::dec << begin << " to " << end
           << " [0x" << std::hex << begin << ", 0x" << end
           << ") : " << (result ? "PASSED" : "FAILED") << std::endl;
       std::cout << msg.str();
     });
     begin += increment;
     end += increment;

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

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 struct LlvmLibcExp2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
-  void check(uint32_t start, uint32_t stop,
+  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);
-      EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 0.5,
-                        rounding);
+      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x,
+                                  __llvm_libc::exp2f(x), 0.5, rounding);
     } while (bits++ < stop);
+    return result;
   }
 };
 
 static constexpr int NUM_THREADS = 16;
 
 // Range: [0, 128];
 static constexpr uint32_t POS_START = 0x0000'0000U;
 static constexpr uint32_t POS_STOP = 0x4300'0000U;

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

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 struct LlvmLibcExpfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
-  void check(uint32_t start, uint32_t stop,
+  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);
-      EXPECT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), 0.5,
-                        rounding);
+      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
+                                  0.5, rounding);
     } while (bits++ < stop);
+    return result;
   }
 };
 
 static constexpr int NUM_THREADS = 16;
 
 // 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

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 struct LlvmLibcExpfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
-  void check(uint32_t start, uint32_t stop, mpfr::RoundingMode rounding,
-             bool &result) override {
+  bool check(uint32_t start, uint32_t stop,
+             mpfr::RoundingMode rounding) override {
     mpfr::ForceRoundingMode r(rounding);
     uint32_t bits = start;
-    result = false;
+    bool result = true;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-      EXPECT_MPFR_MATCH(mpfr::Operation::Expm1, x, __llvm_libc::expm1f(x), 0.5,
-                        rounding);
+      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Expm1, x,
+                                  __llvm_libc::expm1f(x), 0.5, rounding);
     } while (bits++ < stop);
-    result = true;
   }
 };
 
 static constexpr int NUM_THREADS = 16;
 
 // 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

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 struct LlvmLibcHypotfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
-  void check(uint32_t start, uint32_t stop,
+  bool check(uint32_t start, uint32_t stop,
              mpfr::RoundingMode rounding) override {
     // Range of the second input: [2^37, 2^48).
     constexpr uint32_t Y_START = (37U + 127U) << 23;
     constexpr uint32_t Y_STOP = (48U + 127U) << 23;
 
     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));
-        EXPECT_FP_EQ(__llvm_libc::fputil::hypot(x, y),
+        result &= EXPECT_FP_EQ(__llvm_libc::fputil::hypot(x, y),
                                __llvm_libc::hypotf(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;
   }
 };
 
 // Range of the first input: [2^23, 2^24);
 static constexpr uint32_t START = (23U + 127U) << 23;
 static constexpr uint32_t STOP = ((23U + 127U) << 23) + 1;
 static constexpr int NUM_THREADS = 1;
 

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

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 struct LlvmLibcLog10fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
-  void check(uint32_t start, uint32_t stop,
+  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);
-      EXPECT_MPFR_MATCH(mpfr::Operation::Log10, x, __llvm_libc::log10f(x), 0.5,
-                        rounding);
+      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log10, x,
+                                  __llvm_libc::log10f(x), 0.5, rounding);
     } while (bits++ < stop);
+    return result;
   }
 };
 
 // Range: All non-negative;
 static constexpr uint32_t START = 0x0000'0000U;
 static constexpr uint32_t STOP = 0x7f80'0000U;
 // Range: [1, 10];
 // static constexpr uint32_t START = 0x3f80'0000U;

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

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 struct LlvmLibclog1pfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
-  void check(uint32_t start, uint32_t stop,
+  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);
-      EXPECT_MPFR_MATCH(mpfr::Operation::Log1p, x, __llvm_libc::log1pf(x), 0.5,
-                        rounding);
+      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log1p, x,
+                                  __llvm_libc::log1pf(x), 0.5, rounding);
     } while (bits++ < stop);
+    return result;
   }
 };
 
 // Range: All non-negative;
 static constexpr uint32_t START = 0x0000'0000U;
 static constexpr uint32_t STOP = 0x7f80'0000U;
 // Range: [-1, 0];
 // static constexpr uint32_t START = 0x8000'0000U;

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

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 struct LlvmLibcLog2fExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
-  void check(uint32_t start, uint32_t stop,
+  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);
-      EXPECT_MPFR_MATCH(mpfr::Operation::Log2, x, __llvm_libc::log2f(x), 0.5,
-                        rounding);
+      result &= EXPECT_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, /*nthreads=*/16,
                   mpfr::RoundingMode::Nearest);
 }
 

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

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 struct LlvmLibcLogfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
-  void check(uint32_t start, uint32_t stop,
+  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);
-      EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), 0.5,
-                        rounding);
+      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x),
+                                  0.5, rounding);
     } while (bits++ < stop);
+    return result;
   }
 };
 
 TEST_F(LlvmLibcLogfExhaustiveTest, RoundNearestTieToEven) {
   test_full_range(/*start=*/0U, /*stop=*/0x7f80'0000U, /*nthreads=*/16,
                   mpfr::RoundingMode::Nearest);
 }
 

libc/utils/UnitTest/LibcTest.h

 
 #endif // ENABLE_SUBPROCESS_TESTS
 
 #define __CAT1(a, b) a##b
 #define __CAT(a, b) __CAT1(a, b)
 #define UNIQUE_VAR(prefix) __CAT(prefix, __LINE__)
 
 #define EXPECT_THAT(MATCH, MATCHER)                                            \
-  do {                                                                         \
+  [&]() -> bool {                                                              \
     auto UNIQUE_VAR(__matcher) = (MATCHER);                                    \
-    this->testMatch(UNIQUE_VAR(__matcher).match((MATCH)),                      \
-                    UNIQUE_VAR(__matcher), #MATCH, #MATCHER, __FILE__,         \
-                    __LINE__);                                                 \
-  } while (0)
+    return this->testMatch(UNIQUE_VAR(__matcher).match((MATCH)),               \
+                           UNIQUE_VAR(__matcher), #MATCH, #MATCHER, __FILE__,  \
+                           __LINE__);                                          \
+  }()
 
 #define ASSERT_THAT(MATCH, MATCHER)                                            \
   do {                                                                         \
-    auto UNIQUE_VAR(__matcher) = (MATCHER);                                    \
-    if (!this->testMatch(UNIQUE_VAR(__matcher).match((MATCH)),                 \
-                         UNIQUE_VAR(__matcher), #MATCH, #MATCHER, __FILE__,    \
-                         __LINE__))                                            \
+    if (!EXPECT_THAT(MATCH, MATCHER))                                          \
       return;                                                                  \
   } while (0)
 
 #define WITH_SIGNAL(X) X
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_LIBCTEST_H