[libcxx-commits] [libcxx] e0560c4 - [libc++][math][NFC] Generalize test-suite improvement for `signbit` and `fpclassify` tests (#217897)

[via libcxx-commits]

Author: Lucas Mellone
Date: 2026-08-25T18:46:35+03:00
New Revision: e0560c43d5d5d35530a41c7e201431c64411e3f3

URL: https://github.com/llvm/llvm-project/commit/e0560c43d5d5d35530a41c7e201431c64411e3f3
DIFF: https://github.com/llvm/llvm-project/commit/e0560c43d5d5d35530a41c7e201431c64411e3f3.diff

LOG: [libc++][math][NFC] Generalize test-suite improvement for `signbit` and `fpclassify` tests (#217897)

This patch generalizes the test-suite improvements for
`signbit.pass.cpp` and `fpclassify.pass.cpp` as per the review comments
present in https://github.com/llvm/llvm-project/pull/210075 for
consistency purposes.

Follows-up:
https://github.com/llvm/llvm-project/pull/210075#discussion_r3629842324

Added: 
    

Modified: 
    libcxx/test/std/numerics/c.math/fpclassify.pass.cpp
    libcxx/test/std/numerics/c.math/signbit.pass.cpp

Removed: 
    


################################################################################
diff  --git a/libcxx/test/std/numerics/c.math/fpclassify.pass.cpp b/libcxx/test/std/numerics/c.math/fpclassify.pass.cpp
index 10b2297fce105..b5fa618655c3e 100644
--- a/libcxx/test/std/numerics/c.math/fpclassify.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/fpclassify.pass.cpp
@@ -19,26 +19,20 @@
 struct TestFloat {
   template <class T>
   TEST_CONSTEXPR_CXX23 void operator()() const {
-    using lim                    = std::numeric_limits<T>;
-    TEST_CONSTEXPR_CXX23 T max   = lim::max();
-    TEST_CONSTEXPR_CXX23 T min   = lim::min();
-    TEST_CONSTEXPR_CXX23 T d_min = lim::denorm_min();
-    TEST_CONSTEXPR_CXX23 T inf   = lim::infinity();
-    TEST_CONSTEXPR_CXX23 T nan   = lim::quiet_NaN();
-    TEST_CONSTEXPR_CXX23 T s_nan = lim::signaling_NaN();
+    using lim = std::numeric_limits<T>;
 
-    assert(std::fpclassify(nan) == FP_NAN);
-    assert(std::fpclassify(s_nan) == FP_NAN);
+    assert(std::fpclassify(lim::quiet_NaN()) == FP_NAN);
+    assert(std::fpclassify(lim::signaling_NaN()) == FP_NAN);
 
-    assert(std::fpclassify(inf) == FP_INFINITE);
-    assert(std::fpclassify(-inf) == FP_INFINITE);
+    assert(std::fpclassify(lim::infinity()) == FP_INFINITE);
+    assert(std::fpclassify(-lim::infinity()) == FP_INFINITE);
 
     assert(std::fpclassify(T(1)) == FP_NORMAL);
     assert(std::fpclassify(T(-1)) == FP_NORMAL);
-    assert(std::fpclassify(max) == FP_NORMAL);
-    assert(std::fpclassify(min) == FP_NORMAL);
+    assert(std::fpclassify(lim::max()) == FP_NORMAL);
+    assert(std::fpclassify(lim::min()) == FP_NORMAL);
 
-    assert(std::fpclassify(d_min) == FP_SUBNORMAL);
+    assert(std::fpclassify(lim::denorm_min()) == FP_SUBNORMAL);
 
     assert(std::fpclassify(T(0)) == FP_ZERO);
     assert(std::fpclassify(T(-0.0)) == FP_ZERO);
@@ -48,16 +42,14 @@ struct TestFloat {
 struct TestInt {
   template <class T>
   TEST_CONSTEXPR_CXX23 void operator()() const {
-    using lim                  = std::numeric_limits<T>;
-    TEST_CONSTEXPR_CXX23 T max = lim::max();
-    TEST_CONSTEXPR_CXX23 T low = lim::lowest();
+    using lim = std::numeric_limits<T>;
 
     assert(std::fpclassify(T(0)) == FP_ZERO);
     assert(std::fpclassify(T(1)) == FP_NORMAL);
-    assert(std::fpclassify(max) == FP_NORMAL);
+    assert(std::fpclassify(lim::max()) == FP_NORMAL);
 
     if (std::is_signed<T>::value) {
-      assert(std::fpclassify(low) == FP_NORMAL);
+      assert(std::fpclassify(lim::lowest()) == FP_NORMAL);
       assert(std::fpclassify(T(-1)) == FP_NORMAL);
     }
   }

diff  --git a/libcxx/test/std/numerics/c.math/signbit.pass.cpp b/libcxx/test/std/numerics/c.math/signbit.pass.cpp
index ce219b3a35c0b..f31034ec50ba8 100644
--- a/libcxx/test/std/numerics/c.math/signbit.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/signbit.pass.cpp
@@ -24,59 +24,43 @@
 
 struct TestFloat {
   template <class T>
-  static TEST_CONSTEXPR_CXX23 bool test() {
+  TEST_CONSTEXPR_CXX23 void operator()() {
+    using lim = std::numeric_limits<T>;
+
     assert(!std::signbit(T(0)));
-    assert(!std::signbit(std::numeric_limits<T>::min()));
-    assert(!std::signbit(std::numeric_limits<T>::denorm_min()));
-    assert(!std::signbit(std::numeric_limits<T>::max()));
-    assert(!std::signbit(std::numeric_limits<T>::infinity()));
-    assert(!std::signbit(std::numeric_limits<T>::quiet_NaN()));
-    assert(!std::signbit(std::numeric_limits<T>::signaling_NaN()));
+    assert(!std::signbit(lim::min()));
+    assert(!std::signbit(lim::denorm_min()));
+    assert(!std::signbit(lim::max()));
+    assert(!std::signbit(lim::infinity()));
+    assert(!std::signbit(lim::quiet_NaN()));
+    assert(!std::signbit(lim::signaling_NaN()));
     assert(std::signbit(-T(0)));
-    assert(std::signbit(-std::numeric_limits<T>::infinity()));
-    assert(std::signbit(std::numeric_limits<T>::lowest()));
-
-    return true;
-  }
-
-  template <class T>
-  TEST_CONSTEXPR_CXX23 void operator()() {
-    test<T>();
-#if TEST_STD_VER >= 23
-    static_assert(test<T>());
-#endif
+    assert(std::signbit(-lim::infinity()));
+    assert(std::signbit(lim::lowest()));
   }
 };
 
 struct TestInt {
   template <class T>
-  static TEST_CONSTEXPR_CXX23 bool test() {
-    assert(!std::signbit(std::numeric_limits<T>::max()));
+  TEST_CONSTEXPR_CXX23 void operator()() {
+    using lim = std::numeric_limits<T>;
+
+    assert(!std::signbit(lim::max()));
     assert(!std::signbit(T(0)));
     if (std::is_unsigned<T>::value) {
-      assert(!std::signbit(std::numeric_limits<T>::lowest()));
+      assert(!std::signbit(lim::lowest()));
     } else {
-      assert(std::signbit(std::numeric_limits<T>::lowest()));
+      assert(std::signbit(lim::lowest()));
     }
-
-    return true;
-  }
-
-  template <class T>
-  TEST_CONSTEXPR_CXX23 void operator()() {
-    test<T>();
-#if TEST_STD_VER >= 23
-    static_assert(test<T>());
-#endif
   }
 };
 
 template <typename T>
 struct ConvertibleTo {
-  operator T() const { return T(); }
+  TEST_CONSTEXPR_CXX23 operator T() const { return T(); }
 };
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX23 bool test() {
   types::for_each(types::floating_point_types(), TestFloat());
   types::for_each(types::integral_types(), TestInt());
 
@@ -88,5 +72,14 @@ int main(int, char**) {
     assert(!std::signbit(ConvertibleTo<double>()));
     assert(!std::signbit(ConvertibleTo<long double>()));
   }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 23
+  static_assert(test());
+#endif
   return 0;
 }