[libc][NFC] Use a convenience macro to declare special floating point constants.

[sivachandra]

This patch only touches the remquo related tests. After it lands, I can change other tests also in an obvious follow up commit.

libc/test/src/math/remquo_test.cpp

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 using UIntType = FPBits::UIntType;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
-static const double zero = FPBits::zero();
-static const double negZero = FPBits::negZero();
-static const double nan = FPBits::buildNaN(1);
-static const double inf = FPBits::inf();
-static const double negInf = FPBits::negInf();
+DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(RemquoTest, SpecialNumbers) {
   int exponent;
   double x, y;
 
   y = 1.0;
   x = inf;
   EXPECT_NE(isnan(__llvm_libc::remquo(x, y, &exponent)), 0);

libc/test/src/math/remquof_test.cpp

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 using UIntType = FPBits::UIntType;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
-static const float zero = FPBits::zero();
-static const float negZero = FPBits::negZero();
-static const float nan = FPBits::buildNaN(1);
-static const float inf = FPBits::inf();
-static const float negInf = FPBits::negInf();
+DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(RemquofTest, SpecialNumbers) {
   int exponent;
   float x, y;
 
   y = 1.0f;
   x = inf;
   EXPECT_NE(isnan(__llvm_libc::remquof(x, y, &exponent)), 0);

libc/test/src/math/remquol_test.cpp

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 using UIntType = FPBits::UIntType;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
-static const long double zero = FPBits::zero();
-static const long double negZero = FPBits::negZero();
-static const long double nan = FPBits::buildNaN(1);
-static const long double inf = FPBits::inf();
-static const long double negInf = FPBits::negInf();
+DECLARE_SPECIAL_CONSTANTS(long double)
 
-TEST(RemquoTest, SpecialNumbers) {
+TEST(RemquolTest, SpecialNumbers) {
   int exponent;
   long double x, y;
 
   y = 1.0l;
   x = inf;
   EXPECT_NE(isnan(__llvm_libc::remquol(x, y, &exponent)), 0);
   x = negInf;
   EXPECT_NE(isnan(__llvm_libc::remquol(x, y, &exponent)), 0);
TEST(RemquolTest, SpecialNumbers) {
   y = 1.0l;
   EXPECT_FP_EQ(__llvm_libc::remquol(x, y, &exponent), zero);
 
   x = negZero;
   y = 1.0l;
   EXPECT_FP_EQ(__llvm_libc::remquol(x, y, &exponent), negZero);
 }
 
-TEST(RemquofTest, SubnormalRange) {
+TEST(RemquolTest, SubnormalRange) {
   constexpr UIntType count = 1000001;
   constexpr UIntType step =
       (FPBits::maxSubnormal - FPBits::minSubnormal) / count;
   for (UIntType v = FPBits::minSubnormal, w = FPBits::maxSubnormal;
        v <= FPBits::maxSubnormal && w >= FPBits::minSubnormal;
        v += step, w -= step) {
     long double x = FPBits(v), y = FPBits(w);
     mpfr::BinaryOutput<long double> result;
     mpfr::BinaryInput<long double> input{x, y};
     result.f = __llvm_libc::remquol(x, y, &result.i);
     ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
   }
 }
 
-TEST(RemquofTest, NormalRange) {
+TEST(RemquolTest, NormalRange) {
   constexpr UIntType count = 1000001;
   constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
   for (UIntType v = FPBits::minNormal, w = FPBits::maxNormal;
        v <= FPBits::maxNormal && w >= FPBits::minNormal; v += step, w -= step) {
     long double x = FPBits(v), y = FPBits(w);
     mpfr::BinaryOutput<long double> result;
     result.f = __llvm_libc::remquol(x, y, &result.i);
     // In normal range on x86 platforms, the implicit 1 bit can be zero making

libc/utils/FPUtil/TestHelpers.h

 FPMatcher<T, C> getMatcher(T expectedValue) {
   return FPMatcher<T, C>(expectedValue);
 }
 
 } // namespace testing
 } // namespace fputil
 } // namespace __llvm_libc
 
+#define DECLARE_SPECIAL_CONSTANTS(T)                                           \
+  static const T zero = __llvm_libc::fputil::FPBits<T>::zero();                \
+  static const T negZero = __llvm_libc::fputil::FPBits<T>::negZero();          \
+  static const T nan = __llvm_libc::fputil::FPBits<T>::buildNaN(1);            \
+  static const T inf = __llvm_libc::fputil::FPBits<T>::inf();                  \
+  static const T negInf = __llvm_libc::fputil::FPBits<T>::negInf();
+
 #define EXPECT_FP_EQ(expected, actual)                                         \
   EXPECT_THAT(                                                                 \
       actual,                                                                  \
       __llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_EQ>( \
           expected))
 
 #define ASSERT_FP_EQ(expected, actual)                                         \
   ASSERT_THAT(                                                                 \