[libc] [llvm] [libc][NFC] Reduce type clutter in str_to_float_test (PR #75353)

via llvm-commits llvm-commits at lists.llvm.org
Wed Dec 13 08:48:21 PST 2023


llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-libc

Author: Guillaume Chatelet (gchatelet)

<details>
<summary>Changes</summary>



---

Patch is 21.91 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/75353.diff


3 Files Affected:

- (modified) libc/test/src/__support/CMakeLists.txt (+1) 
- (modified) libc/test/src/__support/str_to_float_test.cpp (+142-154) 
- (modified) utils/bazel/llvm-project-overlay/libc/test/src/__support/BUILD.bazel (+1-1) 


``````````diff
diff --git a/libc/test/src/__support/CMakeLists.txt b/libc/test/src/__support/CMakeLists.txt
index 740209bc83d75e..693b8232445afe 100644
--- a/libc/test/src/__support/CMakeLists.txt
+++ b/libc/test/src/__support/CMakeLists.txt
@@ -51,6 +51,7 @@ add_libc_test(
   SRCS
     str_to_float_test.cpp
   DEPENDS
+    libc.src.__support.FPUtil.float_properties
     libc.src.__support.str_to_float
     libc.src.__support.uint128
     libc.src.errno.errno
diff --git a/libc/test/src/__support/str_to_float_test.cpp b/libc/test/src/__support/str_to_float_test.cpp
index 35f7318fb9c78d..49b9fdf33d497b 100644
--- a/libc/test/src/__support/str_to_float_test.cpp
+++ b/libc/test/src/__support/str_to_float_test.cpp
@@ -6,28 +6,26 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/__support/FPUtil/FPBits.h"
+#include "src/__support/FPUtil/FloatProperties.h"
 #include "src/__support/UInt128.h"
 #include "src/__support/str_to_float.h"
 #include "src/errno/libc_errno.h"
 
 #include "test/UnitTest/Test.h"
 
-class LlvmLibcStrToFloatTest : public LIBC_NAMESPACE::testing::Test {
+namespace LIBC_NAMESPACE {
+
+template <typename T> class LlvmLibcStrToFloatTest : public testing::Test {
 public:
-  template <class T>
-  void clinger_fast_path_test(
-      const typename LIBC_NAMESPACE::fputil::FPBits<T>::UIntType inputMantissa,
-      const int32_t inputExp10,
-      const typename LIBC_NAMESPACE::fputil::FPBits<T>::UIntType
-          expectedOutputMantissa,
-      const uint32_t expectedOutputExp2) {
-    typename LIBC_NAMESPACE::fputil::FPBits<T>::UIntType
-        actual_output_mantissa = 0;
+  using UIntType = typename fputil::FloatProperties<T>::UIntType;
+  void clinger_fast_path_test(const UIntType inputMantissa,
+                              const int32_t inputExp10,
+                              const UIntType expectedOutputMantissa,
+                              const uint32_t expectedOutputExp2) {
+    UIntType actual_output_mantissa = 0;
     uint32_t actual_output_exp2 = 0;
 
-    auto result = LIBC_NAMESPACE::internal::clinger_fast_path<T>(
-        {inputMantissa, inputExp10});
+    auto result = internal::clinger_fast_path<T>({inputMantissa, inputExp10});
 
     ASSERT_TRUE(result.has_value());
 
@@ -38,28 +36,23 @@ class LlvmLibcStrToFloatTest : public LIBC_NAMESPACE::testing::Test {
     EXPECT_EQ(actual_output_exp2, expectedOutputExp2);
   }
 
-  template <class T>
-  void clinger_fast_path_fails_test(
-      const typename LIBC_NAMESPACE::fputil::FPBits<T>::UIntType inputMantissa,
-      const int32_t inputExp10) {
-    ASSERT_FALSE(LIBC_NAMESPACE::internal::clinger_fast_path<T>(
-                     {inputMantissa, inputExp10})
+  void clinger_fast_path_fails_test(const UIntType inputMantissa,
+                                    const int32_t inputExp10) {
+    ASSERT_FALSE(internal::clinger_fast_path<T>({inputMantissa, inputExp10})
                      .has_value());
   }
 
-  template <class T>
-  void eisel_lemire_test(
-      const typename LIBC_NAMESPACE::fputil::FPBits<T>::UIntType inputMantissa,
-      const int32_t inputExp10,
-      const typename LIBC_NAMESPACE::fputil::FPBits<T>::UIntType
-          expectedOutputMantissa,
-      const uint32_t expectedOutputExp2) {
-    typename LIBC_NAMESPACE::fputil::FPBits<T>::UIntType
-        actual_output_mantissa = 0;
+  auto eisel_lemire(const UIntType inputMantissa, const int32_t inputExp10) {
+    return internal::eisel_lemire<T>({inputMantissa, inputExp10});
+  }
+
+  void eisel_lemire_test(const UIntType inputMantissa, const int32_t inputExp10,
+                         const UIntType expectedOutputMantissa,
+                         const uint32_t expectedOutputExp2) {
+    UIntType actual_output_mantissa = 0;
     uint32_t actual_output_exp2 = 0;
 
-    auto result =
-        LIBC_NAMESPACE::internal::eisel_lemire<T>({inputMantissa, inputExp10});
+    auto result = eisel_lemire(inputMantissa, inputExp10);
 
     ASSERT_TRUE(result.has_value());
 
@@ -70,19 +63,15 @@ class LlvmLibcStrToFloatTest : public LIBC_NAMESPACE::testing::Test {
     EXPECT_EQ(actual_output_exp2, expectedOutputExp2);
   }
 
-  template <class T>
-  void simple_decimal_conversion_test(
-      const char *__restrict numStart,
-      const typename LIBC_NAMESPACE::fputil::FPBits<T>::UIntType
-          expectedOutputMantissa,
-      const uint32_t expectedOutputExp2, const int expectedErrno = 0) {
-    typename LIBC_NAMESPACE::fputil::FPBits<T>::UIntType
-        actual_output_mantissa = 0;
+  void simple_decimal_conversion_test(const char *__restrict numStart,
+                                      const UIntType expectedOutputMantissa,
+                                      const uint32_t expectedOutputExp2,
+                                      const int expectedErrno = 0) {
+    UIntType actual_output_mantissa = 0;
     uint32_t actual_output_exp2 = 0;
     libc_errno = 0;
 
-    auto result =
-        LIBC_NAMESPACE::internal::simple_decimal_conversion<T>(numStart);
+    auto result = internal::simple_decimal_conversion<T>(numStart);
 
     actual_output_mantissa = result.num.mantissa;
     actual_output_exp2 = result.num.exponent;
@@ -93,117 +82,123 @@ class LlvmLibcStrToFloatTest : public LIBC_NAMESPACE::testing::Test {
   }
 };
 
-TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64Simple) {
-  clinger_fast_path_test<double>(123, 0, 0xEC00000000000, 1029);
-  clinger_fast_path_test<double>(1234567890123456, 1, 0x5ee2a2eb5a5c0, 1076);
-  clinger_fast_path_test<double>(1234567890, -10, 0xf9add3739635f, 1019);
+using LlvmLibcStrToFloatTestFloat = LlvmLibcStrToFloatTest<float>;
+using LlvmLibcStrToFloatTestDouble = LlvmLibcStrToFloatTest<double>;
+using LlvmLibcStrToFloatTestLongDouble = LlvmLibcStrToFloatTest<long double>;
+
+TEST_F(LlvmLibcStrToFloatTestDouble, ClingerFastPathFloat64Simple) {
+  clinger_fast_path_test(123, 0, 0xEC00000000000, 1029);
+  clinger_fast_path_test(1234567890123456, 1, 0x5ee2a2eb5a5c0, 1076);
+  clinger_fast_path_test(1234567890, -10, 0xf9add3739635f, 1019);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64ExtendedExp) {
-  clinger_fast_path_test<double>(1, 30, 0x93e5939a08cea, 1122);
-  clinger_fast_path_test<double>(1, 37, 0xe17b84357691b, 1145);
-  clinger_fast_path_fails_test<double>(10, 37);
-  clinger_fast_path_fails_test<double>(1, 100);
+TEST_F(LlvmLibcStrToFloatTestDouble, ClingerFastPathFloat64ExtendedExp) {
+  clinger_fast_path_test(1, 30, 0x93e5939a08cea, 1122);
+  clinger_fast_path_test(1, 37, 0xe17b84357691b, 1145);
+  clinger_fast_path_fails_test(10, 37);
+  clinger_fast_path_fails_test(1, 100);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64NegativeExp) {
-  clinger_fast_path_test<double>(1, -10, 0xb7cdfd9d7bdbb, 989);
-  clinger_fast_path_test<double>(1, -20, 0x79ca10c924223, 956);
-  clinger_fast_path_fails_test<double>(1, -25);
+TEST_F(LlvmLibcStrToFloatTestDouble, ClingerFastPathFloat64NegativeExp) {
+  clinger_fast_path_test(1, -10, 0xb7cdfd9d7bdbb, 989);
+  clinger_fast_path_test(1, -20, 0x79ca10c924223, 956);
+  clinger_fast_path_fails_test(1, -25);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat32Simple) {
-  clinger_fast_path_test<float>(123, 0, 0x760000, 133);
-  clinger_fast_path_test<float>(1234567, 1, 0x3c6146, 150);
-  clinger_fast_path_test<float>(12345, -5, 0x7cd35b, 123);
+TEST_F(LlvmLibcStrToFloatTestFloat, ClingerFastPathFloat32Simple) {
+  clinger_fast_path_test(123, 0, 0x760000, 133);
+  clinger_fast_path_test(1234567, 1, 0x3c6146, 150);
+  clinger_fast_path_test(12345, -5, 0x7cd35b, 123);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat32ExtendedExp) {
-  clinger_fast_path_test<float>(1, 15, 0x635fa9, 176);
-  clinger_fast_path_test<float>(1, 17, 0x31a2bc, 183);
-  clinger_fast_path_fails_test<float>(10, 17);
-  clinger_fast_path_fails_test<float>(1, 50);
+TEST_F(LlvmLibcStrToFloatTestFloat, ClingerFastPathFloat32ExtendedExp) {
+  clinger_fast_path_test(1, 15, 0x635fa9, 176);
+  clinger_fast_path_test(1, 17, 0x31a2bc, 183);
+  clinger_fast_path_fails_test(10, 17);
+  clinger_fast_path_fails_test(1, 50);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat32NegativeExp) {
-  clinger_fast_path_test<float>(1, -5, 0x27c5ac, 110);
-  clinger_fast_path_test<float>(1, -10, 0x5be6ff, 93);
-  clinger_fast_path_fails_test<float>(1, -15);
+TEST_F(LlvmLibcStrToFloatTestFloat, ClingerFastPathFloat32NegativeExp) {
+  clinger_fast_path_test(1, -5, 0x27c5ac, 110);
+  clinger_fast_path_test(1, -10, 0x5be6ff, 93);
+  clinger_fast_path_fails_test(1, -15);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat64Simple) {
-  eisel_lemire_test<double>(12345678901234567890u, 1, 0x1AC53A7E04BCDA, 1089);
-  eisel_lemire_test<double>(123, 0, 0x1EC00000000000, 1029);
-  eisel_lemire_test<double>(12345678901234568192u, 0, 0x156A95319D63E2, 1086);
+TEST_F(LlvmLibcStrToFloatTestDouble, EiselLemireFloat64Simple) {
+  eisel_lemire_test(12345678901234567890u, 1, 0x1AC53A7E04BCDA, 1089);
+  eisel_lemire_test(123, 0, 0x1EC00000000000, 1029);
+  eisel_lemire_test(12345678901234568192u, 0, 0x156A95319D63E2, 1086);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat64SpecificFailures) {
+TEST_F(LlvmLibcStrToFloatTestDouble, EiselLemireFloat64SpecificFailures) {
   // These test cases have caused failures in the past.
-  eisel_lemire_test<double>(358416272, -33, 0x1BBB2A68C9D0B9, 941);
-  eisel_lemire_test<double>(2166568064000000238u, -9, 0x10246690000000, 1054);
-  eisel_lemire_test<double>(2794967654709307187u, 1, 0x183e132bc608c8, 1087);
-  eisel_lemire_test<double>(2794967654709307188u, 1, 0x183e132bc608c9, 1087);
+  eisel_lemire_test(358416272, -33, 0x1BBB2A68C9D0B9, 941);
+  eisel_lemire_test(2166568064000000238u, -9, 0x10246690000000, 1054);
+  eisel_lemire_test(2794967654709307187u, 1, 0x183e132bc608c8, 1087);
+  eisel_lemire_test(2794967654709307188u, 1, 0x183e132bc608c9, 1087);
 }
 
 // Check the fallback states for the algorithm:
-TEST_F(LlvmLibcStrToFloatTest, EiselLemireFallbackStates) {
+TEST_F(LlvmLibcStrToFloatTestDouble, EiselLemireFloat64FallbackStates) {
   // This number can't be evaluated by Eisel-Lemire since it's exactly 1024 away
   // from both of its closest floating point approximations
   // (12345678901234548736 and 12345678901234550784)
-  ASSERT_FALSE(
-      LIBC_NAMESPACE::internal::eisel_lemire<double>({12345678901234549760u, 0})
-          .has_value());
-
-  ASSERT_FALSE(
-      LIBC_NAMESPACE::internal::eisel_lemire<float>({20040229, 0}).has_value());
+  ASSERT_FALSE(eisel_lemire(12345678901234549760u, 0).has_value());
 }
 
-TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicWholeNumbers) {
-  simple_decimal_conversion_test<double>("123456789012345678900",
-                                         0x1AC53A7E04BCDA, 1089);
-  simple_decimal_conversion_test<double>("123", 0x1EC00000000000, 1029);
-  simple_decimal_conversion_test<double>("12345678901234549760",
-                                         0x156A95319D63D8, 1086);
+// Check the fallback states for the algorithm:
+TEST_F(LlvmLibcStrToFloatTestFloat, EiselLemireFloat32FallbackStates) {
+  // Same as above but for float.
+  ASSERT_FALSE(eisel_lemire(20040229, 0).has_value());
 }
 
-TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicDecimals) {
-  simple_decimal_conversion_test<double>("1.2345", 0x13c083126e978d, 1023);
-  simple_decimal_conversion_test<double>(".2345", 0x1e04189374bc6a, 1020);
-  simple_decimal_conversion_test<double>(".299792458", 0x132fccb4aca314, 1021);
+TEST_F(LlvmLibcStrToFloatTestDouble,
+       SimpleDecimalConversion64BasicWholeNumbers) {
+  simple_decimal_conversion_test("123456789012345678900", 0x1AC53A7E04BCDA,
+                                 1089);
+  simple_decimal_conversion_test("123", 0x1EC00000000000, 1029);
+  simple_decimal_conversion_test("12345678901234549760", 0x156A95319D63D8,
+                                 1086);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicExponents) {
-  simple_decimal_conversion_test<double>("1e10", 0x12a05f20000000, 1056);
-  simple_decimal_conversion_test<double>("1e-10", 0x1b7cdfd9d7bdbb, 989);
-  simple_decimal_conversion_test<double>("1e300", 0x17e43c8800759c, 2019);
-  simple_decimal_conversion_test<double>("1e-300", 0x156e1fc2f8f359, 26);
+TEST_F(LlvmLibcStrToFloatTestDouble, SimpleDecimalConversion64BasicDecimals) {
+  simple_decimal_conversion_test("1.2345", 0x13c083126e978d, 1023);
+  simple_decimal_conversion_test(".2345", 0x1e04189374bc6a, 1020);
+  simple_decimal_conversion_test(".299792458", 0x132fccb4aca314, 1021);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicSubnormals) {
-  simple_decimal_conversion_test<double>("1e-320", 0x7e8, 0, ERANGE);
-  simple_decimal_conversion_test<double>("1e-308", 0x730d67819e8d2, 0, ERANGE);
-  simple_decimal_conversion_test<double>("2.9e-308", 0x14da6df5e4bcc8, 1);
+TEST_F(LlvmLibcStrToFloatTestDouble, SimpleDecimalConversion64BasicExponents) {
+  simple_decimal_conversion_test("1e10", 0x12a05f20000000, 1056);
+  simple_decimal_conversion_test("1e-10", 0x1b7cdfd9d7bdbb, 989);
+  simple_decimal_conversion_test("1e300", 0x17e43c8800759c, 2019);
+  simple_decimal_conversion_test("1e-300", 0x156e1fc2f8f359, 26);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64SubnormalRounding) {
+TEST_F(LlvmLibcStrToFloatTestDouble, SimpleDecimalConversion64BasicSubnormals) {
+  simple_decimal_conversion_test("1e-320", 0x7e8, 0, ERANGE);
+  simple_decimal_conversion_test("1e-308", 0x730d67819e8d2, 0, ERANGE);
+  simple_decimal_conversion_test("2.9e-308", 0x14da6df5e4bcc8, 1);
+}
 
+TEST_F(LlvmLibcStrToFloatTestDouble,
+       SimpleDecimalConversion64SubnormalRounding) {
   // Technically you can keep adding digits until you hit the truncation limit,
   // but this is the shortest string that results in the maximum subnormal that
   // I found.
-  simple_decimal_conversion_test<double>("2.225073858507201e-308",
-                                         0xfffffffffffff, 0, ERANGE);
+  simple_decimal_conversion_test("2.225073858507201e-308", 0xfffffffffffff, 0,
+                                 ERANGE);
 
   // Same here, if you were to extend the max subnormal out for another 800
   // digits, incrementing any one of those digits would create a normal number.
-  simple_decimal_conversion_test<double>("2.2250738585072012e-308",
-                                         0x10000000000000, 1);
+  simple_decimal_conversion_test("2.2250738585072012e-308", 0x10000000000000,
+                                 1);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion32SpecificFailures) {
-  simple_decimal_conversion_test<float>(
+TEST_F(LlvmLibcStrToFloatTestFloat, SimpleDecimalConversion32SpecificFailures) {
+  simple_decimal_conversion_test(
       "1.4012984643248170709237295832899161312802619418765e-45", 0x1, 0,
       ERANGE);
-  simple_decimal_conversion_test<float>(
+  simple_decimal_conversion_test(
       "7."
       "006492321624085354618647916449580656401309709382578858785341419448955413"
       "42930300743319094181060791015625e-46",
@@ -216,8 +211,7 @@ TEST(LlvmLibcStrToFloatTest, SimpleDecimalConversionExtraTypes) {
 
   libc_errno = 0;
   auto float_result =
-      LIBC_NAMESPACE::internal::simple_decimal_conversion<float>(
-          "123456789012345678900");
+      internal::simple_decimal_conversion<float>("123456789012345678900");
   float_output_mantissa = float_result.num.mantissa;
   output_exp2 = float_result.num.exponent;
   EXPECT_EQ(float_output_mantissa, uint32_t(0xd629d4));
@@ -229,8 +223,7 @@ TEST(LlvmLibcStrToFloatTest, SimpleDecimalConversionExtraTypes) {
 
   libc_errno = 0;
   auto double_result =
-      LIBC_NAMESPACE::internal::simple_decimal_conversion<double>(
-          "123456789012345678900");
+      internal::simple_decimal_conversion<double>("123456789012345678900");
 
   double_output_mantissa = double_result.num.mantissa;
   output_exp2 = double_result.num.exponent;
@@ -241,26 +234,25 @@ TEST(LlvmLibcStrToFloatTest, SimpleDecimalConversionExtraTypes) {
 }
 
 #if defined(LIBC_LONG_DOUBLE_IS_FLOAT64)
-TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat64AsLongDouble) {
-  eisel_lemire_test<long double>(123, 0, 0x1EC00000000000, 1029);
+TEST_F(LlvmLibcStrToFloatTestLongDouble, EiselLemireFloat64AsLongDouble) {
+  eisel_lemire_test(123, 0, 0x1EC00000000000, 1029);
 }
 #elif defined(LIBC_LONG_DOUBLE_IS_X86_FLOAT80)
-TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80Simple) {
-  eisel_lemire_test<long double>(123, 0, 0xf600000000000000, 16389);
-  eisel_lemire_test<long double>(12345678901234568192u, 0, 0xab54a98ceb1f0c00,
-                                 16446);
+TEST_F(LlvmLibcStrToFloatTestLongDouble, EiselLemireFloat80Simple) {
+  eisel_lemire_test(123, 0, 0xf600000000000000, 16389);
+  eisel_lemire_test(12345678901234568192u, 0, 0xab54a98ceb1f0c00, 16446);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80LongerMantissa) {
-  eisel_lemire_test<long double>((UInt128(0x1234567812345678) << 64) +
-                                     UInt128(0x1234567812345678),
-                                 0, 0x91a2b3c091a2b3c1, 16507);
-  eisel_lemire_test<long double>((UInt128(0x1234567812345678) << 64) +
-                                     UInt128(0x1234567812345678),
-                                 300, 0xd97757de56adb65c, 17503);
-  eisel_lemire_test<long double>((UInt128(0x1234567812345678) << 64) +
-                                     UInt128(0x1234567812345678),
-                                 -300, 0xc30feb9a7618457d, 15510);
+TEST_F(LlvmLibcStrToFloatTestLongDouble, EiselLemireFloat80LongerMantissa) {
+  eisel_lemire_test((UInt128(0x1234567812345678) << 64) +
+                        UInt128(0x1234567812345678),
+                    0, 0x91a2b3c091a2b3c1, 16507);
+  eisel_lemire_test((UInt128(0x1234567812345678) << 64) +
+                        UInt128(0x1234567812345678),
+                    300, 0xd97757de56adb65c, 17503);
+  eisel_lemire_test((UInt128(0x1234567812345678) << 64) +
+                        UInt128(0x1234567812345678),
+                    -300, 0xc30feb9a7618457d, 15510);
 }
 
 // These tests check numbers at the edge of the DETAILED_POWERS_OF_TEN table.
@@ -271,51 +263,47 @@ TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80LongerMantissa) {
 // maximum exponent would need to be about 5000, leading to a 10,000 entry
 // table). This would have significant memory and storage costs all the time to
 // speed up a relatively uncommon path.
-TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80TableLimits) {
-  eisel_lemire_test<long double>(1, 347, 0xd13eb46469447567, 17535);
-  eisel_lemire_test<long double>(1, -348, 0xfa8fd5a0081c0288, 15226);
+TEST_F(LlvmLibcStrToFloatTestLongDouble, EiselLemireFloat80TableLimits) {
+  eisel_lemire_test(1, 347, 0xd13eb46469447567, 17535);
+  eisel_lemire_test(1, -348, 0xfa8fd5a0081c0288, 15226);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat80Fallback) {
+TEST_F(LlvmLibcStrToFloatTestLongDouble, EiselLemireFloat80Fallback) {
   // This number is halfway between two possible results, and the algorithm
   // can't determine which is correct.
-  ASSERT_FALSE(LIBC_NAMESPACE::internal::eisel_lemire<long double>(
-                   {12345678901234567890u, 1})
-                   .has_value());
+  ASSERT_FALSE(eisel_lemire(12345678901234567890u, 1).has_value());
 
   // These numbers' exponents are out of range for the current powers of ten
   // table.
-  ASSERT_FALSE(LIBC_NAMESPACE::internal::eisel_lemire<long double>({1, 1000})
-                   .has_value());
-  ASSERT_FALSE(LIBC_NAMESPACE::internal::eisel_lemire<long double>({1, -1000})
-                   .has_value());
+  ASSERT_FALSE(eisel_lemire(1, 1000).has_value());
+  ASSERT_FALSE(eisel_lemire(1, -1000).has_value());
 }
 #else // Quad precision long double
-TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat128Simple) {
-  eisel_lemire_test<long double>(123, 0, (UInt128(0x1ec0000000000) << 64),
-                                 16389);
-  eisel_lemire_test<long double>(
+TEST_F(LlvmLibcStrToFloatTestLongDouble, EiselLemireFloat128Simple) {
+  eisel_lemire_test(123, 0, (UInt128(0x1ec0000000000) << 64), 16389);
+  eisel_lemire_test(
       12345678901234568192u, 0,
       (UInt128(0x156a95319d63e) << 64) + UInt128(0x1800000000000000), 16446);
 }
 
-TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat128LongerMantissa)...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/75353


More information about the llvm-commits mailing list