[libc] Add testing macros for errno and floating point exceptions.

[lntue]

Summary

Add testing macros for errno and floating point exceptions.

[michaelrj]

libc/utils/UnitTest/FPMatcher.h

104

why is the do/while(0) necessary?

[sivachandra]

Thanks for doing this. Please answer or fix per @michaelrj's comment.

[lntue]

libc/utils/UnitTest/FPMatcher.h

104

just to safely wrap the if statement and allow it to be used with ; at the end like EXPECT_MATH_ERRNO(value);

libc/test/src/math/RoundToIntegerTest.h

 //===-- Utility class to test different flavors of [l|ll]round --*- 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_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H
 #define LLVM_LIBC_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H
 
+#include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/FPMatcher.h"
 #include "utils/UnitTest/Test.h"
 
-#include <math.h>
-#if math_errhandling & MATH_ERRNO
 #include <errno.h>
-#endif
-#if math_errhandling & MATH_ERREXCEPT
-#include "src/__support/FPUtil/FEnvImpl.h"
-#endif
+#include <math.h>
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 static constexpr int ROUNDING_MODES[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
                                           FE_TONEAREST};
 
 template <typename F, typename I, bool TestModes = false>
 class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
private:
   const F inf = F(__llvm_libc::fputil::FPBits<F>::inf());
   const F neg_inf = F(__llvm_libc::fputil::FPBits<F>::neg_inf());
   const F nan = F(__llvm_libc::fputil::FPBits<F>::build_nan(1));
   static constexpr I INTEGER_MIN = I(1) << (sizeof(I) * 8 - 1);
   static constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
 
   void test_one_input(RoundToIntegerFunc func, F input, I expected,
                       bool expectError) {
-#if math_errhandling & MATH_ERRNO
     errno = 0;
-#endif
-#if math_errhandling & MATH_ERREXCEPT
     __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
-#endif
 
     ASSERT_EQ(func(input), expected);
 
     if (expectError) {
-#if math_errhandling & MATH_ERREXCEPT
-      ASSERT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT), FE_INVALID);
-#endif
-#if math_errhandling & MATH_ERRNO
-      ASSERT_EQ(errno, EDOM);
-#endif
+      ASSERT_FP_EXCEPTION(FE_INVALID);
+      ASSERT_MATH_ERRNO(EDOM);
     } else {
-#if math_errhandling & MATH_ERREXCEPT
-      ASSERT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT), 0);
-#endif
-#if math_errhandling & MATH_ERRNO
-      ASSERT_EQ(errno, 0);
-#endif
+      ASSERT_FP_EXCEPTION(0);
+      ASSERT_MATH_ERRNO(0);
     }
   }
 
   static inline mpfr::RoundingMode to_mpfr_rounding_mode(int mode) {
     switch (mode) {
     case FE_UPWARD:
       return mpfr::RoundingMode::Upward;
     case FE_DOWNWARD:

libc/test/src/math/cosf_test.cpp

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(LlvmLibcCosfTest, SpecialNumbers) {
   errno = 0;
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(aNaN));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::cosf(0.0f));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::cosf(-0.0f));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
-  errno = 0;
   EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(inf));
-  EXPECT_EQ(errno, EDOM);
+  EXPECT_MATH_ERRNO(EDOM);
 
-  errno = 0;
   EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(neg_inf));
-  EXPECT_EQ(errno, EDOM);
+  EXPECT_MATH_ERRNO(EDOM);
 }
 
 TEST(LlvmLibcCosfTest, 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 = float(FPBits(v));
     if (isnan(x) || isinf(x))

libc/test/src/math/exp2f_test.cpp

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(LlvmLibcExp2fTest, SpecialNumbers) {
   errno = 0;
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::exp2f(aNaN));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(inf, __llvm_libc::exp2f(inf));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(0.0f, __llvm_libc::exp2f(neg_inf));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(0.0f));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(-0.0f));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExpfTest, Overflow) {
   errno = 0;
   EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x7f7fffffU))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x43000000U))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x43000001U))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 }
 
 // Test with inputs which are the borders of underflow/overflow but still
 // produce valid results without setting errno.
 TEST(LlvmLibcExpfTest, Borderline) {
   float x;
 
   errno = 0;
   x = float(FPBits(0x42fa0001U));
   EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0x42ffffffU));
   EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0xc2fa0001U));
   EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0xc2fc0000U));
   EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0xc2fc0001U));
   EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0xc3150000U));
   EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExpfTest, Underflow) {
   errno = 0;
   EXPECT_FP_EQ(0.0f, __llvm_libc::exp2f(float(FPBits(0xff7fffffU))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   float x = float(FPBits(0xc3158000U));
   EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0);
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   x = float(FPBits(0xc3165432U));
   EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0);
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 }
 
 TEST(LlvmLibcexp2fTest, 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 = float(FPBits(v));
     if (isnan(x) || isinf(x))

libc/test/src/math/expf_test.cpp

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(LlvmLibcExpfTest, SpecialNumbers) {
   errno = 0;
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::expf(aNaN));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(inf, __llvm_libc::expf(inf));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(0.0f, __llvm_libc::expf(neg_inf));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::expf(0.0f));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::expf(-0.0f));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExpfTest, Overflow) {
   errno = 0;
   EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPBits(0x7f7fffffU))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPBits(0x42cffff8U))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   EXPECT_FP_EQ(inf, __llvm_libc::expf(float(FPBits(0x42d00008U))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 }
 
 TEST(LlvmLibcExpfTest, Underflow) {
   errno = 0;
   EXPECT_FP_EQ(0.0f, __llvm_libc::expf(float(FPBits(0xff7fffffU))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   float x = float(FPBits(0xc2cffff8U));
   EXPECT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), 1.0);
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   x = float(FPBits(0xc2d00008U));
   EXPECT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), 1.0);
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 }
 
 // Test with inputs which are the borders of underflow/overflow but still
 // produce valid results without setting errno.
 TEST(LlvmLibcExpfTest, Borderline) {
   float x;
 
   errno = 0;
   x = float(FPBits(0x42affff8U));
   ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0x42b00008U));
   ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0xc2affff8U));
   ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0xc2b00008U));
   ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExpfTest, 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 = float(FPBits(v));
     if (isnan(x) || isinf(x))

libc/test/src/math/expm1f_test.cpp

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(LlvmLibcExpm1fTest, SpecialNumbers) {
   errno = 0;
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::expm1f(aNaN));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(inf, __llvm_libc::expm1f(inf));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(neg_inf));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(0.0f, __llvm_libc::expm1f(0.0f));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(-0.0f, __llvm_libc::expm1f(-0.0f));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExpm1fTest, Overflow) {
   errno = 0;
   EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPBits(0x7f7fffffU))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPBits(0x42cffff8U))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   EXPECT_FP_EQ(inf, __llvm_libc::expm1f(float(FPBits(0x42d00008U))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 }
 
 TEST(LlvmLibcExpm1fTest, Underflow) {
   errno = 0;
   EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(float(FPBits(0xff7fffffU))));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   float x = float(FPBits(0xc2cffff8U));
   EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(x));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 
-  errno = 0;
   x = float(FPBits(0xc2d00008U));
   EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(x));
-  EXPECT_EQ(errno, ERANGE);
+  EXPECT_MATH_ERRNO(ERANGE);
 }
 
 // Test with inputs which are the borders of underflow/overflow but still
 // produce valid results without setting errno.
 TEST(LlvmLibcExpm1fTest, Borderline) {
   float x;
 
   errno = 0;
   x = float(FPBits(0x42affff8U));
   ASSERT_MPFR_MATCH(mpfr::Operation::Expm1, x, __llvm_libc::expm1f(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0x42b00008U));
   ASSERT_MPFR_MATCH(mpfr::Operation::Expm1, x, __llvm_libc::expm1f(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0xc2affff8U));
   ASSERT_MPFR_MATCH(mpfr::Operation::Expm1, x, __llvm_libc::expm1f(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   x = float(FPBits(0xc2b00008U));
   ASSERT_MPFR_MATCH(mpfr::Operation::Expm1, x, __llvm_libc::expm1f(x), 1.0);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExpm1fTest, 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 = float(FPBits(v));
     if (isnan(x) || isinf(x))

libc/test/src/math/sincosf_test.cpp

 
 TEST(LlvmLibcSinCosfTest, SpecialNumbers) {
   errno = 0;
   float sin, cos;
 
   __llvm_libc::sincosf(aNaN, &sin, &cos);
   EXPECT_FP_EQ(aNaN, cos);
   EXPECT_FP_EQ(aNaN, sin);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   __llvm_libc::sincosf(0.0f, &sin, &cos);
   EXPECT_FP_EQ(1.0f, cos);
   EXPECT_FP_EQ(0.0f, sin);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   __llvm_libc::sincosf(-0.0f, &sin, &cos);
   EXPECT_FP_EQ(1.0f, cos);
   EXPECT_FP_EQ(-0.0f, sin);
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
-  errno = 0;
   __llvm_libc::sincosf(inf, &sin, &cos);
   EXPECT_FP_EQ(aNaN, cos);
   EXPECT_FP_EQ(aNaN, sin);
-  EXPECT_EQ(errno, EDOM);
+  EXPECT_MATH_ERRNO(EDOM);
 
-  errno = 0;
   __llvm_libc::sincosf(neg_inf, &sin, &cos);
   EXPECT_FP_EQ(aNaN, cos);
   EXPECT_FP_EQ(aNaN, sin);
-  EXPECT_EQ(errno, EDOM);
+  EXPECT_MATH_ERRNO(EDOM);
 }
 
 TEST(LlvmLibcSinCosfTest, 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 = float(FPBits((v)));
     if (isnan(x) || isinf(x))

libc/test/src/math/sinf_test.cpp

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(LlvmLibcSinfTest, SpecialNumbers) {
   errno = 0;
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(aNaN));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(0.0f, __llvm_libc::sinf(0.0f));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(-0.0f, __llvm_libc::sinf(-0.0f));
-  EXPECT_EQ(errno, 0);
+  EXPECT_MATH_ERRNO(0);
 
-  errno = 0;
   EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(inf));
-  EXPECT_EQ(errno, EDOM);
+  EXPECT_MATH_ERRNO(EDOM);
 
-  errno = 0;
   EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(neg_inf));
-  EXPECT_EQ(errno, EDOM);
+  EXPECT_MATH_ERRNO(EDOM);
 }
 
 TEST(LlvmLibcSinfTest, 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 = float(FPBits(v));
     if (isnan(x) || isinf(x))

libc/utils/UnitTest/FPMatcher.h

 //===-- TestMatchers.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_UNITTEST_FPMATCHER_H
 #define LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H
 
+#include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
-
 #include "utils/UnitTest/Test.h"
 
+#include <errno.h>
+#include <math.h>
+
 namespace __llvm_libc {
 namespace fputil {
 namespace testing {
 
 template <typename ValType, typename StreamType>
 cpp::EnableIfType<cpp::IsFloatingPointType<ValType>::Value, void>
 describeValue(const char *label, ValType value, StreamType &stream);
 
EXPECT_THAT(                                                                 \
           expected))
 
 #define ASSERT_FP_NE(expected, actual)                                         \
   ASSERT_THAT(                                                                 \
       actual,                                                                  \
       __llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_NE>( \
           expected))
 
+#define EXPECT_MATH_ERRNO(expected)                                            \
+  do {                                                                         \
+    if (math_errhandling & MATH_ERRNO) {                                       \
+      int actual = errno;                                                      \
+      errno = 0;                                                               \
+      EXPECT_EQ(actual, expected);                                             \
+    }                                                                          \
+  } while (0)
+
+#define ASSERT_MATH_ERRNO(expected)                                            \
+  do {                                                                         \
+    if (math_errhandling & MATH_ERRNO) {                                       \
+      int actual = errno;                                                      \
+      errno = 0;                                                               \
+      ASSERT_EQ(actual, expected);                                             \
+    }                                                                          \
+  } while (0)
+
+#define EXPECT_FP_EXCEPTION(expected)                                          \
+  do {                                                                         \
+    if (math_errhandling & MATH_ERREXCEPT) {                                   \
+      EXPECT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT), expected);    \
+    }                                                                          \
+  } while (0)
+
+#define ASSERT_FP_EXCEPTION(expected)                                          \
+  do {                                                                         \
+    if (math_errhandling & MATH_ERREXCEPT) {                                   \
+      ASSERT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT), expected);    \
+    }                                                                          \
+  } while (0)
+
 #endif // LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H