[libc][NFC] Rename global `nan` in tests to `aNaN`.

The name `nan` conflicts with the function `nan` defined declared in
math.h.

diff --git a/libc/test/src/math/ceil_test.cpp b/libc/test/src/math/ceil_test.cpp
index 0e17b0a7984b4da446e9573529affecba2141db6..1537227d3180a03e928edf291437505a441a770a 100644 (file)
--- a/libc/test/src/math/ceil_test.cpp
+++ b/libc/test/src/math/ceil_test.cpp
@@ -26,8 +26,8 @@ TEST(CeilTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::ceil(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::ceil(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::ceil(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::ceil(aNaN)), 0);
 }
 
 TEST(CeilTest, RoundedNumbers) {

diff --git a/libc/test/src/math/ceilf_test.cpp b/libc/test/src/math/ceilf_test.cpp
index 3d7db68eea3b82cb14dcd07b3146ce3f4d039a6b..aa3ea73f035281da93320463a27a16701c09c485 100644 (file)
--- a/libc/test/src/math/ceilf_test.cpp
+++ b/libc/test/src/math/ceilf_test.cpp
@@ -26,8 +26,8 @@ TEST(CeilfTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::ceilf(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::ceilf(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::ceilf(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::ceilf(aNaN)), 0);
 }
 
 TEST(CeilfTest, RoundedNumbers) {

diff --git a/libc/test/src/math/ceill_test.cpp b/libc/test/src/math/ceill_test.cpp
index 950a976220233a66aed059b5b98e3643a6d375ed..b33d317e0ac69477dc23736fa753ba3eed5c3f1d 100644 (file)
--- a/libc/test/src/math/ceill_test.cpp
+++ b/libc/test/src/math/ceill_test.cpp
@@ -26,8 +26,8 @@ TEST(CeillTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::ceill(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::ceill(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::ceill(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::ceill(aNaN)), 0);
 }
 
 TEST(CeillTest, RoundedNumbers) {

diff --git a/libc/test/src/math/copysign_test.cpp b/libc/test/src/math/copysign_test.cpp
index 09067fa10b5682eea9b1d15352e14c5dabd141ca..7ab7ccfdb7009113cacf233ee69520da86a58996 100644 (file)
--- a/libc/test/src/math/copysign_test.cpp
+++ b/libc/test/src/math/copysign_test.cpp
@@ -17,8 +17,8 @@ using FPBits = __llvm_libc::fputil::FPBits<double>;
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(CopySignTest, SpecialNumbers) {
-  EXPECT_FP_EQ(nan, __llvm_libc::copysign(nan, -1.0));
-  EXPECT_FP_EQ(nan, __llvm_libc::copysign(nan, 1.0));
+  EXPECT_FP_EQ(aNaN, __llvm_libc::copysign(aNaN, -1.0));
+  EXPECT_FP_EQ(aNaN, __llvm_libc::copysign(aNaN, 1.0));
 
   EXPECT_FP_EQ(negInf, __llvm_libc::copysign(inf, -1.0));
   EXPECT_FP_EQ(inf, __llvm_libc::copysign(negInf, 1.0));

diff --git a/libc/test/src/math/copysignf_test.cpp b/libc/test/src/math/copysignf_test.cpp
index e43055041dc3143686be9e5aae3e7eb18868d7ff..72082cac8d432123a157479dee851acf396ebd01 100644 (file)
--- a/libc/test/src/math/copysignf_test.cpp
+++ b/libc/test/src/math/copysignf_test.cpp
@@ -17,8 +17,8 @@ using FPBits = __llvm_libc::fputil::FPBits<float>;
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(CopySinfTest, SpecialNumbers) {
-  EXPECT_FP_EQ(nan, __llvm_libc::copysignf(nan, -1.0));
-  EXPECT_FP_EQ(nan, __llvm_libc::copysignf(nan, 1.0));
+  EXPECT_FP_EQ(aNaN, __llvm_libc::copysignf(aNaN, -1.0));
+  EXPECT_FP_EQ(aNaN, __llvm_libc::copysignf(aNaN, 1.0));
 
   EXPECT_FP_EQ(negInf, __llvm_libc::copysignf(inf, -1.0));
   EXPECT_FP_EQ(inf, __llvm_libc::copysignf(negInf, 1.0));

diff --git a/libc/test/src/math/copysignl_test.cpp b/libc/test/src/math/copysignl_test.cpp
index 47f439f10ca2cd524b69116536d97ae47c3314ff..69daa038d991e2e5db7e86e91aed9bc73e58e403 100644 (file)
--- a/libc/test/src/math/copysignl_test.cpp
+++ b/libc/test/src/math/copysignl_test.cpp
@@ -17,8 +17,8 @@ using FPBits = __llvm_libc::fputil::FPBits<long double>;
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 TEST(CopySinlTest, SpecialNumbers) {
-  EXPECT_FP_EQ(nan, __llvm_libc::copysignl(nan, -1.0));
-  EXPECT_FP_EQ(nan, __llvm_libc::copysignl(nan, 1.0));
+  EXPECT_FP_EQ(aNaN, __llvm_libc::copysignl(aNaN, -1.0));
+  EXPECT_FP_EQ(aNaN, __llvm_libc::copysignl(aNaN, 1.0));
 
   EXPECT_FP_EQ(negInf, __llvm_libc::copysignl(inf, -1.0));
   EXPECT_FP_EQ(inf, __llvm_libc::copysignl(negInf, 1.0));

diff --git a/libc/test/src/math/fabs_test.cpp b/libc/test/src/math/fabs_test.cpp
index 0e1dc48ccfe7b081231aa3988a4fc1a3b5d18f41..91d37e3f569b538d7cca5ec6df764fb4ed0ae077 100644 (file)
--- a/libc/test/src/math/fabs_test.cpp
+++ b/libc/test/src/math/fabs_test.cpp
@@ -20,7 +20,7 @@ DECLARE_SPECIAL_CONSTANTS(double)
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 TEST(FabsTest, SpecialNumbers) {
-  EXPECT_FP_EQ(nan, __llvm_libc::fabs(nan));
+  EXPECT_FP_EQ(aNaN, __llvm_libc::fabs(aNaN));
 
   EXPECT_FP_EQ(inf, __llvm_libc::fabs(inf));
   EXPECT_FP_EQ(inf, __llvm_libc::fabs(negInf));

diff --git a/libc/test/src/math/fabsf_test.cpp b/libc/test/src/math/fabsf_test.cpp
index 256748c6b87b00de8f70caaa8f08ecd011ac241d..fc0925901fa5f9291d7fa4b23ad3cac498dff3db 100644 (file)
--- a/libc/test/src/math/fabsf_test.cpp
+++ b/libc/test/src/math/fabsf_test.cpp
@@ -20,7 +20,7 @@ DECLARE_SPECIAL_CONSTANTS(float)
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 TEST(FabsfTest, SpecialNumbers) {
-  EXPECT_FP_EQ(nan, __llvm_libc::fabsf(nan));
+  EXPECT_FP_EQ(aNaN, __llvm_libc::fabsf(aNaN));
 
   EXPECT_FP_EQ(inf, __llvm_libc::fabsf(inf));
   EXPECT_FP_EQ(inf, __llvm_libc::fabsf(negInf));

diff --git a/libc/test/src/math/fabsl_test.cpp b/libc/test/src/math/fabsl_test.cpp
index fd3a8825c0fa79b80a930fa8272c85b2b570808b..1a0cb9d93be55787b35b73ef0fd5f7e8b2e6435c 100644 (file)
--- a/libc/test/src/math/fabsl_test.cpp
+++ b/libc/test/src/math/fabsl_test.cpp
@@ -20,7 +20,7 @@ DECLARE_SPECIAL_CONSTANTS(long double)
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 TEST(FabslTest, SpecialNumbers) {
-  EXPECT_FP_EQ(nan, __llvm_libc::fabsl(nan));
+  EXPECT_FP_EQ(aNaN, __llvm_libc::fabsl(aNaN));
 
   EXPECT_FP_EQ(inf, __llvm_libc::fabsl(inf));
   EXPECT_FP_EQ(inf, __llvm_libc::fabsl(negInf));

diff --git a/libc/test/src/math/floor_test.cpp b/libc/test/src/math/floor_test.cpp
index 588b2a3dd56b3f717ccab8bdfb7e8b337413d56e..35f107a918cc7d2a6dc602151afb2fc95d60ea0f 100644 (file)
--- a/libc/test/src/math/floor_test.cpp
+++ b/libc/test/src/math/floor_test.cpp
@@ -26,8 +26,8 @@ TEST(FloorTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::floor(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::floor(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::floor(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::floor(aNaN)), 0);
 }
 
 TEST(FloorTest, RoundedNumbers) {

diff --git a/libc/test/src/math/floorf_test.cpp b/libc/test/src/math/floorf_test.cpp
index 5a8e8cf635060b2fab9d8abf99af58b5b8f2271f..e6bc974f1fc817b1b32ba8dafdca02e0d7ed63f2 100644 (file)
--- a/libc/test/src/math/floorf_test.cpp
+++ b/libc/test/src/math/floorf_test.cpp
@@ -26,8 +26,8 @@ TEST(FloorfTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::floorf(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::floorf(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::floorf(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::floorf(aNaN)), 0);
 }
 
 TEST(FloorfTest, RoundedNumbers) {

diff --git a/libc/test/src/math/floorl_test.cpp b/libc/test/src/math/floorl_test.cpp
index 3ab5d5f8201bfc715c52711dfa8b23a9bd537270..cad5c70c2f5b8ce64508e7f8cacb6ba4ce29b78b 100644 (file)
--- a/libc/test/src/math/floorl_test.cpp
+++ b/libc/test/src/math/floorl_test.cpp
@@ -26,8 +26,8 @@ TEST(FloorlTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::floorl(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::floorl(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::floorl(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::floorl(aNaN)), 0);
 }
 
 TEST(FloorlTest, RoundedNumbers) {

diff --git a/libc/test/src/math/fmax_test.cpp b/libc/test/src/math/fmax_test.cpp
index 1114307e60a82d7214e6d769fa95c6c989f3b88e..b84db3003cc6a86aa85c612f46f844bd7c00bdb6 100644 (file)
--- a/libc/test/src/math/fmax_test.cpp
+++ b/libc/test/src/math/fmax_test.cpp
@@ -17,13 +17,13 @@ using FPBits = __llvm_libc::fputil::FPBits<double>;
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(FmaxTest, NaNArg) {
-  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);
+  EXPECT_FP_EQ(inf, __llvm_libc::fmax(aNaN, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmax(negInf, aNaN));
+  EXPECT_FP_EQ(0.0, __llvm_libc::fmax(aNaN, 0.0));
+  EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, aNaN));
+  EXPECT_FP_EQ(-1.2345, __llvm_libc::fmax(aNaN, -1.2345));
+  EXPECT_FP_EQ(1.2345, __llvm_libc::fmax(1.2345, aNaN));
+  EXPECT_NE(isnan(__llvm_libc::fmax(aNaN, aNaN)), 0);
 }
 
 TEST(FmaxTest, InfArg) {

diff --git a/libc/test/src/math/fmaxf_test.cpp b/libc/test/src/math/fmaxf_test.cpp
index 3e81c9979114f9833dc84514b39c949cb3dbab53..7d6661cb4b8b82f64b0d7c21a9f6e5ee7fa9ecbb 100644 (file)
--- a/libc/test/src/math/fmaxf_test.cpp
+++ b/libc/test/src/math/fmaxf_test.cpp
@@ -17,13 +17,13 @@ using FPBits = __llvm_libc::fputil::FPBits<float>;
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(FmaxfTest, NaNArg) {
-  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);
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(aNaN, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmaxf(negInf, aNaN));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(aNaN, 0.0f));
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, aNaN));
+  EXPECT_FP_EQ(-1.2345f, __llvm_libc::fmaxf(aNaN, -1.2345f));
+  EXPECT_FP_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, aNaN));
+  EXPECT_NE(isnan(__llvm_libc::fmaxf(aNaN, aNaN)), 0);
 }
 
 TEST(FmaxfTest, InfArg) {

diff --git a/libc/test/src/math/fmaxl_test.cpp b/libc/test/src/math/fmaxl_test.cpp
index ce48b5dce76ffc07c1524b6e5253e7ce04646ecb..72f7636cb0ebfacada4b749f33d2ec8bb5266568 100644 (file)
--- a/libc/test/src/math/fmaxl_test.cpp
+++ b/libc/test/src/math/fmaxl_test.cpp
@@ -17,13 +17,13 @@ using FPBits = __llvm_libc::fputil::FPBits<long double>;
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 TEST(FmaxlTest, NaNArg) {
-  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);
+  EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(aNaN, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmaxl(negInf, aNaN));
+  EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(aNaN, 0.0L));
+  EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, aNaN));
+  EXPECT_FP_EQ(-1.2345L, __llvm_libc::fmaxl(aNaN, -1.2345L));
+  EXPECT_FP_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, aNaN));
+  EXPECT_NE(isnan(__llvm_libc::fmaxl(aNaN, aNaN)), 0);
 }
 
 TEST(FmaxlTest, InfArg) {

diff --git a/libc/test/src/math/fmin_test.cpp b/libc/test/src/math/fmin_test.cpp
index 89a25beba8d7545bedcb2f998b77cecc28678863..5deaa857c1f2ef5ca7d85c2c97d9b311d4f91dde 100644 (file)
--- a/libc/test/src/math/fmin_test.cpp
+++ b/libc/test/src/math/fmin_test.cpp
@@ -17,13 +17,13 @@ using FPBits = __llvm_libc::fputil::FPBits<double>;
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(FminTest, NaNArg) {
-  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);
+  EXPECT_FP_EQ(inf, __llvm_libc::fmin(aNaN, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, aNaN));
+  EXPECT_FP_EQ(0.0, __llvm_libc::fmin(aNaN, 0.0));
+  EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, aNaN));
+  EXPECT_FP_EQ(-1.2345, __llvm_libc::fmin(aNaN, -1.2345));
+  EXPECT_FP_EQ(1.2345, __llvm_libc::fmin(1.2345, aNaN));
+  EXPECT_NE(isnan(__llvm_libc::fmin(aNaN, aNaN)), 0);
 }
 
 TEST(FminTest, InfArg) {

diff --git a/libc/test/src/math/fminf_test.cpp b/libc/test/src/math/fminf_test.cpp
index 6772fb5e96a3d5ca84b3071e735f3d971e3ccdeb..d9a01dd506d88c64457cbef0b2c4631bea166312 100644 (file)
--- a/libc/test/src/math/fminf_test.cpp
+++ b/libc/test/src/math/fminf_test.cpp
@@ -17,13 +17,13 @@ using FPBits = __llvm_libc::fputil::FPBits<float>;
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(FminfTest, NaNArg) {
-  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);
+  EXPECT_FP_EQ(inf, __llvm_libc::fminf(aNaN, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, aNaN));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(aNaN, 0.0f));
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, aNaN));
+  EXPECT_FP_EQ(-1.2345f, __llvm_libc::fminf(aNaN, -1.2345f));
+  EXPECT_FP_EQ(1.2345f, __llvm_libc::fminf(1.2345f, aNaN));
+  EXPECT_NE(isnan(__llvm_libc::fminf(aNaN, aNaN)), 0);
 }
 
 TEST(FminfTest, InfArg) {

diff --git a/libc/test/src/math/fminl_test.cpp b/libc/test/src/math/fminl_test.cpp
index 20c88d410a47a6b844e434221a5694dbb433370e..75200b1212e583e91740446a2e4975f56521b368 100644 (file)
--- a/libc/test/src/math/fminl_test.cpp
+++ b/libc/test/src/math/fminl_test.cpp
@@ -17,13 +17,13 @@ using FPBits = __llvm_libc::fputil::FPBits<long double>;
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 TEST(FminlTest, NaNArg) {
-  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);
+  EXPECT_FP_EQ(inf, __llvm_libc::fminl(aNaN, inf));
+  EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, aNaN));
+  EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(aNaN, 0.0L));
+  EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, aNaN));
+  EXPECT_FP_EQ(-1.2345L, __llvm_libc::fminl(aNaN, -1.2345L));
+  EXPECT_FP_EQ(1.2345L, __llvm_libc::fminl(1.2345L, aNaN));
+  EXPECT_NE(isnan(__llvm_libc::fminl(aNaN, aNaN)), 0);
 }
 
 TEST(FminlTest, InfArg) {

diff --git a/libc/test/src/math/round_test.cpp b/libc/test/src/math/round_test.cpp
index bc611d4559a11abe7dba2e52b4a1eaf8caf3d252..defa22a05d44a83d4f7ca48d4d33476f0c4f1dcf 100644 (file)
--- a/libc/test/src/math/round_test.cpp
+++ b/libc/test/src/math/round_test.cpp
@@ -26,8 +26,8 @@ TEST(RoundTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::round(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::round(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::round(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::round(aNaN)), 0);
 }
 
 TEST(RoundTest, RoundedNumbers) {

diff --git a/libc/test/src/math/roundf_test.cpp b/libc/test/src/math/roundf_test.cpp
index 4a49c095b88271418a0acc13fa99f0ee613738ea..2665e81e54c135ad4e9d36be591efd705a85081a 100644 (file)
--- a/libc/test/src/math/roundf_test.cpp
+++ b/libc/test/src/math/roundf_test.cpp
@@ -26,8 +26,8 @@ TEST(RoundfTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::roundf(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::roundf(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::roundf(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::roundf(aNaN)), 0);
 }
 
 TEST(RoundfTest, RoundedNumbers) {

diff --git a/libc/test/src/math/roundl_test.cpp b/libc/test/src/math/roundl_test.cpp
index 7b2eb6f90c8eb73fb3c2da2ba2536c26d68391bf..ff33c071b3b621a53128ffd34eda27442eeb0e82 100644 (file)
--- a/libc/test/src/math/roundl_test.cpp
+++ b/libc/test/src/math/roundl_test.cpp
@@ -26,8 +26,8 @@ TEST(RoundlTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::roundl(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::roundl(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::roundl(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::roundl(aNaN)), 0);
 }
 
 TEST(RoundlTest, RoundedNumbers) {

diff --git a/libc/test/src/math/sqrt_test.cpp b/libc/test/src/math/sqrt_test.cpp
index beec7adcb7f9362bbb9a11c4066ad0290429d974..f0a1ffff82f1d798d02cd63a66fb511d7dfb84da 100644 (file)
--- a/libc/test/src/math/sqrt_test.cpp
+++ b/libc/test/src/math/sqrt_test.cpp
@@ -23,12 +23,12 @@ constexpr UIntType HiddenBit =
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(SqrtTest, SpecialValues) {
-  ASSERT_FP_EQ(nan, __llvm_libc::sqrt(nan));
+  ASSERT_FP_EQ(aNaN, __llvm_libc::sqrt(aNaN));
   ASSERT_FP_EQ(inf, __llvm_libc::sqrt(inf));
-  ASSERT_FP_EQ(nan, __llvm_libc::sqrt(negInf));
+  ASSERT_FP_EQ(aNaN, __llvm_libc::sqrt(negInf));
   ASSERT_FP_EQ(0.0, __llvm_libc::sqrt(0.0));
   ASSERT_FP_EQ(-0.0, __llvm_libc::sqrt(-0.0));
-  ASSERT_FP_EQ(nan, __llvm_libc::sqrt(-1.0));
+  ASSERT_FP_EQ(aNaN, __llvm_libc::sqrt(-1.0));
   ASSERT_FP_EQ(1.0, __llvm_libc::sqrt(1.0));
   ASSERT_FP_EQ(2.0, __llvm_libc::sqrt(4.0));
   ASSERT_FP_EQ(3.0, __llvm_libc::sqrt(9.0));

diff --git a/libc/test/src/math/sqrtf_test.cpp b/libc/test/src/math/sqrtf_test.cpp
index b64b0d0376230d6806ce30f30e6759becd1ca437..2f1b8071227b7db163b07a38fa40802054910c7b 100644 (file)
--- a/libc/test/src/math/sqrtf_test.cpp
+++ b/libc/test/src/math/sqrtf_test.cpp
@@ -23,12 +23,12 @@ constexpr UIntType HiddenBit =
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(SqrtfTest, SpecialValues) {
-  ASSERT_FP_EQ(nan, __llvm_libc::sqrtf(nan));
+  ASSERT_FP_EQ(aNaN, __llvm_libc::sqrtf(aNaN));
   ASSERT_FP_EQ(inf, __llvm_libc::sqrtf(inf));
-  ASSERT_FP_EQ(nan, __llvm_libc::sqrtf(negInf));
+  ASSERT_FP_EQ(aNaN, __llvm_libc::sqrtf(negInf));
   ASSERT_FP_EQ(0.0f, __llvm_libc::sqrtf(0.0f));
   ASSERT_FP_EQ(-0.0f, __llvm_libc::sqrtf(-0.0f));
-  ASSERT_FP_EQ(nan, __llvm_libc::sqrtf(-1.0f));
+  ASSERT_FP_EQ(aNaN, __llvm_libc::sqrtf(-1.0f));
   ASSERT_FP_EQ(1.0f, __llvm_libc::sqrtf(1.0f));
   ASSERT_FP_EQ(2.0f, __llvm_libc::sqrtf(4.0f));
   ASSERT_FP_EQ(3.0f, __llvm_libc::sqrtf(9.0f));

diff --git a/libc/test/src/math/sqrtl_test.cpp b/libc/test/src/math/sqrtl_test.cpp
index 4fe03df57eb65e4e1545e9001bfdf764e6738a04..6e7a092aef6657e568de00e70b53e4ff3857e8f0 100644 (file)
--- a/libc/test/src/math/sqrtl_test.cpp
+++ b/libc/test/src/math/sqrtl_test.cpp
@@ -23,12 +23,12 @@ constexpr UIntType HiddenBit =
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 TEST(SqrtlTest, SpecialValues) {
-  ASSERT_FP_EQ(nan, __llvm_libc::sqrtl(nan));
+  ASSERT_FP_EQ(aNaN, __llvm_libc::sqrtl(aNaN));
   ASSERT_FP_EQ(inf, __llvm_libc::sqrtl(inf));
-  ASSERT_FP_EQ(nan, __llvm_libc::sqrtl(negInf));
+  ASSERT_FP_EQ(aNaN, __llvm_libc::sqrtl(negInf));
   ASSERT_FP_EQ(0.0L, __llvm_libc::sqrtl(0.0L));
   ASSERT_FP_EQ(-0.0L, __llvm_libc::sqrtl(-0.0L));
-  ASSERT_FP_EQ(nan, __llvm_libc::sqrtl(-1.0L));
+  ASSERT_FP_EQ(aNaN, __llvm_libc::sqrtl(-1.0L));
   ASSERT_FP_EQ(1.0L, __llvm_libc::sqrtl(1.0L));
   ASSERT_FP_EQ(2.0L, __llvm_libc::sqrtl(4.0L));
   ASSERT_FP_EQ(3.0L, __llvm_libc::sqrtl(9.0L));

diff --git a/libc/test/src/math/trunc_test.cpp b/libc/test/src/math/trunc_test.cpp
index 981a729b4e297b72936f89ab3d0f831e7ba658c5..89fa17d9010ff59bf8840d6e091fcc6b86f87966 100644 (file)
--- a/libc/test/src/math/trunc_test.cpp
+++ b/libc/test/src/math/trunc_test.cpp
@@ -26,8 +26,8 @@ TEST(TruncTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::trunc(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::trunc(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::trunc(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::trunc(aNaN)), 0);
 }
 
 TEST(TruncTest, RoundedNumbers) {

diff --git a/libc/test/src/math/truncf_test.cpp b/libc/test/src/math/truncf_test.cpp
index 416eb7c7d212e0a750976f9df10ee21a0ca87d01..bd44ce7b1226785b847c527e08b2e83703366817 100644 (file)
--- a/libc/test/src/math/truncf_test.cpp
+++ b/libc/test/src/math/truncf_test.cpp
@@ -26,8 +26,8 @@ TEST(TruncfTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::truncf(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::truncf(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::truncf(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::truncf(aNaN)), 0);
 }
 
 TEST(TruncfTest, RoundedNumbers) {

diff --git a/libc/test/src/math/truncl_test.cpp b/libc/test/src/math/truncl_test.cpp
index 1220b7a7cc8845d26495cc40f3e10711fbb8742d..3c70a3a1593bbba1b99e2b5364e7b0827d01c1f0 100644 (file)
--- a/libc/test/src/math/truncl_test.cpp
+++ b/libc/test/src/math/truncl_test.cpp
@@ -26,8 +26,8 @@ TEST(TrunclTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::truncl(inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::truncl(negInf));
 
-  ASSERT_NE(isnan(nan), 0);
-  ASSERT_NE(isnan(__llvm_libc::truncl(nan)), 0);
+  ASSERT_NE(isnan(aNaN), 0);
+  ASSERT_NE(isnan(__llvm_libc::truncl(aNaN)), 0);
 }
 
 TEST(TrunclTest, RoundedNumbers) {

diff --git a/libc/utils/FPUtil/TestHelpers.h b/libc/utils/FPUtil/TestHelpers.h
index 8addb0c58db587989553f23148866f9bafa368ac..48abed85f27620f6ca42856405c7365e78e5e211 100644 (file)
--- a/libc/utils/FPUtil/TestHelpers.h
+++ b/libc/utils/FPUtil/TestHelpers.h
@@ -68,7 +68,7 @@ FPMatcher<T, C> getMatcher(T expectedValue) {
 #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 aNaN = __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();