From db936e0e915377a58032dccc13bedbfccf0a1ca8 Mon Sep 17 00:00:00 2001
From: Siva Chandra Reddy <sivachandra@google.com>
Date: Thu, 6 Aug 2020 00:19:08 -0700
Subject: [libc][NFC] Add library of floating point test matchers.

This eliminates UnitTest's dependency on FPUtil and hence prevents
non-math tests from depending indirectly on FPUtil. The patch
essentially moves some of the existing pieces into a library of its own.

Along the way, renamed add_math_unittest to add_fp_unittest.

Reviewed By: lntue

Differential Revision: https://reviews.llvm.org/D85486
---
 libc/test/src/math/CMakeLists.txt | 83 ++++++++++++++++++++-------------------
 libc/test/src/math/fmax_test.cpp  | 45 ++++++++++-----------
 libc/test/src/math/fmaxf_test.cpp | 45 ++++++++++-----------
 libc/test/src/math/fmaxl_test.cpp | 45 ++++++++++-----------
 libc/test/src/math/fmin_test.cpp  | 45 ++++++++++-----------
 libc/test/src/math/fminf_test.cpp | 45 ++++++++++-----------
 libc/test/src/math/fminl_test.cpp | 45 ++++++++++-----------
 7 files changed, 180 insertions(+), 173 deletions(-)

(limited to 'libc/test')

diff --git a/libc/test/src/math/CMakeLists.txt b/libc/test/src/math/CMakeLists.txt
index 3bd40f6b32f1..f5a1e0e51a71 100644
--- a/libc/test/src/math/CMakeLists.txt
+++ b/libc/test/src/math/CMakeLists.txt
@@ -1,6 +1,6 @@
 add_libc_testsuite(libc_math_unittests)
 
-function(add_math_unittest name)
+function(add_fp_unittest name)
   cmake_parse_arguments(
     "MATH_UNITTEST"
     "NEED_MPFR" # No optional arguments
@@ -17,13 +17,14 @@ function(add_math_unittest name)
   endif()
 
   add_libc_unittest(${name} ${MATH_UNITTEST_UNPARSED_ARGUMENTS})
+  get_fq_target_name(${name} fq_target_name)
+  target_link_libraries(${fq_target_name} PRIVATE LibcFPTestHelpers)
   if(MATH_UNITTEST_NEED_MPFR)
-    get_fq_target_name(${name} fq_target_name)
     target_link_libraries(${fq_target_name} PRIVATE libcMPFRWrapper -lmpfr -lgmp)
   endif()
-endfunction(add_math_unittest)
+endfunction(add_fp_unittest)
 
-add_math_unittest(
+add_fp_unittest(
   cosf_test
   NEED_MPFR
   SUITE
@@ -39,7 +40,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   sinf_test
   NEED_MPFR
   SUITE
@@ -55,7 +56,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   sincosf_test
   NEED_MPFR
   SUITE
@@ -71,7 +72,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   fabs_test
   NEED_MPFR
   SUITE
@@ -84,7 +85,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   fabsf_test
   NEED_MPFR
   SUITE
@@ -97,7 +98,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   fabsl_test
   NEED_MPFR
   SUITE
@@ -110,7 +111,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   trunc_test
   NEED_MPFR
   SUITE
@@ -123,7 +124,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   truncf_test
   NEED_MPFR
   SUITE
@@ -136,7 +137,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   truncl_test
   NEED_MPFR
   SUITE
@@ -149,7 +150,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   ceil_test
   NEED_MPFR
   SUITE
@@ -162,7 +163,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   ceilf_test
   NEED_MPFR
   SUITE
@@ -175,7 +176,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   ceill_test
   NEED_MPFR
   SUITE
@@ -188,7 +189,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   floor_test
   NEED_MPFR
   SUITE
@@ -201,7 +202,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   floorf_test
   NEED_MPFR
   SUITE
@@ -214,7 +215,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   floorl_test
   NEED_MPFR
   SUITE
@@ -227,7 +228,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   round_test
   NEED_MPFR
   SUITE
@@ -240,7 +241,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   roundf_test
   NEED_MPFR
   SUITE
@@ -253,7 +254,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   roundl_test
   NEED_MPFR
   SUITE
@@ -266,7 +267,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   expf_test
   NEED_MPFR
   SUITE
@@ -280,7 +281,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   exp2f_test
   NEED_MPFR
   SUITE
@@ -294,7 +295,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   copysign_test
   SUITE
     libc_math_unittests
@@ -306,7 +307,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   copysignf_test
   SUITE
     libc_math_unittests
@@ -318,7 +319,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   copysignl_test
   SUITE
     libc_math_unittests
@@ -330,7 +331,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   frexp_test
   SUITE
     libc_math_unittests
@@ -342,7 +343,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   frexpf_test
   SUITE
     libc_math_unittests
@@ -354,7 +355,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   frexpl_test
   SUITE
     libc_math_unittests
@@ -366,7 +367,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   logb_test
   SUITE
     libc_math_unittests
@@ -378,7 +379,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   logbf_test
   SUITE
     libc_math_unittests
@@ -390,7 +391,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   logbl_test
   SUITE
     libc_math_unittests
@@ -402,7 +403,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   modf_test
   SUITE
     libc_math_unittests
@@ -414,7 +415,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   modff_test
   SUITE
     libc_math_unittests
@@ -426,7 +427,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   modfl_test
   SUITE
     libc_math_unittests
@@ -438,7 +439,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   fminf_test
   SUITE
     libc_math_unittests
@@ -450,7 +451,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   fmin_test
   SUITE
     libc_math_unittests
@@ -462,7 +463,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   fminl_test
   SUITE
     libc_math_unittests
@@ -474,7 +475,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   fmaxf_test
   SUITE
     libc_math_unittests
@@ -486,7 +487,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   fmax_test
   SUITE
     libc_math_unittests
@@ -498,7 +499,7 @@ add_math_unittest(
     libc.utils.FPUtil.fputil
 )
 
-add_math_unittest(
+add_fp_unittest(
   fmaxl_test
   SUITE
     libc_math_unittests
diff --git a/libc/test/src/math/fmax_test.cpp b/libc/test/src/math/fmax_test.cpp
index 8d1c6c276382..0dc57e4290fc 100644
--- a/libc/test/src/math/fmax_test.cpp
+++ b/libc/test/src/math/fmax_test.cpp
@@ -9,6 +9,7 @@
 #include "include/math.h"
 #include "src/math/fmax.h"
 #include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
@@ -18,36 +19,36 @@ double inf = FPBits::inf();
 double negInf = FPBits::negInf();
 
 TEST(FmaxTest, NaNArg) {
-  EXPECT_EQ(inf, __llvm_libc::fmax(nan, inf));
-  EXPECT_EQ(negInf, __llvm_libc::fmax(negInf, nan));
-  EXPECT_EQ(0.0, __llvm_libc::fmax(nan, 0.0));
-  EXPECT_EQ(-0.0, __llvm_libc::fmax(-0.0, nan));
-  EXPECT_EQ(-1.2345, __llvm_libc::fmax(nan, -1.2345));
-  EXPECT_EQ(1.2345, __llvm_libc::fmax(1.2345, nan));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmax(nan, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmax(negInf, nan));
+  EXPECT_FP_EQ(0.0, __llvm_libc::fmax(nan, 0.0));
+  EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, nan));
+  EXPECT_FP_EQ(-1.2345, __llvm_libc::fmax(nan, -1.2345));
+  EXPECT_FP_EQ(1.2345, __llvm_libc::fmax(1.2345, nan));
   EXPECT_NE(isnan(__llvm_libc::fmax(nan, nan)), 0);
 }
 
 TEST(FmaxTest, InfArg) {
-  EXPECT_EQ(inf, __llvm_libc::fmax(negInf, inf));
-  EXPECT_EQ(inf, __llvm_libc::fmax(inf, 0.0));
-  EXPECT_EQ(inf, __llvm_libc::fmax(-0.0, inf));
-  EXPECT_EQ(inf, __llvm_libc::fmax(inf, 1.2345));
-  EXPECT_EQ(inf, __llvm_libc::fmax(-1.2345, inf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmax(negInf, inf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, 0.0));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmax(-0.0, inf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, 1.2345));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmax(-1.2345, inf));
 }
 
 TEST(FmaxTest, NegInfArg) {
-  EXPECT_EQ(inf, __llvm_libc::fmax(inf, negInf));
-  EXPECT_EQ(0.0, __llvm_libc::fmax(negInf, 0.0));
-  EXPECT_EQ(-0.0, __llvm_libc::fmax(-0.0, negInf));
-  EXPECT_EQ(-1.2345, __llvm_libc::fmax(negInf, -1.2345));
-  EXPECT_EQ(1.2345, __llvm_libc::fmax(1.2345, negInf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, negInf));
+  EXPECT_FP_EQ(0.0, __llvm_libc::fmax(negInf, 0.0));
+  EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, negInf));
+  EXPECT_FP_EQ(-1.2345, __llvm_libc::fmax(negInf, -1.2345));
+  EXPECT_FP_EQ(1.2345, __llvm_libc::fmax(1.2345, negInf));
 }
 
 TEST(FmaxTest, BothZero) {
-  EXPECT_EQ(0.0, __llvm_libc::fmax(0.0, 0.0));
-  EXPECT_EQ(0.0, __llvm_libc::fmax(-0.0, 0.0));
-  EXPECT_EQ(0.0, __llvm_libc::fmax(0.0, -0.0));
-  EXPECT_EQ(-0.0, __llvm_libc::fmax(-0.0, -0.0));
+  EXPECT_FP_EQ(0.0, __llvm_libc::fmax(0.0, 0.0));
+  EXPECT_FP_EQ(0.0, __llvm_libc::fmax(-0.0, 0.0));
+  EXPECT_FP_EQ(0.0, __llvm_libc::fmax(0.0, -0.0));
+  EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, -0.0));
 }
 
 TEST(FmaxTest, InDoubleRange) {
@@ -65,9 +66,9 @@ TEST(FmaxTest, InDoubleRange) {
       continue;
 
     if (x > y) {
-      ASSERT_EQ(x, __llvm_libc::fmax(x, y));
+      EXPECT_FP_EQ(x, __llvm_libc::fmax(x, y));
     } else {
-      ASSERT_EQ(y, __llvm_libc::fmax(x, y));
+      EXPECT_FP_EQ(y, __llvm_libc::fmax(x, y));
     }
   }
 }
diff --git a/libc/test/src/math/fmaxf_test.cpp b/libc/test/src/math/fmaxf_test.cpp
index fe9eaad171bd..fc8f1cc2512c 100644
--- a/libc/test/src/math/fmaxf_test.cpp
+++ b/libc/test/src/math/fmaxf_test.cpp
@@ -9,6 +9,7 @@
 #include "include/math.h"
 #include "src/math/fmaxf.h"
 #include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
@@ -18,36 +19,36 @@ float inf = FPBits::inf();
 float negInf = FPBits::negInf();
 
 TEST(FmaxfTest, NaNArg) {
-  EXPECT_EQ(inf, __llvm_libc::fmaxf(nan, inf));
-  EXPECT_EQ(negInf, __llvm_libc::fmaxf(negInf, nan));
-  EXPECT_EQ(0.0f, __llvm_libc::fmaxf(nan, 0.0f));
-  EXPECT_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, nan));
-  EXPECT_EQ(-1.2345f, __llvm_libc::fmaxf(nan, -1.2345f));
-  EXPECT_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, nan));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(nan, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmaxf(negInf, nan));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(nan, 0.0f));
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, nan));
+  EXPECT_FP_EQ(-1.2345f, __llvm_libc::fmaxf(nan, -1.2345f));
+  EXPECT_FP_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, nan));
   EXPECT_NE(isnan(__llvm_libc::fmaxf(nan, nan)), 0);
 }
 
 TEST(FmaxfTest, InfArg) {
-  EXPECT_EQ(inf, __llvm_libc::fmaxf(negInf, inf));
-  EXPECT_EQ(inf, __llvm_libc::fmaxf(inf, 0.0f));
-  EXPECT_EQ(inf, __llvm_libc::fmaxf(-0.0f, inf));
-  EXPECT_EQ(inf, __llvm_libc::fmaxf(inf, 1.2345f));
-  EXPECT_EQ(inf, __llvm_libc::fmaxf(-1.2345f, inf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(negInf, inf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, 0.0f));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(-0.0f, inf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, 1.2345f));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(-1.2345f, inf));
 }
 
 TEST(FmaxfTest, NegInfArg) {
-  EXPECT_EQ(inf, __llvm_libc::fmaxf(inf, negInf));
-  EXPECT_EQ(0.0f, __llvm_libc::fmaxf(negInf, 0.0f));
-  EXPECT_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, negInf));
-  EXPECT_EQ(-1.2345f, __llvm_libc::fmaxf(negInf, -1.2345f));
-  EXPECT_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, negInf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, negInf));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(negInf, 0.0f));
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, negInf));
+  EXPECT_FP_EQ(-1.2345f, __llvm_libc::fmaxf(negInf, -1.2345f));
+  EXPECT_FP_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, negInf));
 }
 
 TEST(FmaxfTest, BothZero) {
-  EXPECT_EQ(0.0f, __llvm_libc::fmaxf(0.0f, 0.0f));
-  EXPECT_EQ(0.0f, __llvm_libc::fmaxf(-0.0f, 0.0f));
-  EXPECT_EQ(0.0f, __llvm_libc::fmaxf(0.0f, -0.0f));
-  EXPECT_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, -0.0f));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(0.0f, 0.0f));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(-0.0f, 0.0f));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(0.0f, -0.0f));
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, -0.0f));
 }
 
 TEST(FmaxfTest, InFloatRange) {
@@ -65,9 +66,9 @@ TEST(FmaxfTest, InFloatRange) {
       continue;
 
     if (x > y) {
-      ASSERT_EQ(x, __llvm_libc::fmaxf(x, y));
+      ASSERT_FP_EQ(x, __llvm_libc::fmaxf(x, y));
     } else {
-      ASSERT_EQ(y, __llvm_libc::fmaxf(x, y));
+      ASSERT_FP_EQ(y, __llvm_libc::fmaxf(x, y));
     }
   }
 }
diff --git a/libc/test/src/math/fmaxl_test.cpp b/libc/test/src/math/fmaxl_test.cpp
index 9c7aa21582eb..ac62899d1a96 100644
--- a/libc/test/src/math/fmaxl_test.cpp
+++ b/libc/test/src/math/fmaxl_test.cpp
@@ -9,6 +9,7 @@
 #include "include/math.h"
 #include "src/math/fmaxl.h"
 #include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
@@ -18,36 +19,36 @@ long double inf = FPBits::inf();
 long double negInf = FPBits::negInf();
 
 TEST(FmaxlTest, NaNArg) {
-  EXPECT_EQ(inf, __llvm_libc::fmaxl(nan, inf));
-  EXPECT_EQ(negInf, __llvm_libc::fmaxl(negInf, nan));
-  EXPECT_EQ(0.0L, __llvm_libc::fmaxl(nan, 0.0L));
-  EXPECT_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, nan));
-  EXPECT_EQ(-1.2345L, __llvm_libc::fmaxl(nan, -1.2345L));
-  EXPECT_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, nan));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(nan, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmaxl(negInf, nan));
+  EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(nan, 0.0L));
+  EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, nan));
+  EXPECT_FP_EQ(-1.2345L, __llvm_libc::fmaxl(nan, -1.2345L));
+  EXPECT_FP_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, nan));
   EXPECT_NE(isnan(__llvm_libc::fmaxl(nan, nan)), 0);
 }
 
 TEST(FmaxlTest, InfArg) {
-  EXPECT_EQ(inf, __llvm_libc::fmaxl(negInf, inf));
-  EXPECT_EQ(inf, __llvm_libc::fmaxl(inf, 0.0L));
-  EXPECT_EQ(inf, __llvm_libc::fmaxl(-0.0L, inf));
-  EXPECT_EQ(inf, __llvm_libc::fmaxl(inf, 1.2345L));
-  EXPECT_EQ(inf, __llvm_libc::fmaxl(-1.2345L, inf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(negInf, inf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, 0.0L));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(-0.0L, inf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, 1.2345L));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(-1.2345L, inf));
 }
 
 TEST(FmaxlTest, NegInfArg) {
-  EXPECT_EQ(inf, __llvm_libc::fmaxl(inf, negInf));
-  EXPECT_EQ(0.0L, __llvm_libc::fmaxl(negInf, 0.0L));
-  EXPECT_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, negInf));
-  EXPECT_EQ(-1.2345L, __llvm_libc::fmaxl(negInf, -1.2345L));
-  EXPECT_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, negInf));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, negInf));
+  EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(negInf, 0.0L));
+  EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, negInf));
+  EXPECT_FP_EQ(-1.2345L, __llvm_libc::fmaxl(negInf, -1.2345L));
+  EXPECT_FP_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, negInf));
 }
 
 TEST(FmaxlTest, BothZero) {
-  EXPECT_EQ(0.0L, __llvm_libc::fmaxl(0.0L, 0.0L));
-  EXPECT_EQ(0.0L, __llvm_libc::fmaxl(-0.0L, 0.0L));
-  EXPECT_EQ(0.0L, __llvm_libc::fmaxl(0.0L, -0.0L));
-  EXPECT_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, -0.0L));
+  EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(0.0L, 0.0L));
+  EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(-0.0L, 0.0L));
+  EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(0.0L, -0.0L));
+  EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, -0.0L));
 }
 
 TEST(FmaxlTest, InLongDoubleRange) {
@@ -65,9 +66,9 @@ TEST(FmaxlTest, InLongDoubleRange) {
       continue;
 
     if (x > y) {
-      ASSERT_EQ(x, __llvm_libc::fmaxl(x, y));
+      ASSERT_FP_EQ(x, __llvm_libc::fmaxl(x, y));
     } else {
-      ASSERT_EQ(y, __llvm_libc::fmaxl(x, y));
+      ASSERT_FP_EQ(y, __llvm_libc::fmaxl(x, y));
     }
   }
 }
diff --git a/libc/test/src/math/fmin_test.cpp b/libc/test/src/math/fmin_test.cpp
index 7fd1e8af1e51..47a4433f0c95 100644
--- a/libc/test/src/math/fmin_test.cpp
+++ b/libc/test/src/math/fmin_test.cpp
@@ -9,6 +9,7 @@
 #include "include/math.h"
 #include "src/math/fmin.h"
 #include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
@@ -18,36 +19,36 @@ double inf = static_cast<double>(FPBits::inf());
 double negInf = static_cast<double>(FPBits::negInf());
 
 TEST(FminTest, NaNArg) {
-  EXPECT_EQ(inf, __llvm_libc::fmin(nan, inf));
-  EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, nan));
-  EXPECT_EQ(0.0, __llvm_libc::fmin(nan, 0.0));
-  EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, nan));
-  EXPECT_EQ(-1.2345, __llvm_libc::fmin(nan, -1.2345));
-  EXPECT_EQ(1.2345, __llvm_libc::fmin(1.2345, nan));
+  EXPECT_FP_EQ(inf, __llvm_libc::fmin(nan, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, nan));
+  EXPECT_FP_EQ(0.0, __llvm_libc::fmin(nan, 0.0));
+  EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, nan));
+  EXPECT_FP_EQ(-1.2345, __llvm_libc::fmin(nan, -1.2345));
+  EXPECT_FP_EQ(1.2345, __llvm_libc::fmin(1.2345, nan));
   EXPECT_NE(isnan(__llvm_libc::fmin(nan, nan)), 0);
 }
 
 TEST(FminTest, InfArg) {
-  EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, inf));
-  EXPECT_EQ(0.0, __llvm_libc::fmin(inf, 0.0));
-  EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, inf));
-  EXPECT_EQ(1.2345, __llvm_libc::fmin(inf, 1.2345));
-  EXPECT_EQ(-1.2345, __llvm_libc::fmin(-1.2345, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, inf));
+  EXPECT_FP_EQ(0.0, __llvm_libc::fmin(inf, 0.0));
+  EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, inf));
+  EXPECT_FP_EQ(1.2345, __llvm_libc::fmin(inf, 1.2345));
+  EXPECT_FP_EQ(-1.2345, __llvm_libc::fmin(-1.2345, inf));
 }
 
 TEST(FminTest, NegInfArg) {
-  EXPECT_EQ(negInf, __llvm_libc::fmin(inf, negInf));
-  EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, 0.0));
-  EXPECT_EQ(negInf, __llvm_libc::fmin(-0.0, negInf));
-  EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, -1.2345));
-  EXPECT_EQ(negInf, __llvm_libc::fmin(1.2345, negInf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmin(inf, negInf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, 0.0));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmin(-0.0, negInf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, -1.2345));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmin(1.2345, negInf));
 }
 
 TEST(FminTest, BothZero) {
-  EXPECT_EQ(0.0, __llvm_libc::fmin(0.0, 0.0));
-  EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, 0.0));
-  EXPECT_EQ(-0.0, __llvm_libc::fmin(0.0, -0.0));
-  EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, -0.0));
+  EXPECT_FP_EQ(0.0, __llvm_libc::fmin(0.0, 0.0));
+  EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, 0.0));
+  EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(0.0, -0.0));
+  EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, -0.0));
 }
 
 TEST(FminTest, InFloatRange) {
@@ -65,9 +66,9 @@ TEST(FminTest, InFloatRange) {
       continue;
 
     if (x < y) {
-      ASSERT_EQ(x, __llvm_libc::fmin(x, y));
+      ASSERT_FP_EQ(x, __llvm_libc::fmin(x, y));
     } else {
-      ASSERT_EQ(y, __llvm_libc::fmin(x, y));
+      ASSERT_FP_EQ(y, __llvm_libc::fmin(x, y));
     }
   }
 }
diff --git a/libc/test/src/math/fminf_test.cpp b/libc/test/src/math/fminf_test.cpp
index dea4e7ccf524..20bcdb950291 100644
--- a/libc/test/src/math/fminf_test.cpp
+++ b/libc/test/src/math/fminf_test.cpp
@@ -9,6 +9,7 @@
 #include "include/math.h"
 #include "src/math/fminf.h"
 #include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
@@ -18,36 +19,36 @@ float inf = static_cast<float>(FPBits::inf());
 float negInf = static_cast<float>(FPBits::negInf());
 
 TEST(FminfTest, NaNArg) {
-  EXPECT_EQ(inf, __llvm_libc::fminf(nan, inf));
-  EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, nan));
-  EXPECT_EQ(0.0f, __llvm_libc::fminf(nan, 0.0f));
-  EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, nan));
-  EXPECT_EQ(-1.2345f, __llvm_libc::fminf(nan, -1.2345f));
-  EXPECT_EQ(1.2345f, __llvm_libc::fminf(1.2345f, nan));
+  EXPECT_FP_EQ(inf, __llvm_libc::fminf(nan, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, nan));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(nan, 0.0f));
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, nan));
+  EXPECT_FP_EQ(-1.2345f, __llvm_libc::fminf(nan, -1.2345f));
+  EXPECT_FP_EQ(1.2345f, __llvm_libc::fminf(1.2345f, nan));
   EXPECT_NE(isnan(__llvm_libc::fminf(nan, nan)), 0);
 }
 
 TEST(FminfTest, InfArg) {
-  EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, inf));
-  EXPECT_EQ(0.0f, __llvm_libc::fminf(inf, 0.0f));
-  EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, inf));
-  EXPECT_EQ(1.2345f, __llvm_libc::fminf(inf, 1.2345f));
-  EXPECT_EQ(-1.2345f, __llvm_libc::fminf(-1.2345f, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, inf));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(inf, 0.0f));
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, inf));
+  EXPECT_FP_EQ(1.2345f, __llvm_libc::fminf(inf, 1.2345f));
+  EXPECT_FP_EQ(-1.2345f, __llvm_libc::fminf(-1.2345f, inf));
 }
 
 TEST(FminfTest, NegInfArg) {
-  EXPECT_EQ(negInf, __llvm_libc::fminf(inf, negInf));
-  EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, 0.0f));
-  EXPECT_EQ(negInf, __llvm_libc::fminf(-0.0f, negInf));
-  EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, -1.2345f));
-  EXPECT_EQ(negInf, __llvm_libc::fminf(1.2345f, negInf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminf(inf, negInf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, 0.0f));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminf(-0.0f, negInf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, -1.2345f));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminf(1.2345f, negInf));
 }
 
 TEST(FminfTest, BothZero) {
-  EXPECT_EQ(0.0f, __llvm_libc::fminf(0.0f, 0.0f));
-  EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, 0.0f));
-  EXPECT_EQ(-0.0f, __llvm_libc::fminf(0.0f, -0.0f));
-  EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, -0.0f));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(0.0f, 0.0f));
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, 0.0f));
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(0.0f, -0.0f));
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, -0.0f));
 }
 
 TEST(FminfTest, InFloatRange) {
@@ -65,9 +66,9 @@ TEST(FminfTest, InFloatRange) {
       continue;
 
     if (x < y) {
-      ASSERT_EQ(x, __llvm_libc::fminf(x, y));
+      ASSERT_FP_EQ(x, __llvm_libc::fminf(x, y));
     } else {
-      ASSERT_EQ(y, __llvm_libc::fminf(x, y));
+      ASSERT_FP_EQ(y, __llvm_libc::fminf(x, y));
     }
   }
 }
diff --git a/libc/test/src/math/fminl_test.cpp b/libc/test/src/math/fminl_test.cpp
index 3eabb55b0cab..ea770bc07e4f 100644
--- a/libc/test/src/math/fminl_test.cpp
+++ b/libc/test/src/math/fminl_test.cpp
@@ -9,6 +9,7 @@
 #include "include/math.h"
 #include "src/math/fminl.h"
 #include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
@@ -18,36 +19,36 @@ long double inf = static_cast<long double>(FPBits::inf());
 long double negInf = static_cast<long double>(FPBits::negInf());
 
 TEST(FminlTest, NaNArg) {
-  EXPECT_EQ(inf, __llvm_libc::fminl(nan, inf));
-  EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, nan));
-  EXPECT_EQ(0.0L, __llvm_libc::fminl(nan, 0.0L));
-  EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, nan));
-  EXPECT_EQ(-1.2345L, __llvm_libc::fminl(nan, -1.2345L));
-  EXPECT_EQ(1.2345L, __llvm_libc::fminl(1.2345L, nan));
+  EXPECT_FP_EQ(inf, __llvm_libc::fminl(nan, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, nan));
+  EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(nan, 0.0L));
+  EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, nan));
+  EXPECT_FP_EQ(-1.2345L, __llvm_libc::fminl(nan, -1.2345L));
+  EXPECT_FP_EQ(1.2345L, __llvm_libc::fminl(1.2345L, nan));
   EXPECT_NE(isnan(__llvm_libc::fminl(nan, nan)), 0);
 }
 
 TEST(FminlTest, InfArg) {
-  EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, inf));
-  EXPECT_EQ(0.0L, __llvm_libc::fminl(inf, 0.0L));
-  EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, inf));
-  EXPECT_EQ(1.2345L, __llvm_libc::fminl(inf, 1.2345L));
-  EXPECT_EQ(-1.2345L, __llvm_libc::fminl(-1.2345L, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, inf));
+  EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(inf, 0.0L));
+  EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, inf));
+  EXPECT_FP_EQ(1.2345L, __llvm_libc::fminl(inf, 1.2345L));
+  EXPECT_FP_EQ(-1.2345L, __llvm_libc::fminl(-1.2345L, inf));
 }
 
 TEST(FminlTest, NegInfArg) {
-  EXPECT_EQ(negInf, __llvm_libc::fminl(inf, negInf));
-  EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, 0.0L));
-  EXPECT_EQ(negInf, __llvm_libc::fminl(-0.0L, negInf));
-  EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, -1.2345L));
-  EXPECT_EQ(negInf, __llvm_libc::fminl(1.2345L, negInf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminl(inf, negInf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, 0.0L));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminl(-0.0L, negInf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, -1.2345L));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminl(1.2345L, negInf));
 }
 
 TEST(FminlTest, BothZero) {
-  EXPECT_EQ(0.0L, __llvm_libc::fminl(0.0L, 0.0L));
-  EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, 0.0L));
-  EXPECT_EQ(-0.0L, __llvm_libc::fminl(0.0L, -0.0L));
-  EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, -0.0L));
+  EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(0.0L, 0.0L));
+  EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, 0.0L));
+  EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(0.0L, -0.0L));
+  EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, -0.0L));
 }
 
 TEST(FminlTest, InLongDoubleRange) {
@@ -65,9 +66,9 @@ TEST(FminlTest, InLongDoubleRange) {
       continue;
 
     if (x < y) {
-      ASSERT_EQ(x, __llvm_libc::fminl(x, y));
+      ASSERT_FP_EQ(x, __llvm_libc::fminl(x, y));
     } else {
-      ASSERT_EQ(y, __llvm_libc::fminl(x, y));
+      ASSERT_FP_EQ(y, __llvm_libc::fminl(x, y));
     }
   }
 }
-- 
cgit v1.2.3