[libc][NFC] Reduce type clutter in str_to_float_test #75353
Closed
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@llvm/pr-subscribers-libc Author: Guillaume Chatelet (gchatelet) ChangesPatch is 21.91 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/75353.diff 3 Files Affected:
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]
|
|
@michaelrj-google my original goal was to remove |
lntue
reviewed
Dec 13, 2023
There was a problem hiding this comment.
Without the types it's actually a bit hard to see which type is being tested. Does it make sense to split this test into several files: str_to_float.h containing the test template, then str_to_float.cpp, str_to_double.cpp, str_to_long_double.cpp or something like that for test specializations.
|
I agree with Tue that the types being explicit is important. Splitting into multiple files sounds like a good overall solution. |
|
I'm closing this PR to prevent confusion. I'll ping here with the "split" patch. |
gchatelet
added a commit
that referenced
this pull request
Dec 15, 2023
This is a follow up on #75353.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
No description provided.