[libc-commits] [libc] 25226f3 - [libc] apply formatting to tests
Michael Jones via libc-commits
libc-commits at lists.llvm.org
Wed Dec 22 10:53:30 PST 2021
Author: Michael Jones
Date: 2021-12-22T10:53:25-08:00
New Revision: 25226f3e4a42f70124995c16e22ff870efa30c6d
URL: https://github.com/llvm/llvm-project/commit/25226f3e4a42f70124995c16e22ff870efa30c6d
DIFF: https://github.com/llvm/llvm-project/commit/25226f3e4a42f70124995c16e22ff870efa30c6d.diff
LOG: [libc] apply formatting to tests
Apply the formatting rules that were applied to the libc/src directory
to the libc/test directory, as well as the files in libc/utils that are
included by the tests. This does not include automated enforcement.
Reviewed By: sivachandra, lntue
Differential Revision: https://reviews.llvm.org/D116127
Added:
Modified:
libc/benchmarks/LibcBenchmarkTest.cpp
libc/benchmarks/automemcpy/lib/ResultAnalyzerMain.cpp
libc/test/config/linux/x86_64/syscall_test.cpp
libc/test/src/__support/str_to_float_test.cpp
libc/test/src/fenv/enabled_exceptions_test.cpp
libc/test/src/fenv/exception_status_test.cpp
libc/test/src/math/CeilTest.h
libc/test/src/math/CopySignTest.h
libc/test/src/math/FAbsTest.h
libc/test/src/math/FDimTest.h
libc/test/src/math/FMaxTest.h
libc/test/src/math/FMinTest.h
libc/test/src/math/FloorTest.h
libc/test/src/math/FmaTest.h
libc/test/src/math/FrexpTest.h
libc/test/src/math/HypotTest.h
libc/test/src/math/ILogbTest.h
libc/test/src/math/LdExpTest.h
libc/test/src/math/LogbTest.h
libc/test/src/math/ModfTest.h
libc/test/src/math/NextAfterTest.h
libc/test/src/math/RIntTest.h
libc/test/src/math/RemQuoTest.h
libc/test/src/math/RoundTest.h
libc/test/src/math/RoundToIntegerTest.h
libc/test/src/math/SqrtTest.h
libc/test/src/math/TruncTest.h
libc/test/src/math/cos_test.cpp
libc/test/src/math/cosf_test.cpp
libc/test/src/math/exp2f_test.cpp
libc/test/src/math/expf_test.cpp
libc/test/src/math/expm1f_test.cpp
libc/test/src/math/fdim_test.cpp
libc/test/src/math/fdimf_test.cpp
libc/test/src/math/fdiml_test.cpp
libc/test/src/math/fma_test.cpp
libc/test/src/math/fmaf_test.cpp
libc/test/src/math/hypot_test.cpp
libc/test/src/math/hypotf_test.cpp
libc/test/src/math/ilogb_test.cpp
libc/test/src/math/ilogbf_test.cpp
libc/test/src/math/ilogbl_test.cpp
libc/test/src/math/logf_test.cpp
libc/test/src/math/sdcomp26094.h
libc/test/src/math/sin_test.cpp
libc/test/src/math/sincosf_test.cpp
libc/test/src/math/sinf_test.cpp
libc/test/src/math/tan_test.cpp
libc/test/src/signal/sigprocmask_test.cpp
libc/test/src/stdlib/atof_test.cpp
libc/test/src/stdlib/bsearch_test.cpp
libc/test/src/stdlib/qsort_test.cpp
libc/test/src/stdlib/strtod_test.cpp
libc/test/src/stdlib/strtof_test.cpp
libc/test/src/stdlib/strtold_test.cpp
libc/test/src/string/bcmp_test.cpp
libc/test/src/string/bzero_test.cpp
libc/test/src/string/memcmp_test.cpp
libc/test/src/string/memcpy_test.cpp
libc/test/src/string/memset_test.cpp
libc/test/src/string/stpcpy_test.cpp
libc/test/src/threads/call_once_test.cpp
libc/test/src/threads/mtx_test.cpp
libc/test/src/time/TmHelper.h
libc/test/src/time/asctime_r_test.cpp
libc/test/src/time/asctime_test.cpp
libc/test/src/time/mktime_test.cpp
libc/test/src/unistd/write_test.cpp
libc/utils/UnitTest/LibcTest.cpp
libc/utils/testutils/ExecuteFunction.h
libc/utils/testutils/ExecuteFunctionUnix.cpp
libc/utils/testutils/FDReader.h
libc/utils/testutils/FDReaderUnix.cpp
libc/utils/testutils/StreamWrapper.cpp
libc/utils/testutils/StreamWrapper.h
Removed:
################################################################################
diff --git a/libc/benchmarks/LibcBenchmarkTest.cpp b/libc/benchmarks/LibcBenchmarkTest.cpp
index c9b21e48e8f70..e4afab531fef5 100644
--- a/libc/benchmarks/LibcBenchmarkTest.cpp
+++ b/libc/benchmarks/LibcBenchmarkTest.cpp
@@ -50,9 +50,9 @@ class LibcBenchmark : public ::testing::Test {
}
protected:
- void SetUp() override { Options.Log = BenchmarkLog::Full; }
+ void set_up() override { Options.Log = BenchmarkLog::Full; }
- void TearDown() override {
+ void tear_down() override {
// We make sure all the expected measurements were performed.
if (MaybeTimepoints)
EXPECT_THAT(*MaybeTimepoints, IsEmpty());
diff --git a/libc/benchmarks/automemcpy/lib/ResultAnalyzerMain.cpp b/libc/benchmarks/automemcpy/lib/ResultAnalyzerMain.cpp
index 6a657e432c18f..47e3200f9dccb 100644
--- a/libc/benchmarks/automemcpy/lib/ResultAnalyzerMain.cpp
+++ b/libc/benchmarks/automemcpy/lib/ResultAnalyzerMain.cpp
@@ -94,7 +94,7 @@ JsonFile parseJsonResultFile(StringRef Filename) {
json::Path::Root Root;
JsonFile JF;
if (!fromJSON(JsonValue, JF, Root))
- ExitOnErr(Root.getError());
+ ExitOnErr(Root.get_error());
return JF;
}
diff --git a/libc/test/config/linux/x86_64/syscall_test.cpp b/libc/test/config/linux/x86_64/syscall_test.cpp
index 971b571fce4d7..eb2205aa4fb65 100644
--- a/libc/test/config/linux/x86_64/syscall_test.cpp
+++ b/libc/test/config/linux/x86_64/syscall_test.cpp
@@ -39,6 +39,6 @@ TEST(LlvmLibcX86_64_SyscallTest, APITest) {
return __llvm_libc::syscall(n, a1, a2, a3, a4, a5, a6);
});
- Function<long(long, void *)> notLongType(
+ Function<long(long, void *)> not_long_type(
[](long n, void *a1) { return __llvm_libc::syscall(n, a1); });
}
diff --git a/libc/test/src/__support/str_to_float_test.cpp b/libc/test/src/__support/str_to_float_test.cpp
index 5728185e54bb5..44f0cecec76ca 100644
--- a/libc/test/src/__support/str_to_float_test.cpp
+++ b/libc/test/src/__support/str_to_float_test.cpp
@@ -14,201 +14,209 @@
class LlvmLibcStrToFloatTest : public __llvm_libc::testing::Test {
public:
template <class T>
- void ClingerFastPathTest(
+ void clinger_fast_path_test(
const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa,
const int32_t inputExp10,
const typename __llvm_libc::fputil::FPBits<T>::UIntType
expectedOutputMantissa,
const uint32_t expectedOutputExp2) {
- typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0;
- uint32_t actualOutputExp2 = 0;
+ typename __llvm_libc::fputil::FPBits<T>::UIntType actual_output_mantissa =
+ 0;
+ uint32_t actual_output_exp2 = 0;
ASSERT_TRUE(__llvm_libc::internal::clinger_fast_path<T>(
- inputMantissa, inputExp10, &actualOutputMantissa, &actualOutputExp2));
- EXPECT_EQ(actualOutputMantissa, expectedOutputMantissa);
- EXPECT_EQ(actualOutputExp2, expectedOutputExp2);
+ inputMantissa, inputExp10, &actual_output_mantissa,
+ &actual_output_exp2));
+ EXPECT_EQ(actual_output_mantissa, expectedOutputMantissa);
+ EXPECT_EQ(actual_output_exp2, expectedOutputExp2);
}
template <class T>
- void ClingerFastPathFailsTest(
+ void clinger_fast_path_fails_test(
const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa,
const int32_t inputExp10) {
- typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0;
- uint32_t actualOutputExp2 = 0;
+ typename __llvm_libc::fputil::FPBits<T>::UIntType actual_output_mantissa =
+ 0;
+ uint32_t actual_output_exp2 = 0;
ASSERT_FALSE(__llvm_libc::internal::clinger_fast_path<T>(
- inputMantissa, inputExp10, &actualOutputMantissa, &actualOutputExp2));
+ inputMantissa, inputExp10, &actual_output_mantissa,
+ &actual_output_exp2));
}
template <class T>
- void EiselLemireTest(
+ void eisel_lemire_test(
const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa,
const int32_t inputExp10,
const typename __llvm_libc::fputil::FPBits<T>::UIntType
expectedOutputMantissa,
const uint32_t expectedOutputExp2) {
- typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0;
- uint32_t actualOutputExp2 = 0;
+ typename __llvm_libc::fputil::FPBits<T>::UIntType actual_output_mantissa =
+ 0;
+ uint32_t actual_output_exp2 = 0;
ASSERT_TRUE(__llvm_libc::internal::eisel_lemire<T>(
- inputMantissa, inputExp10, &actualOutputMantissa, &actualOutputExp2));
- EXPECT_EQ(actualOutputMantissa, expectedOutputMantissa);
- EXPECT_EQ(actualOutputExp2, expectedOutputExp2);
+ inputMantissa, inputExp10, &actual_output_mantissa,
+ &actual_output_exp2));
+ EXPECT_EQ(actual_output_mantissa, expectedOutputMantissa);
+ EXPECT_EQ(actual_output_exp2, expectedOutputExp2);
}
template <class T>
- void SimpleDecimalConversionTest(
+ void simple_decimal_conversion_test(
const char *__restrict numStart,
const typename __llvm_libc::fputil::FPBits<T>::UIntType
expectedOutputMantissa,
const uint32_t expectedOutputExp2, const int expectedErrno = 0) {
- typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0;
- uint32_t actualOutputExp2 = 0;
+ typename __llvm_libc::fputil::FPBits<T>::UIntType actual_output_mantissa =
+ 0;
+ uint32_t actual_output_exp2 = 0;
errno = 0;
__llvm_libc::internal::simple_decimal_conversion<T>(
- numStart, &actualOutputMantissa, &actualOutputExp2);
- EXPECT_EQ(actualOutputMantissa, expectedOutputMantissa);
- EXPECT_EQ(actualOutputExp2, expectedOutputExp2);
+ numStart, &actual_output_mantissa, &actual_output_exp2);
+ EXPECT_EQ(actual_output_mantissa, expectedOutputMantissa);
+ EXPECT_EQ(actual_output_exp2, expectedOutputExp2);
EXPECT_EQ(errno, expectedErrno);
}
};
TEST(LlvmLibcStrToFloatTest, LeadingZeroes) {
- uint64_t testNum64 = 1;
- uint32_t numOfZeroes = 63;
+ uint64_t test_num64 = 1;
+ uint32_t num_of_zeroes = 63;
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(0), 64u);
- for (; numOfZeroes < 64; testNum64 <<= 1, numOfZeroes--) {
- EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(testNum64),
- numOfZeroes);
+ for (; num_of_zeroes < 64; test_num64 <<= 1, num_of_zeroes--) {
+ EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(test_num64),
+ num_of_zeroes);
}
- testNum64 = 3;
- numOfZeroes = 62;
- for (; numOfZeroes > 63; testNum64 <<= 1, numOfZeroes--) {
- EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(testNum64),
- numOfZeroes);
+ test_num64 = 3;
+ num_of_zeroes = 62;
+ for (; num_of_zeroes > 63; test_num64 <<= 1, num_of_zeroes--) {
+ EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(test_num64),
+ num_of_zeroes);
}
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(0xffffffffffffffff),
0u);
- testNum64 = 1;
- numOfZeroes = 63;
- for (; numOfZeroes > 63; testNum64 = (testNum64 << 1) + 1, numOfZeroes--) {
- EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(testNum64),
- numOfZeroes);
+ test_num64 = 1;
+ num_of_zeroes = 63;
+ for (; num_of_zeroes > 63;
+ test_num64 = (test_num64 << 1) + 1, num_of_zeroes--) {
+ EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(test_num64),
+ num_of_zeroes);
}
- uint64_t testNum32 = 1;
- numOfZeroes = 31;
+ uint64_t test_num32 = 1;
+ num_of_zeroes = 31;
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(0), 32u);
- for (; numOfZeroes < 32; testNum32 <<= 1, numOfZeroes--) {
- EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(testNum32),
- numOfZeroes);
+ for (; num_of_zeroes < 32; test_num32 <<= 1, num_of_zeroes--) {
+ EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(test_num32),
+ num_of_zeroes);
}
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(0xffffffff), 0u);
}
TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64Simple) {
- ClingerFastPathTest<double>(123, 0, 0xEC00000000000, 1029);
- ClingerFastPathTest<double>(1234567890123456, 1, 0x5ee2a2eb5a5c0, 1076);
- ClingerFastPathTest<double>(1234567890, -10, 0xf9add3739635f, 1019);
+ 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);
}
TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64ExtendedExp) {
- ClingerFastPathTest<double>(1, 30, 0x93e5939a08cea, 1122);
- ClingerFastPathTest<double>(1, 37, 0xe17b84357691b, 1145);
- ClingerFastPathFailsTest<double>(10, 37);
- ClingerFastPathFailsTest<double>(1, 100);
+ 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(LlvmLibcStrToFloatTest, ClingerFastPathFloat64NegativeExp) {
- ClingerFastPathTest<double>(1, -10, 0xb7cdfd9d7bdbb, 989);
- ClingerFastPathTest<double>(1, -20, 0x79ca10c924223, 956);
- ClingerFastPathFailsTest<double>(1, -25);
+ 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(LlvmLibcStrToFloatTest, ClingerFastPathFloat32Simple) {
- ClingerFastPathTest<float>(123, 0, 0x760000, 133);
- ClingerFastPathTest<float>(1234567, 1, 0x3c6146, 150);
- ClingerFastPathTest<float>(12345, -5, 0x7cd35b, 123);
+ 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(LlvmLibcStrToFloatTest, ClingerFastPathFloat32ExtendedExp) {
- ClingerFastPathTest<float>(1, 15, 0x635fa9, 176);
- ClingerFastPathTest<float>(1, 17, 0x31a2bc, 183);
- ClingerFastPathFailsTest<float>(10, 17);
- ClingerFastPathFailsTest<float>(1, 50);
+ 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(LlvmLibcStrToFloatTest, ClingerFastPathFloat32NegativeExp) {
- ClingerFastPathTest<float>(1, -5, 0x27c5ac, 110);
- ClingerFastPathTest<float>(1, -10, 0x5be6ff, 93);
- ClingerFastPathFailsTest<float>(1, -15);
+ 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(LlvmLibcStrToFloatTest, EiselLemireFloat64Simple) {
- EiselLemireTest<double>(12345678901234567890u, 1, 0x1AC53A7E04BCDA, 1089);
- EiselLemireTest<double>(123, 0, 0x1EC00000000000, 1029);
- EiselLemireTest<double>(12345678901234568192u, 0, 0x156A95319D63E2, 1086);
+ 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(LlvmLibcStrToFloatTest, EiselLemireFloat64SpecificFailures) {
// These test cases have caused failures in the past.
- EiselLemireTest<double>(358416272, -33, 0x1BBB2A68C9D0B9, 941);
- EiselLemireTest<double>(2166568064000000238u, -9, 0x10246690000000, 1054);
- EiselLemireTest<double>(2794967654709307187u, 1, 0x183e132bc608c8, 1087);
- EiselLemireTest<double>(2794967654709307188u, 1, 0x183e132bc608c9, 1087);
+ 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);
}
TEST_F(LlvmLibcStrToFloatTest, EiselLemireFallbackStates) {
// Check the fallback states for the algorithm:
- uint32_t floatOutputMantissa = 0;
- uint64_t doubleOutputMantissa = 0;
- __uint128_t tooLongMantissa = 0;
- uint32_t outputExp2 = 0;
+ uint32_t float_output_mantissa = 0;
+ uint64_t double_output_mantissa = 0;
+ __uint128_t too_long_mantissa = 0;
+ uint32_t output_exp2 = 0;
// This Eisel-Lemire implementation doesn't support long doubles yet.
ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<long double>(
- tooLongMantissa, 0, &tooLongMantissa, &outputExp2));
+ too_long_mantissa, 0, &too_long_mantissa, &output_exp2));
// 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(__llvm_libc::internal::eisel_lemire<double>(
- 12345678901234549760u, 0, &doubleOutputMantissa, &outputExp2));
+ 12345678901234549760u, 0, &double_output_mantissa, &output_exp2));
ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<float>(
- 20040229, 0, &floatOutputMantissa, &outputExp2));
+ 20040229, 0, &float_output_mantissa, &output_exp2));
}
TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicWholeNumbers) {
- SimpleDecimalConversionTest<double>("123456789012345678900", 0x1AC53A7E04BCDA,
- 1089);
- SimpleDecimalConversionTest<double>("123", 0x1EC00000000000, 1029);
- SimpleDecimalConversionTest<double>("12345678901234549760", 0x156A95319D63D8,
- 1086);
+ simple_decimal_conversion_test<double>("123456789012345678900",
+ 0x1AC53A7E04BCDA, 1089);
+ simple_decimal_conversion_test<double>("123", 0x1EC00000000000, 1029);
+ simple_decimal_conversion_test<double>("12345678901234549760",
+ 0x156A95319D63D8, 1086);
}
TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicDecimals) {
- SimpleDecimalConversionTest<double>("1.2345", 0x13c083126e978d, 1023);
- SimpleDecimalConversionTest<double>(".2345", 0x1e04189374bc6a, 1020);
- SimpleDecimalConversionTest<double>(".299792458", 0x132fccb4aca314, 1021);
+ 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(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicExponents) {
- SimpleDecimalConversionTest<double>("1e10", 0x12a05f20000000, 1056);
- SimpleDecimalConversionTest<double>("1e-10", 0x1b7cdfd9d7bdbb, 989);
- SimpleDecimalConversionTest<double>("1e300", 0x17e43c8800759c, 2019);
- SimpleDecimalConversionTest<double>("1e-300", 0x156e1fc2f8f359, 26);
+ 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(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicSubnormals) {
- SimpleDecimalConversionTest<double>("1e-320", 0x7e8, 0, ERANGE);
- SimpleDecimalConversionTest<double>("1e-308", 0x730d67819e8d2, 0, ERANGE);
- SimpleDecimalConversionTest<double>("2.9e-308", 0x14da6df5e4bcc8, 1);
+ 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(LlvmLibcStrToFloatTest, SimpleDecimalConversion64SubnormalRounding) {
@@ -216,40 +224,40 @@ TEST_F(LlvmLibcStrToFloatTest, 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.
- SimpleDecimalConversionTest<double>("2.225073858507201e-308", 0xfffffffffffff,
- 0, ERANGE);
+ simple_decimal_conversion_test<double>("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.
- SimpleDecimalConversionTest<double>("2.2250738585072012e-308",
- 0x10000000000000, 1);
+ simple_decimal_conversion_test<double>("2.2250738585072012e-308",
+ 0x10000000000000, 1);
}
TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion32SpecificFailures) {
- SimpleDecimalConversionTest<float>(
+ simple_decimal_conversion_test<float>(
"1.4012984643248170709237295832899161312802619418765e-45", 0x1, 0,
ERANGE);
}
TEST(LlvmLibcStrToFloatTest, SimpleDecimalConversionExtraTypes) {
- uint32_t floatOutputMantissa = 0;
- uint32_t outputExp2 = 0;
+ uint32_t float_output_mantissa = 0;
+ uint32_t output_exp2 = 0;
errno = 0;
__llvm_libc::internal::simple_decimal_conversion<float>(
- "123456789012345678900", &floatOutputMantissa, &outputExp2);
- EXPECT_EQ(floatOutputMantissa, uint32_t(0xd629d4));
- EXPECT_EQ(outputExp2, uint32_t(193));
+ "123456789012345678900", &float_output_mantissa, &output_exp2);
+ EXPECT_EQ(float_output_mantissa, uint32_t(0xd629d4));
+ EXPECT_EQ(output_exp2, uint32_t(193));
EXPECT_EQ(errno, 0);
- uint64_t doubleOutputMantissa = 0;
- outputExp2 = 0;
+ uint64_t double_output_mantissa = 0;
+ output_exp2 = 0;
errno = 0;
__llvm_libc::internal::simple_decimal_conversion<double>(
- "123456789012345678900", &doubleOutputMantissa, &outputExp2);
- EXPECT_EQ(doubleOutputMantissa, uint64_t(0x1AC53A7E04BCDA));
- EXPECT_EQ(outputExp2, uint32_t(1089));
+ "123456789012345678900", &double_output_mantissa, &output_exp2);
+ EXPECT_EQ(double_output_mantissa, uint64_t(0x1AC53A7E04BCDA));
+ EXPECT_EQ(output_exp2, uint32_t(1089));
EXPECT_EQ(errno, 0);
// TODO(michaelrj): Get long double support working.
diff --git a/libc/test/src/fenv/enabled_exceptions_test.cpp b/libc/test/src/fenv/enabled_exceptions_test.cpp
index acc3b09d4aca9..75463c34898ab 100644
--- a/libc/test/src/fenv/enabled_exceptions_test.cpp
+++ b/libc/test/src/fenv/enabled_exceptions_test.cpp
@@ -46,7 +46,7 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
// We '|' the individual exception flags instead of using FE_ALL_EXCEPT
// as it can include non-standard extensions. Note that we should be able
// to compile this file with headers from other libcs as well.
- constexpr int allExcepts =
+ constexpr int ALL_EXCEPTS =
FE_DIVBYZERO | FE_INVALID | FE_INEXACT | FE_OVERFLOW | FE_UNDERFLOW;
for (int e : excepts) {
@@ -59,7 +59,7 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
// can raise FE_INEXACT as well, we don't verify the other
// exception flags when FE_INEXACT is enabled.
if (e != FE_INEXACT) {
- int others = allExcepts & ~e;
+ int others = ALL_EXCEPTS & ~e;
ASSERT_EQ(__llvm_libc::feraiseexcept(others), 0);
ASSERT_EQ(__llvm_libc::fetestexcept(others), others);
}
diff --git a/libc/test/src/fenv/exception_status_test.cpp b/libc/test/src/fenv/exception_status_test.cpp
index a7c0164d370de..f897e65439f2a 100644
--- a/libc/test/src/fenv/exception_status_test.cpp
+++ b/libc/test/src/fenv/exception_status_test.cpp
@@ -25,7 +25,7 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
FE_UNDERFLOW};
- constexpr int allExcepts =
+ constexpr int ALL_EXCEPTS =
FE_DIVBYZERO | FE_INVALID | FE_INEXACT | FE_OVERFLOW | FE_UNDERFLOW;
for (int e : excepts) {
@@ -112,8 +112,8 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
}
}
- int r = __llvm_libc::feraiseexcept(allExcepts);
+ int r = __llvm_libc::feraiseexcept(ALL_EXCEPTS);
ASSERT_EQ(r, 0);
- int s = __llvm_libc::fetestexcept(allExcepts);
- ASSERT_EQ(s, allExcepts);
+ int s = __llvm_libc::fetestexcept(ALL_EXCEPTS);
+ ASSERT_EQ(s, ALL_EXCEPTS);
}
diff --git a/libc/test/src/math/CeilTest.h b/libc/test/src/math/CeilTest.h
index a45b0d5773560..64be0a316ef30 100644
--- a/libc/test/src/math/CeilTest.h
+++ b/libc/test/src/math/CeilTest.h
@@ -64,9 +64,9 @@ template <typename T> class CeilTest : public __llvm_libc::testing::Test {
}
void testRange(CeilFunc func) {
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/CopySignTest.h b/libc/test/src/math/CopySignTest.h
index 46d4c3781184c..20f400197ceb5 100644
--- a/libc/test/src/math/CopySignTest.h
+++ b/libc/test/src/math/CopySignTest.h
@@ -33,9 +33,9 @@ template <typename T> class CopySignTest : public __llvm_libc::testing::Test {
}
void testRange(CopySignFunc func) {
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/FAbsTest.h b/libc/test/src/math/FAbsTest.h
index d4377f7110da0..fe163f6ff672e 100644
--- a/libc/test/src/math/FAbsTest.h
+++ b/libc/test/src/math/FAbsTest.h
@@ -32,9 +32,9 @@ template <typename T> class FAbsTest : public __llvm_libc::testing::Test {
}
void testRange(FabsFunc func) {
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/FDimTest.h b/libc/test/src/math/FDimTest.h
index 029c6390f0767..587913acb1f1c 100644
--- a/libc/test/src/math/FDimTest.h
+++ b/libc/test/src/math/FDimTest.h
@@ -19,7 +19,7 @@ class FDimTestTemplate : public __llvm_libc::testing::Test {
using FPBits = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType;
- void testNaNArg(FuncPtr func) {
+ void test_na_n_arg(FuncPtr func) {
EXPECT_FP_EQ(nan, func(nan, inf));
EXPECT_FP_EQ(nan, func(neg_inf, nan));
EXPECT_FP_EQ(nan, func(nan, zero));
@@ -29,7 +29,7 @@ class FDimTestTemplate : public __llvm_libc::testing::Test {
EXPECT_FP_EQ(func(nan, nan), nan);
}
- void testInfArg(FuncPtr func) {
+ void test_inf_arg(FuncPtr func) {
EXPECT_FP_EQ(zero, func(neg_inf, inf));
EXPECT_FP_EQ(inf, func(inf, zero));
EXPECT_FP_EQ(zero, func(neg_zero, inf));
@@ -37,7 +37,7 @@ class FDimTestTemplate : public __llvm_libc::testing::Test {
EXPECT_FP_EQ(zero, func(T(-1.2345), inf));
}
- void testNegInfArg(FuncPtr func) {
+ void test_neg_inf_arg(FuncPtr func) {
EXPECT_FP_EQ(inf, func(inf, neg_inf));
EXPECT_FP_EQ(zero, func(neg_inf, zero));
EXPECT_FP_EQ(inf, func(neg_zero, neg_inf));
@@ -45,18 +45,18 @@ class FDimTestTemplate : public __llvm_libc::testing::Test {
EXPECT_FP_EQ(inf, func(T(1.2345), neg_inf));
}
- void testBothZero(FuncPtr func) {
+ void test_both_zero(FuncPtr func) {
EXPECT_FP_EQ(zero, func(zero, zero));
EXPECT_FP_EQ(zero, func(zero, neg_zero));
EXPECT_FP_EQ(zero, func(neg_zero, zero));
EXPECT_FP_EQ(zero, func(neg_zero, neg_zero));
}
- void testInRange(FuncPtr func) {
- constexpr UIntType count = 10000001;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
- ++i, v += step, w -= step) {
+ void test_in_range(FuncPtr func) {
+ constexpr UIntType COUNT = 10000001;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
+ ++i, v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/FMaxTest.h b/libc/test/src/math/FMaxTest.h
index c72dad5062eb8..4a0b2151a9cc3 100644
--- a/libc/test/src/math/FMaxTest.h
+++ b/libc/test/src/math/FMaxTest.h
@@ -55,10 +55,10 @@ template <typename T> class FMaxTest : public __llvm_libc::testing::Test {
}
void testRange(FMaxFunc func) {
- constexpr UIntType count = 10000001;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
- ++i, v += step, w -= step) {
+ constexpr UIntType COUNT = 10000001;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
+ ++i, v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/FMinTest.h b/libc/test/src/math/FMinTest.h
index a7491a063fd09..a5d62622b2053 100644
--- a/libc/test/src/math/FMinTest.h
+++ b/libc/test/src/math/FMinTest.h
@@ -55,10 +55,10 @@ template <typename T> class FMinTest : public __llvm_libc::testing::Test {
}
void testRange(FMinFunc func) {
- constexpr UIntType count = 10000001;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
- ++i, v += step, w -= step) {
+ constexpr UIntType COUNT = 10000001;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
+ ++i, v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/FloorTest.h b/libc/test/src/math/FloorTest.h
index b52f8a1a43030..0a3d5a3994aa0 100644
--- a/libc/test/src/math/FloorTest.h
+++ b/libc/test/src/math/FloorTest.h
@@ -64,9 +64,9 @@ template <typename T> class FloorTest : public __llvm_libc::testing::Test {
}
void testRange(FloorFunc func) {
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/FmaTest.h b/libc/test/src/math/FmaTest.h
index 30af38f3cee3a..2d04989400f48 100644
--- a/libc/test/src/math/FmaTest.h
+++ b/libc/test/src/math/FmaTest.h
@@ -29,7 +29,7 @@ class FmaTestTemplate : public __llvm_libc::testing::Test {
const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
- UIntType getRandomBitPattern() {
+ UIntType get_random_bit_pattern() {
UIntType bits{0};
for (UIntType i = 0; i < sizeof(UIntType) / 2; ++i) {
bits =
@@ -39,7 +39,7 @@ class FmaTestTemplate : public __llvm_libc::testing::Test {
}
public:
- void testSpecialNumbers(Func func) {
+ void test_special_numbers(Func func) {
EXPECT_FP_EQ(func(zero, zero, zero), zero);
EXPECT_FP_EQ(func(zero, neg_zero, neg_zero), neg_zero);
EXPECT_FP_EQ(func(inf, inf, zero), inf);
@@ -63,14 +63,14 @@ class FmaTestTemplate : public __llvm_libc::testing::Test {
EXPECT_FP_EQ(func(T(1.75), z, -z), T(0.75) * z);
}
- void testSubnormalRange(Func func) {
- constexpr UIntType count = 1000001;
- constexpr UIntType step =
- (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count;
+ void test_subnormal_range(Func func) {
+ constexpr UIntType COUNT = 1000001;
+ constexpr UIntType STEP =
+ (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL;
v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL;
- v += step, w -= step) {
- T x = T(FPBits(getRandomBitPattern())), y = T(FPBits(v)),
+ v += STEP, w -= STEP) {
+ T x = T(FPBits(get_random_bit_pattern())), y = T(FPBits(v)),
z = T(FPBits(w));
T result = func(x, y, z);
mpfr::TernaryInput<T> input{x, y, z};
@@ -78,14 +78,14 @@ class FmaTestTemplate : public __llvm_libc::testing::Test {
}
}
- void testNormalRange(Func func) {
- constexpr UIntType count = 1000001;
- constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
+ void test_normal_range(Func func) {
+ constexpr UIntType COUNT = 1000001;
+ constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
- v += step, w -= step) {
+ v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w)),
- z = T(FPBits(getRandomBitPattern()));
+ z = T(FPBits(get_random_bit_pattern()));
T result = func(x, y, z);
mpfr::TernaryInput<T> input{x, y, z};
ASSERT_MPFR_MATCH(mpfr::Operation::Fma, input, result, 0.5);
diff --git a/libc/test/src/math/FrexpTest.h b/libc/test/src/math/FrexpTest.h
index 6ccf0b9bac8ac..06789f4ebcc2f 100644
--- a/libc/test/src/math/FrexpTest.h
+++ b/libc/test/src/math/FrexpTest.h
@@ -19,7 +19,7 @@ template <typename T> class FrexpTest : public __llvm_libc::testing::Test {
DECLARE_SPECIAL_CONSTANTS(T)
- static constexpr UIntType HiddenBit =
+ static constexpr UIntType HIDDEN_BIT =
UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE;
public:
@@ -93,9 +93,9 @@ template <typename T> class FrexpTest : public __llvm_libc::testing::Test {
void testRange(FrexpFunc func) {
using UIntType = typename FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = static_cast<T>(FPBits(v));
if (isnan(x) || isinf(x) || x == 0.0l)
continue;
diff --git a/libc/test/src/math/HypotTest.h b/libc/test/src/math/HypotTest.h
index 962da0b39e061..584b5aef3359c 100644
--- a/libc/test/src/math/HypotTest.h
+++ b/libc/test/src/math/HypotTest.h
@@ -32,7 +32,7 @@ class HypotTestTemplate : public __llvm_libc::testing::Test {
const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
public:
- void testSpecialNumbers(Func func) {
+ void test_special_numbers(Func func) {
EXPECT_FP_EQ(func(inf, nan), inf);
EXPECT_FP_EQ(func(nan, neg_inf), inf);
EXPECT_FP_EQ(func(zero, inf), inf);
@@ -45,14 +45,14 @@ class HypotTestTemplate : public __llvm_libc::testing::Test {
EXPECT_FP_EQ(func(neg_zero, zero), zero);
}
- void testSubnormalRange(Func func) {
- constexpr UIntType count = 1000001;
+ void test_subnormal_range(Func func) {
+ constexpr UIntType COUNT = 1000001;
for (unsigned scale = 0; scale < 4; ++scale) {
- UIntType maxValue = FPBits::MAX_SUBNORMAL << scale;
- UIntType step = (maxValue - FPBits::MIN_SUBNORMAL) / count;
+ UIntType max_value = FPBits::MAX_SUBNORMAL << scale;
+ UIntType step = (max_value - FPBits::MIN_SUBNORMAL) / COUNT;
for (int signs = 0; signs < 4; ++signs) {
- for (UIntType v = FPBits::MIN_SUBNORMAL, w = maxValue;
- v <= maxValue && w >= FPBits::MIN_SUBNORMAL;
+ for (UIntType v = FPBits::MIN_SUBNORMAL, w = max_value;
+ v <= max_value && w >= FPBits::MIN_SUBNORMAL;
v += step, w -= step) {
T x = T(FPBits(v)), y = T(FPBits(w));
if (signs % 2 == 1) {
@@ -70,13 +70,13 @@ class HypotTestTemplate : public __llvm_libc::testing::Test {
}
}
- void testNormalRange(Func func) {
- constexpr UIntType count = 1000001;
- constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
+ void test_normal_range(Func func) {
+ constexpr UIntType COUNT = 1000001;
+ constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
for (int signs = 0; signs < 4; ++signs) {
for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
- v += step, w -= step) {
+ v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w));
if (signs % 2 == 1) {
x = -x;
diff --git a/libc/test/src/math/ILogbTest.h b/libc/test/src/math/ILogbTest.h
index 8d8f4e9a6716d..e2de14de446d9 100644
--- a/libc/test/src/math/ILogbTest.h
+++ b/libc/test/src/math/ILogbTest.h
@@ -21,7 +21,7 @@ class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
template <typename T> struct ILogbFunc { typedef int (*Func)(T); };
template <typename T>
- void testSpecialNumbers(typename ILogbFunc<T>::Func func) {
+ void test_special_numbers(typename ILogbFunc<T>::Func func) {
EXPECT_EQ(FP_ILOGB0, func(T(__llvm_libc::fputil::FPBits<T>::zero())));
EXPECT_EQ(FP_ILOGB0, func(T(__llvm_libc::fputil::FPBits<T>::neg_zero())));
@@ -32,7 +32,8 @@ class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
EXPECT_EQ(INT_MAX, func(T(__llvm_libc::fputil::FPBits<T>::neg_inf())));
}
- template <typename T> void testPowersOfTwo(typename ILogbFunc<T>::Func func) {
+ template <typename T>
+ void test_powers_of_two(typename ILogbFunc<T>::Func func) {
EXPECT_EQ(0, func(T(1.0)));
EXPECT_EQ(0, func(T(-1.0)));
@@ -53,7 +54,7 @@ class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
}
template <typename T>
- void testSomeIntegers(typename ILogbFunc<T>::Func func) {
+ void test_some_integers(typename ILogbFunc<T>::Func func) {
EXPECT_EQ(1, func(T(3.0)));
EXPECT_EQ(1, func(T(-3.0)));
@@ -71,14 +72,14 @@ class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
}
template <typename T>
- void testSubnormalRange(typename ILogbFunc<T>::Func func) {
+ void test_subnormal_range(typename ILogbFunc<T>::Func func) {
using FPBits = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType;
- constexpr UIntType count = 1000001;
- constexpr UIntType step =
- (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count;
+ constexpr UIntType COUNT = 1000001;
+ constexpr UIntType STEP =
+ (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
for (UIntType v = FPBits::MIN_SUBNORMAL; v <= FPBits::MAX_SUBNORMAL;
- v += step) {
+ v += STEP) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x) || x == 0.0)
continue;
@@ -89,12 +90,13 @@ class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
}
}
- template <typename T> void testNormalRange(typename ILogbFunc<T>::Func func) {
+ template <typename T>
+ void test_normal_range(typename ILogbFunc<T>::Func func) {
using FPBits = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType;
- constexpr UIntType count = 1000001;
- constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
- for (UIntType v = FPBits::MIN_NORMAL; v <= FPBits::MAX_NORMAL; v += step) {
+ constexpr UIntType COUNT = 1000001;
+ constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
+ for (UIntType v = FPBits::MIN_NORMAL; v <= FPBits::MAX_NORMAL; v += STEP) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x) || x == 0.0)
continue;
diff --git a/libc/test/src/math/LdExpTest.h b/libc/test/src/math/LdExpTest.h
index cd6491d2b71e6..ca9f33f2f8167 100644
--- a/libc/test/src/math/LdExpTest.h
+++ b/libc/test/src/math/LdExpTest.h
@@ -23,10 +23,10 @@ class LdExpTestTemplate : public __llvm_libc::testing::Test {
using FPBits = __llvm_libc::fputil::FPBits<T>;
using NormalFloat = __llvm_libc::fputil::NormalFloat<T>;
using UIntType = typename FPBits::UIntType;
- static constexpr UIntType mantissaWidth =
+ static constexpr UIntType MANTISSA_WIDTH =
__llvm_libc::fputil::MantissaWidth<T>::VALUE;
// A normalized mantissa to be used with tests.
- static constexpr UIntType mantissa = NormalFloat::ONE + 0x1234;
+ static constexpr UIntType MANTISSA = NormalFloat::ONE + 0x1234;
const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
@@ -38,8 +38,8 @@ class LdExpTestTemplate : public __llvm_libc::testing::Test {
typedef T (*LdExpFunc)(T, int);
void testSpecialNumbers(LdExpFunc func) {
- int expArray[5] = {-INT_MAX - 1, -10, 0, 10, INT_MAX};
- for (int exp : expArray) {
+ int exp_array[5] = {-INT_MAX - 1, -10, 0, 10, INT_MAX};
+ for (int exp : exp_array) {
ASSERT_FP_EQ(zero, func(zero, exp));
ASSERT_FP_EQ(neg_zero, func(neg_zero, exp));
ASSERT_FP_EQ(inf, func(inf, exp));
@@ -49,10 +49,10 @@ class LdExpTestTemplate : public __llvm_libc::testing::Test {
}
void testPowersOfTwo(LdExpFunc func) {
- int32_t expArray[5] = {1, 2, 3, 4, 5};
- int32_t valArray[6] = {1, 2, 4, 8, 16, 32};
- for (int32_t exp : expArray) {
- for (int32_t val : valArray) {
+ int32_t exp_array[5] = {1, 2, 3, 4, 5};
+ int32_t val_array[6] = {1, 2, 4, 8, 16, 32};
+ for (int32_t exp : exp_array) {
+ for (int32_t val : val_array) {
ASSERT_FP_EQ(T(val << exp), func(T(val), exp));
ASSERT_FP_EQ(T(-1 * (val << exp)), func(T(-val), exp));
}
@@ -70,11 +70,12 @@ class LdExpTestTemplate : public __llvm_libc::testing::Test {
void testUnderflowToZeroOnNormal(LdExpFunc func) {
// In this test, we pass a normal nubmer to func and expect zero
// to be returned due to underflow.
- int32_t baseExponent = FPBits::EXPONENT_BIAS + mantissaWidth;
- int32_t expArray[] = {baseExponent + 5, baseExponent + 4, baseExponent + 3,
- baseExponent + 2, baseExponent + 1};
- T x = NormalFloat(0, mantissa, 0);
- for (int32_t exp : expArray) {
+ int32_t base_exponent = FPBits::EXPONENT_BIAS + MANTISSA_WIDTH;
+ int32_t exp_array[] = {base_exponent + 5, base_exponent + 4,
+ base_exponent + 3, base_exponent + 2,
+ base_exponent + 1};
+ T x = NormalFloat(0, MANTISSA, 0);
+ for (int32_t exp : exp_array) {
ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero);
}
}
@@ -82,25 +83,26 @@ class LdExpTestTemplate : public __llvm_libc::testing::Test {
void testUnderflowToZeroOnSubnormal(LdExpFunc func) {
// In this test, we pass a normal nubmer to func and expect zero
// to be returned due to underflow.
- int32_t baseExponent = FPBits::EXPONENT_BIAS + mantissaWidth;
- int32_t expArray[] = {baseExponent + 5, baseExponent + 4, baseExponent + 3,
- baseExponent + 2, baseExponent + 1};
- T x = NormalFloat(-FPBits::EXPONENT_BIAS, mantissa, 0);
- for (int32_t exp : expArray) {
+ int32_t base_exponent = FPBits::EXPONENT_BIAS + MANTISSA_WIDTH;
+ int32_t exp_array[] = {base_exponent + 5, base_exponent + 4,
+ base_exponent + 3, base_exponent + 2,
+ base_exponent + 1};
+ T x = NormalFloat(-FPBits::EXPONENT_BIAS, MANTISSA, 0);
+ for (int32_t exp : exp_array) {
ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero);
}
}
void testNormalOperation(LdExpFunc func) {
- T valArray[] = {
+ T val_array[] = {
// Normal numbers
- NormalFloat(100, mantissa, 0), NormalFloat(-100, mantissa, 0),
- NormalFloat(100, mantissa, 1), NormalFloat(-100, mantissa, 1),
+ NormalFloat(100, MANTISSA, 0), NormalFloat(-100, MANTISSA, 0),
+ NormalFloat(100, MANTISSA, 1), NormalFloat(-100, MANTISSA, 1),
// Subnormal numbers
- NormalFloat(-FPBits::EXPONENT_BIAS, mantissa, 0),
- NormalFloat(-FPBits::EXPONENT_BIAS, mantissa, 1)};
- for (int32_t exp = 0; exp <= static_cast<int32_t>(mantissaWidth); ++exp) {
- for (T x : valArray) {
+ NormalFloat(-FPBits::EXPONENT_BIAS, MANTISSA, 0),
+ NormalFloat(-FPBits::EXPONENT_BIAS, MANTISSA, 1)};
+ for (int32_t exp = 0; exp <= static_cast<int32_t>(MANTISSA_WIDTH); ++exp) {
+ for (T x : val_array) {
// We compare the result of ldexp with the result
// of the native multiplication/division instruction.
ASSERT_FP_EQ(func(x, exp), x * (UIntType(1) << exp));
@@ -118,13 +120,13 @@ class LdExpTestTemplate : public __llvm_libc::testing::Test {
x = NormalFloat(FPBits::EXPONENT_BIAS, NormalFloat::ONE, 0);
int exp = -FPBits::MAX_EXPONENT - 5;
T result = func(x, exp);
- FPBits resultBits(result);
- ASSERT_FALSE(resultBits.is_zero());
+ FPBits result_bits(result);
+ ASSERT_FALSE(result_bits.is_zero());
// Verify that the result is indeed subnormal.
- ASSERT_EQ(resultBits.get_unbiased_exponent(), uint16_t(0));
+ ASSERT_EQ(result_bits.get_unbiased_exponent(), uint16_t(0));
// But if the exp is so less that normalization leads to zero, then
// the result should be zero.
- result = func(x, -FPBits::MAX_EXPONENT - int(mantissaWidth) - 5);
+ result = func(x, -FPBits::MAX_EXPONENT - int(MANTISSA_WIDTH) - 5);
ASSERT_TRUE(FPBits(result).is_zero());
// Start with a subnormal number but pass a very high number for exponent.
diff --git a/libc/test/src/math/LogbTest.h b/libc/test/src/math/LogbTest.h
index 6e7e6d5bda06e..49ccf3a1a832e 100644
--- a/libc/test/src/math/LogbTest.h
+++ b/libc/test/src/math/LogbTest.h
@@ -19,7 +19,7 @@ template <typename T> class LogbTest : public __llvm_libc::testing::Test {
DECLARE_SPECIAL_CONSTANTS(T)
- static constexpr UIntType HiddenBit =
+ static constexpr UIntType HIDDEN_BIT =
UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE;
public:
@@ -72,9 +72,9 @@ template <typename T> class LogbTest : public __llvm_libc::testing::Test {
void testRange(LogbFunc func) {
using UIntType = typename FPBits::UIntType;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = static_cast<T>(FPBits(v));
if (isnan(x) || isinf(x) || x == 0.0l)
continue;
diff --git a/libc/test/src/math/ModfTest.h b/libc/test/src/math/ModfTest.h
index a3f0c41082078..4e88c6ae36545 100644
--- a/libc/test/src/math/ModfTest.h
+++ b/libc/test/src/math/ModfTest.h
@@ -84,9 +84,9 @@ template <typename T> class ModfTest : public __llvm_libc::testing::Test {
}
void testRange(ModfFunc func) {
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x) || x == T(0.0))
continue;
diff --git a/libc/test/src/math/NextAfterTest.h b/libc/test/src/math/NextAfterTest.h
index 4b7b5f4997ee4..201d164337048 100644
--- a/libc/test/src/math/NextAfterTest.h
+++ b/libc/test/src/math/NextAfterTest.h
@@ -22,7 +22,7 @@ class NextAfterTestTemplate : public __llvm_libc::testing::Test {
using MantissaWidth = __llvm_libc::fputil::MantissaWidth<T>;
using UIntType = typename FPBits::UIntType;
- static constexpr int bitWidthOfType =
+ static constexpr int BIT_WIDTH_OF_TYPE =
__llvm_libc::fputil::FloatProperties<T>::BIT_WIDTH;
const T zero = T(FPBits::zero());
@@ -30,10 +30,10 @@ class NextAfterTestTemplate : public __llvm_libc::testing::Test {
const T inf = T(FPBits::inf());
const T neg_inf = T(FPBits::neg_inf());
const T nan = T(FPBits::build_nan(1));
- const UIntType MIN_SUBNORMAL = FPBits::MIN_SUBNORMAL;
- const UIntType MAX_SUBNORMAL = FPBits::MAX_SUBNORMAL;
- const UIntType MIN_NORMAL = FPBits::MIN_NORMAL;
- const UIntType MAX_NORMAL = FPBits::MAX_NORMAL;
+ const UIntType min_subnormal = FPBits::MIN_SUBNORMAL;
+ const UIntType max_subnormal = FPBits::MAX_SUBNORMAL;
+ const UIntType min_normal = FPBits::MIN_NORMAL;
+ const UIntType max_normal = FPBits::MAX_NORMAL;
public:
typedef T (*NextAfterFunc)(T, T);
@@ -50,89 +50,91 @@ class NextAfterTestTemplate : public __llvm_libc::testing::Test {
// 'from' is zero|neg_zero.
T x = zero;
T result = func(x, T(1));
- UIntType expectedBits = 1;
- T expected = *reinterpret_cast<T *>(&expectedBits);
+ UIntType expected_bits = 1;
+ T expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
result = func(x, T(-1));
- expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + 1;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + 1;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
x = neg_zero;
result = func(x, 1);
- expectedBits = 1;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = 1;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
result = func(x, -1);
- expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + 1;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + 1;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
// 'from' is max subnormal value.
- x = *reinterpret_cast<const T *>(&MAX_SUBNORMAL);
+ x = *reinterpret_cast<const T *>(&max_subnormal);
result = func(x, 1);
- expected = *reinterpret_cast<const T *>(&MIN_NORMAL);
+ expected = *reinterpret_cast<const T *>(&min_normal);
ASSERT_FP_EQ(result, expected);
result = func(x, 0);
- expectedBits = MAX_SUBNORMAL - 1;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = max_subnormal - 1;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
x = -x;
result = func(x, -1);
- expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MIN_NORMAL;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + min_normal;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
result = func(x, 0);
- expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MAX_SUBNORMAL - 1;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits =
+ (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + max_subnormal - 1;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
// 'from' is min subnormal value.
- x = *reinterpret_cast<const T *>(&MIN_SUBNORMAL);
+ x = *reinterpret_cast<const T *>(&min_subnormal);
result = func(x, 1);
- expectedBits = MIN_SUBNORMAL + 1;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = min_subnormal + 1;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
ASSERT_FP_EQ(func(x, 0), 0);
x = -x;
result = func(x, -1);
- expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MIN_SUBNORMAL + 1;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits =
+ (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + min_subnormal + 1;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
ASSERT_FP_EQ(func(x, 0), T(-0.0));
// 'from' is min normal.
- x = *reinterpret_cast<const T *>(&MIN_NORMAL);
+ x = *reinterpret_cast<const T *>(&min_normal);
result = func(x, 0);
- expectedBits = MAX_SUBNORMAL;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = max_subnormal;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
result = func(x, inf);
- expectedBits = MIN_NORMAL + 1;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = min_normal + 1;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
x = -x;
result = func(x, 0);
- expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MAX_SUBNORMAL;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + max_subnormal;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
result = func(x, -inf);
- expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MIN_NORMAL + 1;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + min_normal + 1;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
// 'from' is max normal and 'to' is infinity.
- x = *reinterpret_cast<const T *>(&MAX_NORMAL);
+ x = *reinterpret_cast<const T *>(&max_normal);
result = func(x, inf);
ASSERT_FP_EQ(result, inf);
@@ -142,48 +144,48 @@ class NextAfterTestTemplate : public __llvm_libc::testing::Test {
// 'from' is infinity.
x = inf;
result = func(x, 0);
- expectedBits = MAX_NORMAL;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = max_normal;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
ASSERT_FP_EQ(func(x, inf), inf);
x = neg_inf;
result = func(x, 0);
- expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MAX_NORMAL;
- expected = *reinterpret_cast<T *>(&expectedBits);
+ expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + max_normal;
+ expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected);
ASSERT_FP_EQ(func(x, neg_inf), neg_inf);
// 'from' is a power of 2.
x = T(32.0);
result = func(x, 0);
- FPBits xBits = FPBits(x);
- FPBits resultBits = FPBits(result);
- ASSERT_EQ(resultBits.get_unbiased_exponent(),
- uint16_t(xBits.get_unbiased_exponent() - 1));
- ASSERT_EQ(resultBits.get_mantissa(),
+ FPBits x_bits = FPBits(x);
+ FPBits result_bits = FPBits(result);
+ ASSERT_EQ(result_bits.get_unbiased_exponent(),
+ uint16_t(x_bits.get_unbiased_exponent() - 1));
+ ASSERT_EQ(result_bits.get_mantissa(),
(UIntType(1) << MantissaWidth::VALUE) - 1);
result = func(x, T(33.0));
- resultBits = FPBits(result);
- ASSERT_EQ(resultBits.get_unbiased_exponent(),
- xBits.get_unbiased_exponent());
- ASSERT_EQ(resultBits.get_mantissa(), xBits.get_mantissa() + UIntType(1));
+ result_bits = FPBits(result);
+ ASSERT_EQ(result_bits.get_unbiased_exponent(),
+ x_bits.get_unbiased_exponent());
+ ASSERT_EQ(result_bits.get_mantissa(), x_bits.get_mantissa() + UIntType(1));
x = -x;
result = func(x, 0);
- resultBits = FPBits(result);
- ASSERT_EQ(resultBits.get_unbiased_exponent(),
- uint16_t(xBits.get_unbiased_exponent() - 1));
- ASSERT_EQ(resultBits.get_mantissa(),
+ result_bits = FPBits(result);
+ ASSERT_EQ(result_bits.get_unbiased_exponent(),
+ uint16_t(x_bits.get_unbiased_exponent() - 1));
+ ASSERT_EQ(result_bits.get_mantissa(),
(UIntType(1) << MantissaWidth::VALUE) - 1);
result = func(x, T(-33.0));
- resultBits = FPBits(result);
- ASSERT_EQ(resultBits.get_unbiased_exponent(),
- xBits.get_unbiased_exponent());
- ASSERT_EQ(resultBits.get_mantissa(), xBits.get_mantissa() + UIntType(1));
+ result_bits = FPBits(result);
+ ASSERT_EQ(result_bits.get_unbiased_exponent(),
+ x_bits.get_unbiased_exponent());
+ ASSERT_EQ(result_bits.get_mantissa(), x_bits.get_mantissa() + UIntType(1));
}
};
diff --git a/libc/test/src/math/RIntTest.h b/libc/test/src/math/RIntTest.h
index 53844a1eaa5fe..7dc677059f19e 100644
--- a/libc/test/src/math/RIntTest.h
+++ b/libc/test/src/math/RIntTest.h
@@ -21,8 +21,8 @@
namespace mpfr = __llvm_libc::testing::mpfr;
-static constexpr int roundingModes[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
- FE_TONEAREST};
+static constexpr int ROUNDING_MODES[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
+ FE_TONEAREST};
template <typename T>
class RIntTestTemplate : public __llvm_libc::testing::Test {
@@ -39,7 +39,7 @@ class RIntTestTemplate : public __llvm_libc::testing::Test {
const T neg_inf = T(FPBits::neg_inf());
const T nan = T(FPBits::build_nan(1));
- static inline mpfr::RoundingMode toMPFRRoundingMode(int mode) {
+ static inline mpfr::RoundingMode to_mpfr_rounding_mode(int mode) {
switch (mode) {
case FE_UPWARD:
return mpfr::RoundingMode::Upward;
@@ -56,7 +56,7 @@ class RIntTestTemplate : public __llvm_libc::testing::Test {
public:
void testSpecialNumbers(RIntFunc func) {
- for (int mode : roundingModes) {
+ for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode);
ASSERT_FP_EQ(inf, func(inf));
ASSERT_FP_EQ(neg_inf, func(neg_inf));
@@ -67,50 +67,50 @@ class RIntTestTemplate : public __llvm_libc::testing::Test {
}
void testRoundNumbers(RIntFunc func) {
- for (int mode : roundingModes) {
+ for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode);
- mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
- ASSERT_FP_EQ(func(T(1.0)), mpfr::Round(T(1.0), mpfrMode));
- ASSERT_FP_EQ(func(T(-1.0)), mpfr::Round(T(-1.0), mpfrMode));
- ASSERT_FP_EQ(func(T(10.0)), mpfr::Round(T(10.0), mpfrMode));
- ASSERT_FP_EQ(func(T(-10.0)), mpfr::Round(T(-10.0), mpfrMode));
- ASSERT_FP_EQ(func(T(1234.0)), mpfr::Round(T(1234.0), mpfrMode));
- ASSERT_FP_EQ(func(T(-1234.0)), mpfr::Round(T(-1234.0), mpfrMode));
+ mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(mode);
+ ASSERT_FP_EQ(func(T(1.0)), mpfr::Round(T(1.0), mpfr_mode));
+ ASSERT_FP_EQ(func(T(-1.0)), mpfr::Round(T(-1.0), mpfr_mode));
+ ASSERT_FP_EQ(func(T(10.0)), mpfr::Round(T(10.0), mpfr_mode));
+ ASSERT_FP_EQ(func(T(-10.0)), mpfr::Round(T(-10.0), mpfr_mode));
+ ASSERT_FP_EQ(func(T(1234.0)), mpfr::Round(T(1234.0), mpfr_mode));
+ ASSERT_FP_EQ(func(T(-1234.0)), mpfr::Round(T(-1234.0), mpfr_mode));
}
}
void testFractions(RIntFunc func) {
- for (int mode : roundingModes) {
+ for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode);
- mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
- ASSERT_FP_EQ(func(T(0.5)), mpfr::Round(T(0.5), mpfrMode));
- ASSERT_FP_EQ(func(T(-0.5)), mpfr::Round(T(-0.5), mpfrMode));
- ASSERT_FP_EQ(func(T(0.115)), mpfr::Round(T(0.115), mpfrMode));
- ASSERT_FP_EQ(func(T(-0.115)), mpfr::Round(T(-0.115), mpfrMode));
- ASSERT_FP_EQ(func(T(0.715)), mpfr::Round(T(0.715), mpfrMode));
- ASSERT_FP_EQ(func(T(-0.715)), mpfr::Round(T(-0.715), mpfrMode));
+ mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(mode);
+ ASSERT_FP_EQ(func(T(0.5)), mpfr::Round(T(0.5), mpfr_mode));
+ ASSERT_FP_EQ(func(T(-0.5)), mpfr::Round(T(-0.5), mpfr_mode));
+ ASSERT_FP_EQ(func(T(0.115)), mpfr::Round(T(0.115), mpfr_mode));
+ ASSERT_FP_EQ(func(T(-0.115)), mpfr::Round(T(-0.115), mpfr_mode));
+ ASSERT_FP_EQ(func(T(0.715)), mpfr::Round(T(0.715), mpfr_mode));
+ ASSERT_FP_EQ(func(T(-0.715)), mpfr::Round(T(-0.715), mpfr_mode));
}
}
void testSubnormalRange(RIntFunc func) {
- constexpr UIntType count = 1000001;
- constexpr UIntType step =
- (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count;
+ constexpr UIntType COUNT = 1000001;
+ constexpr UIntType STEP =
+ (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL;
- i += step) {
+ i += STEP) {
T x = T(FPBits(i));
- for (int mode : roundingModes) {
+ for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode);
- mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
- ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfrMode));
+ mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(mode);
+ ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfr_mode));
}
}
}
void testNormalRange(RIntFunc func) {
- constexpr UIntType count = 1000001;
- constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
- for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += step) {
+ constexpr UIntType COUNT = 1000001;
+ constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
+ for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += STEP) {
T x = T(FPBits(i));
// In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. We will skip them.
@@ -118,10 +118,10 @@ class RIntTestTemplate : public __llvm_libc::testing::Test {
continue;
}
- for (int mode : roundingModes) {
+ for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode);
- mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
- ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfrMode));
+ mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(mode);
+ ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfr_mode));
}
}
}
diff --git a/libc/test/src/math/RemQuoTest.h b/libc/test/src/math/RemQuoTest.h
index e96ddd759bd6b..5903760c1969b 100644
--- a/libc/test/src/math/RemQuoTest.h
+++ b/libc/test/src/math/RemQuoTest.h
@@ -95,12 +95,12 @@ class RemQuoTestTemplate : public __llvm_libc::testing::Test {
}
void testSubnormalRange(RemQuoFunc func) {
- constexpr UIntType count = 1000001;
- constexpr UIntType step =
- (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count;
+ constexpr UIntType COUNT = 1000001;
+ constexpr UIntType STEP =
+ (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL;
v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL;
- v += step, w -= step) {
+ v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w));
mpfr::BinaryOutput<T> result;
mpfr::BinaryInput<T> input{x, y};
@@ -110,11 +110,11 @@ class RemQuoTestTemplate : public __llvm_libc::testing::Test {
}
void testNormalRange(RemQuoFunc func) {
- constexpr UIntType count = 1000001;
- constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
+ constexpr UIntType COUNT = 1000001;
+ constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
- v += step, w -= step) {
+ v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w));
mpfr::BinaryOutput<T> result;
mpfr::BinaryInput<T> input{x, y};
diff --git a/libc/test/src/math/RoundTest.h b/libc/test/src/math/RoundTest.h
index d4fea629507fe..4720f385edabd 100644
--- a/libc/test/src/math/RoundTest.h
+++ b/libc/test/src/math/RoundTest.h
@@ -64,9 +64,9 @@ template <typename T> class RoundTest : public __llvm_libc::testing::Test {
}
void testRange(RoundFunc func) {
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/RoundToIntegerTest.h b/libc/test/src/math/RoundToIntegerTest.h
index b77c4bffc8284..e95f96e92ab03 100644
--- a/libc/test/src/math/RoundToIntegerTest.h
+++ b/libc/test/src/math/RoundToIntegerTest.h
@@ -23,8 +23,8 @@
namespace mpfr = __llvm_libc::testing::mpfr;
-static constexpr int roundingModes[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
- FE_TONEAREST};
+static constexpr int ROUNDING_MODES[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
+ FE_TONEAREST};
template <typename F, typename I, bool TestModes = false>
class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
@@ -40,11 +40,11 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
const F inf = F(__llvm_libc::fputil::FPBits<F>::inf());
const F neg_inf = F(__llvm_libc::fputil::FPBits<F>::neg_inf());
const F nan = F(__llvm_libc::fputil::FPBits<F>::build_nan(1));
- static constexpr I IntegerMin = I(1) << (sizeof(I) * 8 - 1);
- static constexpr I IntegerMax = -(IntegerMin + 1);
+ static constexpr I INTEGER_MIN = I(1) << (sizeof(I) * 8 - 1);
+ static constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
- void testOneInput(RoundToIntegerFunc func, F input, I expected,
- bool expectError) {
+ void test_one_input(RoundToIntegerFunc func, F input, I expected,
+ bool expectError) {
#if math_errhandling & MATH_ERRNO
errno = 0;
#endif
@@ -71,7 +71,7 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
}
}
- static inline mpfr::RoundingMode toMPFRRoundingMode(int mode) {
+ static inline mpfr::RoundingMode to_mpfr_rounding_mode(int mode) {
switch (mode) {
case FE_UPWARD:
return mpfr::RoundingMode::Upward;
@@ -96,32 +96,32 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
#endif
}
- void doInfinityAndNaNTest(RoundToIntegerFunc func) {
- testOneInput(func, inf, IntegerMax, true);
- testOneInput(func, neg_inf, IntegerMin, true);
- testOneInput(func, nan, IntegerMax, true);
+ void do_infinity_and_na_n_test(RoundToIntegerFunc func) {
+ test_one_input(func, inf, INTEGER_MAX, true);
+ test_one_input(func, neg_inf, INTEGER_MIN, true);
+ test_one_input(func, nan, INTEGER_MAX, true);
}
void testInfinityAndNaN(RoundToIntegerFunc func) {
if (TestModes) {
- for (int mode : roundingModes) {
+ for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode);
- doInfinityAndNaNTest(func);
+ do_infinity_and_na_n_test(func);
}
} else {
- doInfinityAndNaNTest(func);
+ do_infinity_and_na_n_test(func);
}
}
- void doRoundNumbersTest(RoundToIntegerFunc func) {
- testOneInput(func, zero, I(0), false);
- testOneInput(func, neg_zero, I(0), false);
- testOneInput(func, F(1.0), I(1), false);
- testOneInput(func, F(-1.0), I(-1), false);
- testOneInput(func, F(10.0), I(10), false);
- testOneInput(func, F(-10.0), I(-10), false);
- testOneInput(func, F(1234.0), I(1234), false);
- testOneInput(func, F(-1234.0), I(-1234), false);
+ void do_round_numbers_test(RoundToIntegerFunc func) {
+ test_one_input(func, zero, I(0), false);
+ test_one_input(func, neg_zero, I(0), false);
+ test_one_input(func, F(1.0), I(1), false);
+ test_one_input(func, F(-1.0), I(-1), false);
+ test_one_input(func, F(10.0), I(10), false);
+ test_one_input(func, F(-10.0), I(-10), false);
+ test_one_input(func, F(1234.0), I(1234), false);
+ test_one_input(func, F(-1234.0), I(-1234), false);
// The rest of this this function compares with an equivalent MPFR function
// which rounds floating point numbers to long values. There is no MPFR
@@ -131,58 +131,58 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
if (sizeof(I) > sizeof(long))
return;
- constexpr int exponentLimit = sizeof(I) * 8 - 1;
+ constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1;
// We start with 1.0 so that the implicit bit for x86 long doubles
// is set.
FPBits bits(F(1.0));
- bits.set_unbiased_exponent(exponentLimit + FPBits::EXPONENT_BIAS);
+ bits.set_unbiased_exponent(EXPONENT_LIMIT + FPBits::EXPONENT_BIAS);
bits.set_sign(1);
bits.set_mantissa(0);
F x = F(bits);
- long mpfrResult;
- bool erangeflag = mpfr::RoundToLong(x, mpfrResult);
+ long mpfr_result;
+ bool erangeflag = mpfr::RoundToLong(x, mpfr_result);
ASSERT_FALSE(erangeflag);
- testOneInput(func, x, mpfrResult, false);
+ test_one_input(func, x, mpfr_result, false);
}
void testRoundNumbers(RoundToIntegerFunc func) {
if (TestModes) {
- for (int mode : roundingModes) {
+ for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode);
- doRoundNumbersTest(func);
+ do_round_numbers_test(func);
}
} else {
- doRoundNumbersTest(func);
+ do_round_numbers_test(func);
}
}
- void doFractionsTest(RoundToIntegerFunc func, int mode) {
- constexpr F fractions[] = {0.5, -0.5, 0.115, -0.115, 0.715, -0.715};
- for (F x : fractions) {
- long mpfrLongResult;
+ void do_fractions_test(RoundToIntegerFunc func, int mode) {
+ constexpr F FRACTIONS[] = {0.5, -0.5, 0.115, -0.115, 0.715, -0.715};
+ for (F x : FRACTIONS) {
+ long mpfr_long_result;
bool erangeflag;
if (TestModes)
erangeflag =
- mpfr::RoundToLong(x, toMPFRRoundingMode(mode), mpfrLongResult);
+ mpfr::RoundToLong(x, to_mpfr_rounding_mode(mode), mpfr_long_result);
else
- erangeflag = mpfr::RoundToLong(x, mpfrLongResult);
+ erangeflag = mpfr::RoundToLong(x, mpfr_long_result);
ASSERT_FALSE(erangeflag);
- I mpfrResult = mpfrLongResult;
- testOneInput(func, x, mpfrResult, false);
+ I mpfr_result = mpfr_long_result;
+ test_one_input(func, x, mpfr_result, false);
}
}
void testFractions(RoundToIntegerFunc func) {
if (TestModes) {
- for (int mode : roundingModes) {
+ for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode);
- doFractionsTest(func, mode);
+ do_fractions_test(func, mode);
}
} else {
// Passing 0 for mode has no effect as it is not used in doFractionsTest
// when `TestModes` is false;
- doFractionsTest(func, 0);
+ do_fractions_test(func, 0);
}
}
@@ -195,39 +195,39 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
if (sizeof(I) > sizeof(long))
return;
- constexpr int exponentLimit = sizeof(I) * 8 - 1;
+ constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1;
// We start with 1.0 so that the implicit bit for x86 long doubles
// is set.
FPBits bits(F(1.0));
- bits.set_unbiased_exponent(exponentLimit + FPBits::EXPONENT_BIAS);
+ bits.set_unbiased_exponent(EXPONENT_LIMIT + FPBits::EXPONENT_BIAS);
bits.set_sign(1);
bits.set_mantissa(UIntType(0x1)
<< (__llvm_libc::fputil::MantissaWidth<F>::VALUE - 1));
F x = F(bits);
if (TestModes) {
- for (int m : roundingModes) {
+ for (int m : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(m);
- long mpfrLongResult;
+ long mpfr_long_result;
bool erangeflag =
- mpfr::RoundToLong(x, toMPFRRoundingMode(m), mpfrLongResult);
+ mpfr::RoundToLong(x, to_mpfr_rounding_mode(m), mpfr_long_result);
ASSERT_TRUE(erangeflag);
- testOneInput(func, x, IntegerMin, true);
+ test_one_input(func, x, INTEGER_MIN, true);
}
} else {
- long mpfrLongResult;
- bool erangeflag = mpfr::RoundToLong(x, mpfrLongResult);
+ long mpfr_long_result;
+ bool erangeflag = mpfr::RoundToLong(x, mpfr_long_result);
ASSERT_TRUE(erangeflag);
- testOneInput(func, x, IntegerMin, true);
+ test_one_input(func, x, INTEGER_MIN, true);
}
}
void testSubnormalRange(RoundToIntegerFunc func) {
- constexpr UIntType count = 1000001;
- constexpr UIntType step =
- (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count;
+ constexpr UIntType COUNT = 1000001;
+ constexpr UIntType STEP =
+ (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL;
- i += step) {
+ i += STEP) {
F x = F(FPBits(i));
if (x == F(0.0))
continue;
@@ -235,25 +235,25 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
if (TestModes) {
if (x > 0) {
__llvm_libc::fputil::set_round(FE_UPWARD);
- testOneInput(func, x, I(1), false);
+ test_one_input(func, x, I(1), false);
__llvm_libc::fputil::set_round(FE_DOWNWARD);
- testOneInput(func, x, I(0), false);
+ test_one_input(func, x, I(0), false);
__llvm_libc::fputil::set_round(FE_TOWARDZERO);
- testOneInput(func, x, I(0), false);
+ test_one_input(func, x, I(0), false);
__llvm_libc::fputil::set_round(FE_TONEAREST);
- testOneInput(func, x, I(0), false);
+ test_one_input(func, x, I(0), false);
} else {
__llvm_libc::fputil::set_round(FE_UPWARD);
- testOneInput(func, x, I(0), false);
+ test_one_input(func, x, I(0), false);
__llvm_libc::fputil::set_round(FE_DOWNWARD);
- testOneInput(func, x, I(-1), false);
+ test_one_input(func, x, I(-1), false);
__llvm_libc::fputil::set_round(FE_TOWARDZERO);
- testOneInput(func, x, I(0), false);
+ test_one_input(func, x, I(0), false);
__llvm_libc::fputil::set_round(FE_TONEAREST);
- testOneInput(func, x, I(0), false);
+ test_one_input(func, x, I(0), false);
}
} else {
- testOneInput(func, x, 0L, false);
+ test_one_input(func, x, 0L, false);
}
}
}
@@ -267,9 +267,9 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
if (sizeof(I) > sizeof(long))
return;
- constexpr UIntType count = 1000001;
- constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
- for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += step) {
+ constexpr UIntType COUNT = 1000001;
+ constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
+ for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += STEP) {
F x = F(FPBits(i));
// In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. We will skip them.
@@ -278,25 +278,25 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
}
if (TestModes) {
- for (int m : roundingModes) {
- long mpfrLongResult;
+ for (int m : ROUNDING_MODES) {
+ long mpfr_long_result;
bool erangeflag =
- mpfr::RoundToLong(x, toMPFRRoundingMode(m), mpfrLongResult);
- I mpfrResult = mpfrLongResult;
+ mpfr::RoundToLong(x, to_mpfr_rounding_mode(m), mpfr_long_result);
+ I mpfr_result = mpfr_long_result;
__llvm_libc::fputil::set_round(m);
if (erangeflag)
- testOneInput(func, x, x > 0 ? IntegerMax : IntegerMin, true);
+ test_one_input(func, x, x > 0 ? INTEGER_MAX : INTEGER_MIN, true);
else
- testOneInput(func, x, mpfrResult, false);
+ test_one_input(func, x, mpfr_result, false);
}
} else {
- long mpfrLongResult;
- bool erangeflag = mpfr::RoundToLong(x, mpfrLongResult);
- I mpfrResult = mpfrLongResult;
+ long mpfr_long_result;
+ bool erangeflag = mpfr::RoundToLong(x, mpfr_long_result);
+ I mpfr_result = mpfr_long_result;
if (erangeflag)
- testOneInput(func, x, x > 0 ? IntegerMax : IntegerMin, true);
+ test_one_input(func, x, x > 0 ? INTEGER_MAX : INTEGER_MIN, true);
else
- testOneInput(func, x, mpfrResult, false);
+ test_one_input(func, x, mpfr_result, false);
}
}
}
diff --git a/libc/test/src/math/SqrtTest.h b/libc/test/src/math/SqrtTest.h
index a6120a2c51eb0..f3e4def723aaf 100644
--- a/libc/test/src/math/SqrtTest.h
+++ b/libc/test/src/math/SqrtTest.h
@@ -18,7 +18,7 @@ template <typename T> class SqrtTest : public __llvm_libc::testing::Test {
DECLARE_SPECIAL_CONSTANTS(T)
- static constexpr UIntType HiddenBit =
+ static constexpr UIntType HIDDEN_BIT =
UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE;
public:
@@ -37,7 +37,7 @@ template <typename T> class SqrtTest : public __llvm_libc::testing::Test {
}
void testDenormalValues(SqrtFunc func) {
- for (UIntType mant = 1; mant < HiddenBit; mant <<= 1) {
+ for (UIntType mant = 1; mant < HIDDEN_BIT; mant <<= 1) {
FPBits denormal(T(0.0));
denormal.set_mantissa(mant);
@@ -45,18 +45,18 @@ template <typename T> class SqrtTest : public __llvm_libc::testing::Test {
T(0.5));
}
- constexpr UIntType count = 1'000'001;
- constexpr UIntType step = HiddenBit / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 1'000'001;
+ constexpr UIntType STEP = HIDDEN_BIT / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = *reinterpret_cast<T *>(&v);
ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5);
}
}
void testNormalRange(SqrtFunc func) {
- constexpr UIntType count = 10'000'001;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10'000'001;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = *reinterpret_cast<T *>(&v);
if (isnan(x) || (x < 0)) {
continue;
diff --git a/libc/test/src/math/TruncTest.h b/libc/test/src/math/TruncTest.h
index 6e65f3d7888df..f939de40e24dd 100644
--- a/libc/test/src/math/TruncTest.h
+++ b/libc/test/src/math/TruncTest.h
@@ -64,9 +64,9 @@ template <typename T> class TruncTest : public __llvm_libc::testing::Test {
}
void testRange(TruncFunc func) {
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/cos_test.cpp b/libc/test/src/math/cos_test.cpp
index e99cb39ad1e86..0feef88ca17f1 100644
--- a/libc/test/src/math/cos_test.cpp
+++ b/libc/test/src/math/cos_test.cpp
@@ -19,9 +19,9 @@ DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibccosTest, Range) {
static constexpr double _2pi = 6.283185307179586;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
double x = double(FPBits(v));
// TODO: Expand the range of testing after range reduction is implemented.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
diff --git a/libc/test/src/math/cosf_test.cpp b/libc/test/src/math/cosf_test.cpp
index be968d6ea35c3..8e5f6c0dcfe8e 100644
--- a/libc/test/src/math/cosf_test.cpp
+++ b/libc/test/src/math/cosf_test.cpp
@@ -18,7 +18,7 @@
#include <errno.h>
#include <stdint.h>
-using __llvm_libc::testing::sdcomp26094Values;
+using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -47,9 +47,9 @@ TEST(LlvmLibcCosfTest, SpecialNumbers) {
}
TEST(LlvmLibcCosfTest, InFloatRange) {
- constexpr uint32_t count = 1000000;
- constexpr uint32_t step = UINT32_MAX / count;
- for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr uint32_t COUNT = 1000000;
+ constexpr uint32_t STEP = UINT32_MAX / COUNT;
+ for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
@@ -73,7 +73,7 @@ TEST(LlvmLibcCosfTest, SmallValues) {
// SDCOMP-26094: check cosf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcCosfTest, SDCOMP_26094) {
- for (uint32_t v : sdcomp26094Values) {
+ for (uint32_t v : SDCOMP26094_VALUES) {
float x = float(FPBits(v));
ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), 1.0);
}
diff --git a/libc/test/src/math/exp2f_test.cpp b/libc/test/src/math/exp2f_test.cpp
index 7db1a576f5542..f3a4cc413e1fa 100644
--- a/libc/test/src/math/exp2f_test.cpp
+++ b/libc/test/src/math/exp2f_test.cpp
@@ -101,9 +101,9 @@ TEST(LlvmLibcExpfTest, Underflow) {
}
TEST(LlvmLibcexp2fTest, InFloatRange) {
- constexpr uint32_t count = 1000000;
- constexpr uint32_t step = UINT32_MAX / count;
- for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr uint32_t COUNT = 1000000;
+ constexpr uint32_t STEP = UINT32_MAX / COUNT;
+ for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/expf_test.cpp b/libc/test/src/math/expf_test.cpp
index 68d7dff462f55..d675fc1a9534c 100644
--- a/libc/test/src/math/expf_test.cpp
+++ b/libc/test/src/math/expf_test.cpp
@@ -93,9 +93,9 @@ TEST(LlvmLibcExpfTest, Borderline) {
}
TEST(LlvmLibcExpfTest, InFloatRange) {
- constexpr uint32_t count = 1000000;
- constexpr uint32_t step = UINT32_MAX / count;
- for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr uint32_t COUNT = 1000000;
+ constexpr uint32_t STEP = UINT32_MAX / COUNT;
+ for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/expm1f_test.cpp b/libc/test/src/math/expm1f_test.cpp
index cec3080962bf9..b8439192151a3 100644
--- a/libc/test/src/math/expm1f_test.cpp
+++ b/libc/test/src/math/expm1f_test.cpp
@@ -93,9 +93,9 @@ TEST(LlvmLibcExpm1fTest, Borderline) {
}
TEST(LlvmLibcExpm1fTest, InFloatRange) {
- constexpr uint32_t count = 1000000;
- constexpr uint32_t step = UINT32_MAX / count;
- for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr uint32_t COUNT = 1000000;
+ constexpr uint32_t STEP = UINT32_MAX / COUNT;
+ for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/fdim_test.cpp b/libc/test/src/math/fdim_test.cpp
index a4726f28a3827..06b61c2124d22 100644
--- a/libc/test/src/math/fdim_test.cpp
+++ b/libc/test/src/math/fdim_test.cpp
@@ -16,14 +16,16 @@
using LlvmLibcFDimTest = FDimTestTemplate<double>;
-TEST_F(LlvmLibcFDimTest, NaNArg_fdim) { testNaNArg(&__llvm_libc::fdim); }
+TEST_F(LlvmLibcFDimTest, NaNArg_fdim) { test_na_n_arg(&__llvm_libc::fdim); }
-TEST_F(LlvmLibcFDimTest, InfArg_fdim) { testInfArg(&__llvm_libc::fdim); }
+TEST_F(LlvmLibcFDimTest, InfArg_fdim) { test_inf_arg(&__llvm_libc::fdim); }
-TEST_F(LlvmLibcFDimTest, NegInfArg_fdim) { testNegInfArg(&__llvm_libc::fdim); }
+TEST_F(LlvmLibcFDimTest, NegInfArg_fdim) {
+ test_neg_inf_arg(&__llvm_libc::fdim);
+}
-TEST_F(LlvmLibcFDimTest, BothZero_fdim) { testBothZero(&__llvm_libc::fdim); }
+TEST_F(LlvmLibcFDimTest, BothZero_fdim) { test_both_zero(&__llvm_libc::fdim); }
TEST_F(LlvmLibcFDimTest, InDoubleRange_fdim) {
- testInRange(&__llvm_libc::fdim);
+ test_in_range(&__llvm_libc::fdim);
}
diff --git a/libc/test/src/math/fdimf_test.cpp b/libc/test/src/math/fdimf_test.cpp
index 45f960cc8955b..c85b755738f31 100644
--- a/libc/test/src/math/fdimf_test.cpp
+++ b/libc/test/src/math/fdimf_test.cpp
@@ -16,16 +16,18 @@
using LlvmLibcFDimTest = FDimTestTemplate<float>;
-TEST_F(LlvmLibcFDimTest, NaNArg_fdimf) { testNaNArg(&__llvm_libc::fdimf); }
+TEST_F(LlvmLibcFDimTest, NaNArg_fdimf) { test_na_n_arg(&__llvm_libc::fdimf); }
-TEST_F(LlvmLibcFDimTest, InfArg_fdimf) { testInfArg(&__llvm_libc::fdimf); }
+TEST_F(LlvmLibcFDimTest, InfArg_fdimf) { test_inf_arg(&__llvm_libc::fdimf); }
TEST_F(LlvmLibcFDimTest, NegInfArg_fdimf) {
- testNegInfArg(&__llvm_libc::fdimf);
+ test_neg_inf_arg(&__llvm_libc::fdimf);
}
-TEST_F(LlvmLibcFDimTest, BothZero_fdimf) { testBothZero(&__llvm_libc::fdimf); }
+TEST_F(LlvmLibcFDimTest, BothZero_fdimf) {
+ test_both_zero(&__llvm_libc::fdimf);
+}
TEST_F(LlvmLibcFDimTest, InFloatRange_fdimf) {
- testInRange(&__llvm_libc::fdimf);
+ test_in_range(&__llvm_libc::fdimf);
}
diff --git a/libc/test/src/math/fdiml_test.cpp b/libc/test/src/math/fdiml_test.cpp
index b82819395b35f..79427d6a33d26 100644
--- a/libc/test/src/math/fdiml_test.cpp
+++ b/libc/test/src/math/fdiml_test.cpp
@@ -16,16 +16,18 @@
using LlvmLibcFDimTest = FDimTestTemplate<long double>;
-TEST_F(LlvmLibcFDimTest, NaNArg_fdiml) { testNaNArg(&__llvm_libc::fdiml); }
+TEST_F(LlvmLibcFDimTest, NaNArg_fdiml) { test_na_n_arg(&__llvm_libc::fdiml); }
-TEST_F(LlvmLibcFDimTest, InfArg_fdiml) { testInfArg(&__llvm_libc::fdiml); }
+TEST_F(LlvmLibcFDimTest, InfArg_fdiml) { test_inf_arg(&__llvm_libc::fdiml); }
TEST_F(LlvmLibcFDimTest, NegInfArg_fdiml) {
- testNegInfArg(&__llvm_libc::fdiml);
+ test_neg_inf_arg(&__llvm_libc::fdiml);
}
-TEST_F(LlvmLibcFDimTest, BothZero_fdiml) { testBothZero(&__llvm_libc::fdiml); }
+TEST_F(LlvmLibcFDimTest, BothZero_fdiml) {
+ test_both_zero(&__llvm_libc::fdiml);
+}
TEST_F(LlvmLibcFDimTest, InLongDoubleRange_fdiml) {
- testInRange(&__llvm_libc::fdiml);
+ test_in_range(&__llvm_libc::fdiml);
}
diff --git a/libc/test/src/math/fma_test.cpp b/libc/test/src/math/fma_test.cpp
index 520772797edfc..a9388cca72f79 100644
--- a/libc/test/src/math/fma_test.cpp
+++ b/libc/test/src/math/fma_test.cpp
@@ -13,11 +13,11 @@
using LlvmLibcFmaTest = FmaTestTemplate<double>;
TEST_F(LlvmLibcFmaTest, SpecialNumbers) {
- testSpecialNumbers(&__llvm_libc::fma);
+ test_special_numbers(&__llvm_libc::fma);
}
TEST_F(LlvmLibcFmaTest, SubnormalRange) {
- testSubnormalRange(&__llvm_libc::fma);
+ test_subnormal_range(&__llvm_libc::fma);
}
-TEST_F(LlvmLibcFmaTest, NormalRange) { testNormalRange(&__llvm_libc::fma); }
+TEST_F(LlvmLibcFmaTest, NormalRange) { test_normal_range(&__llvm_libc::fma); }
diff --git a/libc/test/src/math/fmaf_test.cpp b/libc/test/src/math/fmaf_test.cpp
index f58698c958517..73d009499deb9 100644
--- a/libc/test/src/math/fmaf_test.cpp
+++ b/libc/test/src/math/fmaf_test.cpp
@@ -13,11 +13,11 @@
using LlvmLibcFmaTest = FmaTestTemplate<float>;
TEST_F(LlvmLibcFmaTest, SpecialNumbers) {
- testSpecialNumbers(&__llvm_libc::fmaf);
+ test_special_numbers(&__llvm_libc::fmaf);
}
TEST_F(LlvmLibcFmaTest, SubnormalRange) {
- testSubnormalRange(&__llvm_libc::fmaf);
+ test_subnormal_range(&__llvm_libc::fmaf);
}
-TEST_F(LlvmLibcFmaTest, NormalRange) { testNormalRange(&__llvm_libc::fmaf); }
+TEST_F(LlvmLibcFmaTest, NormalRange) { test_normal_range(&__llvm_libc::fmaf); }
diff --git a/libc/test/src/math/hypot_test.cpp b/libc/test/src/math/hypot_test.cpp
index 928c38a494f63..2d7b640adf10a 100644
--- a/libc/test/src/math/hypot_test.cpp
+++ b/libc/test/src/math/hypot_test.cpp
@@ -13,11 +13,13 @@
using LlvmLibcHypotTest = HypotTestTemplate<double>;
TEST_F(LlvmLibcHypotTest, SpecialNumbers) {
- testSpecialNumbers(&__llvm_libc::hypot);
+ test_special_numbers(&__llvm_libc::hypot);
}
TEST_F(LlvmLibcHypotTest, SubnormalRange) {
- testSubnormalRange(&__llvm_libc::hypot);
+ test_subnormal_range(&__llvm_libc::hypot);
}
-TEST_F(LlvmLibcHypotTest, NormalRange) { testNormalRange(&__llvm_libc::hypot); }
+TEST_F(LlvmLibcHypotTest, NormalRange) {
+ test_normal_range(&__llvm_libc::hypot);
+}
diff --git a/libc/test/src/math/hypotf_test.cpp b/libc/test/src/math/hypotf_test.cpp
index 94f102efb73fc..2e958d63d84ad 100644
--- a/libc/test/src/math/hypotf_test.cpp
+++ b/libc/test/src/math/hypotf_test.cpp
@@ -13,13 +13,13 @@
using LlvmLibcHypotfTest = HypotTestTemplate<float>;
TEST_F(LlvmLibcHypotfTest, SpecialNumbers) {
- testSpecialNumbers(&__llvm_libc::hypotf);
+ test_special_numbers(&__llvm_libc::hypotf);
}
TEST_F(LlvmLibcHypotfTest, SubnormalRange) {
- testSubnormalRange(&__llvm_libc::hypotf);
+ test_subnormal_range(&__llvm_libc::hypotf);
}
TEST_F(LlvmLibcHypotfTest, NormalRange) {
- testNormalRange(&__llvm_libc::hypotf);
+ test_normal_range(&__llvm_libc::hypotf);
}
diff --git a/libc/test/src/math/ilogb_test.cpp b/libc/test/src/math/ilogb_test.cpp
index 8b8b51cb41be0..b049247815d2c 100644
--- a/libc/test/src/math/ilogb_test.cpp
+++ b/libc/test/src/math/ilogb_test.cpp
@@ -16,21 +16,21 @@
#include <math.h>
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogb) {
- testSpecialNumbers<double>(&__llvm_libc::ilogb);
+ test_special_numbers<double>(&__llvm_libc::ilogb);
}
TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogb) {
- testPowersOfTwo<double>(&__llvm_libc::ilogb);
+ test_powers_of_two<double>(&__llvm_libc::ilogb);
}
TEST_F(LlvmLibcILogbTest, SomeIntegers_ilogb) {
- testSomeIntegers<double>(&__llvm_libc::ilogb);
+ test_some_integers<double>(&__llvm_libc::ilogb);
}
TEST_F(LlvmLibcILogbTest, SubnormalRange_ilogb) {
- testSubnormalRange<double>(&__llvm_libc::ilogb);
+ test_subnormal_range<double>(&__llvm_libc::ilogb);
}
TEST_F(LlvmLibcILogbTest, NormalRange_ilogb) {
- testNormalRange<double>(&__llvm_libc::ilogb);
+ test_normal_range<double>(&__llvm_libc::ilogb);
}
diff --git a/libc/test/src/math/ilogbf_test.cpp b/libc/test/src/math/ilogbf_test.cpp
index 9fabc01ea9696..4b330a8fbbd21 100644
--- a/libc/test/src/math/ilogbf_test.cpp
+++ b/libc/test/src/math/ilogbf_test.cpp
@@ -16,21 +16,21 @@
#include <math.h>
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbf) {
- testSpecialNumbers<float>(&__llvm_libc::ilogbf);
+ test_special_numbers<float>(&__llvm_libc::ilogbf);
}
TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogbf) {
- testPowersOfTwo<float>(&__llvm_libc::ilogbf);
+ test_powers_of_two<float>(&__llvm_libc::ilogbf);
}
TEST_F(LlvmLibcILogbTest, SomeIntegers_ilogbf) {
- testSomeIntegers<float>(&__llvm_libc::ilogbf);
+ test_some_integers<float>(&__llvm_libc::ilogbf);
}
TEST_F(LlvmLibcILogbTest, SubnormalRange_ilogbf) {
- testSubnormalRange<float>(&__llvm_libc::ilogbf);
+ test_subnormal_range<float>(&__llvm_libc::ilogbf);
}
TEST_F(LlvmLibcILogbTest, NormalRange_ilogbf) {
- testNormalRange<float>(&__llvm_libc::ilogbf);
+ test_normal_range<float>(&__llvm_libc::ilogbf);
}
diff --git a/libc/test/src/math/ilogbl_test.cpp b/libc/test/src/math/ilogbl_test.cpp
index f36746b6f64fb..5979c96517abe 100644
--- a/libc/test/src/math/ilogbl_test.cpp
+++ b/libc/test/src/math/ilogbl_test.cpp
@@ -18,21 +18,21 @@
using RunContext = __llvm_libc::testing::RunContext;
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbl) {
- testSpecialNumbers<long double>(&__llvm_libc::ilogbl);
+ test_special_numbers<long double>(&__llvm_libc::ilogbl);
}
TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogbl) {
- testPowersOfTwo<long double>(&__llvm_libc::ilogbl);
+ test_powers_of_two<long double>(&__llvm_libc::ilogbl);
}
TEST_F(LlvmLibcILogbTest, SomeIntegers_ilogbl) {
- testSomeIntegers<long double>(&__llvm_libc::ilogbl);
+ test_some_integers<long double>(&__llvm_libc::ilogbl);
}
TEST_F(LlvmLibcILogbTest, SubnormalRange_ilogbl) {
- testSubnormalRange<long double>(&__llvm_libc::ilogbl);
+ test_subnormal_range<long double>(&__llvm_libc::ilogbl);
}
TEST_F(LlvmLibcILogbTest, NormalRange_ilogbl) {
- testNormalRange<long double>(&__llvm_libc::ilogbl);
+ test_normal_range<long double>(&__llvm_libc::ilogbl);
}
diff --git a/libc/test/src/math/logf_test.cpp b/libc/test/src/math/logf_test.cpp
index a3ada693a3cb3..eb4da810486d3 100644
--- a/libc/test/src/math/logf_test.cpp
+++ b/libc/test/src/math/logf_test.cpp
@@ -45,9 +45,9 @@ TEST(LlvmLibcLogfTest, TrickyInputs) {
}
TEST(LlvmLibcLogfTest, InFloatRange) {
- constexpr uint32_t count = 1000000;
- constexpr uint32_t step = UINT32_MAX / count;
- for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr uint32_t COUNT = 1000000;
+ constexpr uint32_t STEP = UINT32_MAX / COUNT;
+ for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
diff --git a/libc/test/src/math/sdcomp26094.h b/libc/test/src/math/sdcomp26094.h
index c42c12c237aff..316288441f94b 100644
--- a/libc/test/src/math/sdcomp26094.h
+++ b/libc/test/src/math/sdcomp26094.h
@@ -16,7 +16,7 @@
namespace __llvm_libc {
namespace testing {
-static constexpr __llvm_libc::cpp::Array<uint32_t, 10> sdcomp26094Values{
+static constexpr __llvm_libc::cpp::Array<uint32_t, 10> SDCOMP26094_VALUES{
0x46427f1b, 0x4647e568, 0x46428bac, 0x4647f1f9, 0x4647fe8a,
0x45d8d7f1, 0x45d371a4, 0x45ce0b57, 0x45d35882, 0x45cdf235,
};
diff --git a/libc/test/src/math/sin_test.cpp b/libc/test/src/math/sin_test.cpp
index bce7a72a8438c..e449074889140 100644
--- a/libc/test/src/math/sin_test.cpp
+++ b/libc/test/src/math/sin_test.cpp
@@ -20,9 +20,9 @@ DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibcSinTest, Range) {
static constexpr double _2pi = 6.283185307179586;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
double x = double(FPBits(v));
// TODO: Expand the range of testing after range reduction is implemented.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
diff --git a/libc/test/src/math/sincosf_test.cpp b/libc/test/src/math/sincosf_test.cpp
index 886fc1e7dcacd..2b4294d29c057 100644
--- a/libc/test/src/math/sincosf_test.cpp
+++ b/libc/test/src/math/sincosf_test.cpp
@@ -18,7 +18,7 @@
#include <errno.h>
#include <stdint.h>
-using __llvm_libc::testing::sdcomp26094Values;
+using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -58,9 +58,9 @@ TEST(LlvmLibcSinCosfTest, SpecialNumbers) {
}
TEST(LlvmLibcSinCosfTest, InFloatRange) {
- constexpr uint32_t count = 1000000;
- constexpr uint32_t step = UINT32_MAX / count;
- for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr uint32_t COUNT = 1000000;
+ constexpr uint32_t STEP = UINT32_MAX / COUNT;
+ for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits((v)));
if (isnan(x) || isinf(x))
continue;
@@ -95,7 +95,7 @@ TEST(LlvmLibcSinCosfTest, SmallValues) {
// SDCOMP-26094: check sinf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcSinCosfTest, SDCOMP_26094) {
- for (uint32_t v : sdcomp26094Values) {
+ for (uint32_t v : SDCOMP26094_VALUES) {
float x = float(FPBits((v)));
float sin, cos;
__llvm_libc::sincosf(x, &sin, &cos);
diff --git a/libc/test/src/math/sinf_test.cpp b/libc/test/src/math/sinf_test.cpp
index 64d932ee22f10..8fa43da08a44b 100644
--- a/libc/test/src/math/sinf_test.cpp
+++ b/libc/test/src/math/sinf_test.cpp
@@ -18,7 +18,7 @@
#include <errno.h>
#include <stdint.h>
-using __llvm_libc::testing::sdcomp26094Values;
+using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
@@ -47,9 +47,9 @@ TEST(LlvmLibcSinfTest, SpecialNumbers) {
}
TEST(LlvmLibcSinfTest, InFloatRange) {
- constexpr uint32_t count = 1000000;
- constexpr uint32_t step = UINT32_MAX / count;
- for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr uint32_t COUNT = 1000000;
+ constexpr uint32_t STEP = UINT32_MAX / COUNT;
+ for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
@@ -78,7 +78,7 @@ TEST(LlvmLibcSinfTest, SmallValues) {
// SDCOMP-26094: check sinf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcSinfTest, SDCOMP_26094) {
- for (uint32_t v : sdcomp26094Values) {
+ for (uint32_t v : SDCOMP26094_VALUES) {
float x = float(FPBits((v)));
EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), 1.0);
}
diff --git a/libc/test/src/math/tan_test.cpp b/libc/test/src/math/tan_test.cpp
index de3d6f16b76e8..750463148bc05 100644
--- a/libc/test/src/math/tan_test.cpp
+++ b/libc/test/src/math/tan_test.cpp
@@ -19,9 +19,9 @@ DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibctanTest, Range) {
static constexpr double _2pi = 6.283185307179586;
- constexpr UIntType count = 10000000;
- constexpr UIntType step = UIntType(-1) / count;
- for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ constexpr UIntType COUNT = 10000000;
+ constexpr UIntType STEP = UIntType(-1) / COUNT;
+ for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
double x = double(FPBits(v));
// TODO: Expand the range of testing after range reduction is implemented.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
diff --git a/libc/test/src/signal/sigprocmask_test.cpp b/libc/test/src/signal/sigprocmask_test.cpp
index e6463627ea9ed..8fe3f03b6cc83 100644
--- a/libc/test/src/signal/sigprocmask_test.cpp
+++ b/libc/test/src/signal/sigprocmask_test.cpp
@@ -21,9 +21,9 @@ class LlvmLibcSignalTest : public __llvm_libc::testing::Test {
sigset_t oldSet;
public:
- void SetUp() override { __llvm_libc::sigprocmask(0, nullptr, &oldSet); }
+ void set_up() override { __llvm_libc::sigprocmask(0, nullptr, &oldSet); }
- void TearDown() override {
+ void tear_down() override {
__llvm_libc::sigprocmask(SIG_SETMASK, &oldSet, nullptr);
}
};
diff --git a/libc/test/src/stdlib/atof_test.cpp b/libc/test/src/stdlib/atof_test.cpp
index a5379b2ee6666..620308c37d605 100644
--- a/libc/test/src/stdlib/atof_test.cpp
+++ b/libc/test/src/stdlib/atof_test.cpp
@@ -18,35 +18,35 @@
// This is just a simple test to make sure that this function works at all. It's
// functionally identical to strtod so the bulk of the testing is there.
TEST(LlvmLibcAToFTest, SimpleTest) {
- __llvm_libc::fputil::FPBits<double> expectedFP =
+ __llvm_libc::fputil::FPBits<double> expected_fp =
__llvm_libc::fputil::FPBits<double>(uint64_t(0x405ec00000000000));
errno = 0;
double result = __llvm_libc::atof("123");
- __llvm_libc::fputil::FPBits<double> actualFP =
+ __llvm_libc::fputil::FPBits<double> actual_fp =
__llvm_libc::fputil::FPBits<double>(result);
- EXPECT_EQ(actualFP.bits, expectedFP.bits);
- EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign());
- EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent());
- EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa());
+ EXPECT_EQ(actual_fp.bits, expected_fp.bits);
+ EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
+ EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
+ EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
EXPECT_EQ(errno, 0);
}
TEST(LlvmLibcAToFTest, FailedParsingTest) {
- __llvm_libc::fputil::FPBits<double> expectedFP =
+ __llvm_libc::fputil::FPBits<double> expected_fp =
__llvm_libc::fputil::FPBits<double>(uint64_t(0));
errno = 0;
double result = __llvm_libc::atof("???");
- __llvm_libc::fputil::FPBits<double> actualFP =
+ __llvm_libc::fputil::FPBits<double> actual_fp =
__llvm_libc::fputil::FPBits<double>(result);
- EXPECT_EQ(actualFP.bits, expectedFP.bits);
- EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign());
- EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent());
- EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa());
+ EXPECT_EQ(actual_fp.bits, expected_fp.bits);
+ EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
+ EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
+ EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
EXPECT_EQ(errno, 0);
}
diff --git a/libc/test/src/stdlib/bsearch_test.cpp b/libc/test/src/stdlib/bsearch_test.cpp
index 6076e47f9ab99..b8bd319f051ca 100644
--- a/libc/test/src/stdlib/bsearch_test.cpp
+++ b/libc/test/src/stdlib/bsearch_test.cpp
@@ -35,44 +35,44 @@ TEST(LlvmLibcBsearchTest, ErrorInputs) {
}
TEST(LlvmLibcBsearchTest, IntegerArray) {
- constexpr int array[25] = {10, 23, 33, 35, 55, 70, 71,
+ constexpr int ARRAY[25] = {10, 23, 33, 35, 55, 70, 71,
100, 110, 123, 133, 135, 155, 170,
171, 1100, 1110, 1123, 1133, 1135, 1155,
1170, 1171, 11100, 12310};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(ARRAY) / sizeof(int);
- for (size_t s = 1; s <= array_size; ++s) {
+ for (size_t s = 1; s <= ARRAY_SIZE; ++s) {
for (size_t i = 0; i < s; ++i) {
- int key = array[i];
+ int key = ARRAY[i];
void *elem =
- __llvm_libc::bsearch(&key, array, s, sizeof(int), int_compare);
+ __llvm_libc::bsearch(&key, ARRAY, s, sizeof(int), int_compare);
ASSERT_EQ(*reinterpret_cast<int *>(elem), key);
}
}
// Non existent keys
- for (size_t s = 1; s <= array_size; ++s) {
+ for (size_t s = 1; s <= ARRAY_SIZE; ++s) {
int key = 5;
- ASSERT_TRUE(__llvm_libc::bsearch(&key, &array, s, sizeof(int),
+ ASSERT_TRUE(__llvm_libc::bsearch(&key, &ARRAY, s, sizeof(int),
int_compare) == nullptr);
key = 125;
- ASSERT_TRUE(__llvm_libc::bsearch(&key, &array, s, sizeof(int),
+ ASSERT_TRUE(__llvm_libc::bsearch(&key, &ARRAY, s, sizeof(int),
int_compare) == nullptr);
key = 136;
- ASSERT_TRUE(__llvm_libc::bsearch(&key, &array, s, sizeof(int),
+ ASSERT_TRUE(__llvm_libc::bsearch(&key, &ARRAY, s, sizeof(int),
int_compare) == nullptr);
key = 12345;
- ASSERT_TRUE(__llvm_libc::bsearch(&key, &array, s, sizeof(int),
+ ASSERT_TRUE(__llvm_libc::bsearch(&key, &ARRAY, s, sizeof(int),
int_compare) == nullptr);
}
}
TEST(LlvmLibcBsearchTest, SameKeyAndArray) {
- constexpr int array[5] = {1, 2, 3, 4, 5};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr int ARRAY[5] = {1, 2, 3, 4, 5};
+ constexpr size_t ARRAY_SIZE = sizeof(ARRAY) / sizeof(int);
void *elem =
- __llvm_libc::bsearch(array, array, array_size, sizeof(int), int_compare);
- EXPECT_EQ(*reinterpret_cast<int *>(elem), array[0]);
+ __llvm_libc::bsearch(ARRAY, ARRAY, ARRAY_SIZE, sizeof(int), int_compare);
+ EXPECT_EQ(*reinterpret_cast<int *>(elem), ARRAY[0]);
}
diff --git a/libc/test/src/stdlib/qsort_test.cpp b/libc/test/src/stdlib/qsort_test.cpp
index 8de8beee598d9..99ccc3fa6046c 100644
--- a/libc/test/src/stdlib/qsort_test.cpp
+++ b/libc/test/src/stdlib/qsort_test.cpp
@@ -27,9 +27,9 @@ TEST(LlvmLibcQsortTest, SortedArray) {
int array[25] = {10, 23, 33, 35, 55, 70, 71, 100, 110,
123, 133, 135, 155, 170, 171, 1100, 1110, 1123,
1133, 1135, 1155, 1170, 1171, 11100, 12310};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 10);
ASSERT_LE(array[1], 23);
@@ -61,11 +61,11 @@ TEST(LlvmLibcQsortTest, SortedArray) {
TEST(LlvmLibcQsortTest, ReverseSortedArray) {
int array[25] = {25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13,
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
- for (int i = 0; i < int(array_size - 1); ++i)
+ for (int i = 0; i < int(ARRAY_SIZE - 1); ++i)
ASSERT_LE(array[i], i + 1);
}
@@ -73,20 +73,20 @@ TEST(LlvmLibcQsortTest, AllEqualElements) {
int array[25] = {100, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100, 100, 100, 100, 100, 100, 100, 100,
100, 100, 100, 100, 100, 100, 100};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
- for (size_t i = 0; i < array_size - 1; ++i)
+ for (size_t i = 0; i < ARRAY_SIZE - 1; ++i)
ASSERT_LE(array[i], 100);
}
TEST(LlvmLibcQsortTest, UnsortedArray1) {
int array[25] = {10, 23, 8, 35, 55, 45, 40, 100, 110, 123, 90, 80, 70,
60, 171, 11, 1, -1, -5, -10, 1155, 1170, 1171, 12, -100};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], -100);
ASSERT_LE(array[1], -10);
@@ -117,9 +117,9 @@ TEST(LlvmLibcQsortTest, UnsortedArray1) {
TEST(LlvmLibcQsortTest, UnsortedArray2) {
int array[7] = {10, 40, 45, 55, 35, 23, 60};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 10);
ASSERT_LE(array[1], 23);
@@ -132,9 +132,9 @@ TEST(LlvmLibcQsortTest, UnsortedArray2) {
TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements1) {
int array[6] = {10, 10, 20, 20, 5, 5};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 5);
ASSERT_LE(array[1], 5);
@@ -146,9 +146,9 @@ TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements1) {
TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements2) {
int array[10] = {20, 10, 10, 10, 10, 20, 21, 21, 21, 21};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 10);
ASSERT_LE(array[1], 10);
@@ -164,9 +164,9 @@ TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements2) {
TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements3) {
int array[10] = {20, 30, 30, 30, 30, 20, 21, 21, 21, 21};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 20);
ASSERT_LE(array[1], 20);
@@ -182,9 +182,9 @@ TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements3) {
TEST(LlvmLibcQsortTest, UnsortedThreeElementArray1) {
int array[3] = {14999024, 0, 3};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 0);
ASSERT_LE(array[1], 3);
@@ -193,9 +193,9 @@ TEST(LlvmLibcQsortTest, UnsortedThreeElementArray1) {
TEST(LlvmLibcQsortTest, UnsortedThreeElementArray2) {
int array[3] = {3, 14999024, 0};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 0);
ASSERT_LE(array[1], 3);
@@ -204,9 +204,9 @@ TEST(LlvmLibcQsortTest, UnsortedThreeElementArray2) {
TEST(LlvmLibcQsortTest, UnsortedThreeElementArray3) {
int array[3] = {3, 0, 14999024};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 0);
ASSERT_LE(array[1], 3);
@@ -215,9 +215,9 @@ TEST(LlvmLibcQsortTest, UnsortedThreeElementArray3) {
TEST(LlvmLibcQsortTest, SameElementThreeElementArray) {
int array[3] = {12345, 12345, 12345};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 12345);
ASSERT_LE(array[1], 12345);
@@ -226,9 +226,9 @@ TEST(LlvmLibcQsortTest, SameElementThreeElementArray) {
TEST(LlvmLibcQsortTest, UnsortedTwoElementArray1) {
int array[2] = {14999024, 0};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 0);
ASSERT_LE(array[1], 14999024);
@@ -236,9 +236,9 @@ TEST(LlvmLibcQsortTest, UnsortedTwoElementArray1) {
TEST(LlvmLibcQsortTest, UnsortedTwoElementArray2) {
int array[2] = {0, 14999024};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 0);
ASSERT_LE(array[1], 14999024);
@@ -246,20 +246,20 @@ TEST(LlvmLibcQsortTest, UnsortedTwoElementArray2) {
TEST(LlvmLibcQsortTest, SameElementTwoElementArray) {
int array[2] = {12345, 12345};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
ASSERT_LE(array[0], 12345);
ASSERT_LE(array[1], 12345);
}
TEST(LlvmLibcQSortTest, SingleElementArray) {
- constexpr int elem = 12345;
- int array[1] = {elem};
- constexpr size_t array_size = sizeof(array) / sizeof(int);
+ constexpr int ELEM = 12345;
+ int array[1] = {ELEM};
+ constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);
- __llvm_libc::qsort(array, array_size, sizeof(int), int_compare);
+ __llvm_libc::qsort(array, ARRAY_SIZE, sizeof(int), int_compare);
- ASSERT_LE(array[0], elem);
+ ASSERT_LE(array[0], ELEM);
}
diff --git a/libc/test/src/stdlib/strtod_test.cpp b/libc/test/src/stdlib/strtod_test.cpp
index 154cf1a33e7e7..eee11231c0442 100644
--- a/libc/test/src/stdlib/strtod_test.cpp
+++ b/libc/test/src/stdlib/strtod_test.cpp
@@ -17,8 +17,8 @@
class LlvmLibcStrToDTest : public __llvm_libc::testing::Test {
public:
- void runTest(const char *inputString, const ptr
diff _t expectedStrLen,
- const uint64_t expectedRawData, const int expectedErrno = 0) {
+ void run_test(const char *inputString, const ptr
diff _t expectedStrLen,
+ const uint64_t expectedRawData, const int expectedErrno = 0) {
// expectedRawData is the expected double result as a uint64_t, organized
// according to IEEE754:
//
@@ -33,58 +33,59 @@ class LlvmLibcStrToDTest : public __llvm_libc::testing::Test {
// +-- 11 Exponent Bits
//
// This is so that the result can be compared in parts.
- char *strEnd = nullptr;
+ char *str_end = nullptr;
- __llvm_libc::fputil::FPBits<double> expectedFP =
+ __llvm_libc::fputil::FPBits<double> expected_fp =
__llvm_libc::fputil::FPBits<double>(expectedRawData);
errno = 0;
- double result = __llvm_libc::strtod(inputString, &strEnd);
+ double result = __llvm_libc::strtod(inputString, &str_end);
- __llvm_libc::fputil::FPBits<double> actualFP =
+ __llvm_libc::fputil::FPBits<double> actual_fp =
__llvm_libc::fputil::FPBits<double>(result);
- EXPECT_EQ(strEnd - inputString, expectedStrLen);
+ EXPECT_EQ(str_end - inputString, expectedStrLen);
- EXPECT_EQ(actualFP.bits, expectedFP.bits);
- EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign());
- EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent());
- EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa());
+ EXPECT_EQ(actual_fp.bits, expected_fp.bits);
+ EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
+ EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
+ EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
EXPECT_EQ(errno, expectedErrno);
}
};
TEST_F(LlvmLibcStrToDTest, SimpleTest) {
- runTest("123", 3, uint64_t(0x405ec00000000000));
+ run_test("123", 3, uint64_t(0x405ec00000000000));
// This should fail on Eisel-Lemire, forcing a fallback to simple decimal
// conversion.
- runTest("12345678901234549760", 20, uint64_t(0x43e56a95319d63d8));
+ run_test("12345678901234549760", 20, uint64_t(0x43e56a95319d63d8));
// Found while looking for
diff icult test cases here:
// https://github.com/nigeltao/parse-number-fxx-test-data/blob/main/more-test-cases/golang-org-issue-36657.txt
- runTest("1090544144181609348835077142190", 31, uint64_t(0x462b8779f2474dfb));
+ run_test("1090544144181609348835077142190", 31, uint64_t(0x462b8779f2474dfb));
- runTest("0x123", 5, uint64_t(0x4072300000000000));
+ run_test("0x123", 5, uint64_t(0x4072300000000000));
}
// These are tests that have caused problems in the past.
TEST_F(LlvmLibcStrToDTest, SpecificFailures) {
- runTest("3E70000000000000", 16, uint64_t(0x7FF0000000000000), ERANGE);
- runTest("358416272e-33", 13, uint64_t(0x3adbbb2a68c9d0b9));
- runTest("2.16656806400000023841857910156251e9", 36,
- uint64_t(0x41e0246690000001));
- runTest("27949676547093071875", 20, uint64_t(0x43f83e132bc608c9));
+ run_test("3E70000000000000", 16, uint64_t(0x7FF0000000000000), ERANGE);
+ run_test("358416272e-33", 13, uint64_t(0x3adbbb2a68c9d0b9));
+ run_test("2.16656806400000023841857910156251e9", 36,
+ uint64_t(0x41e0246690000001));
+ run_test("27949676547093071875", 20, uint64_t(0x43f83e132bc608c9));
}
TEST_F(LlvmLibcStrToDTest, FuzzFailures) {
- runTest("-\xff\xff\xff\xff\xff\xff\xff\x01", 0, uint64_t(0));
- runTest("-.????", 0, uint64_t(0));
- runTest("44444444444444444444444444444444444444444444444444A44444444444444444"
- "44444444444*\x99\xff\xff\xff\xff",
- 50, uint64_t(0x4a3e68fdd0e0b2d8));
- runTest("-NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKNNNNNNNNNNNNNNNNNN?"
- "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN?",
- 0, uint64_t(0));
- runTest("0x.666E40", 9, uint64_t(0x3fd99b9000000000));
+ run_test("-\xff\xff\xff\xff\xff\xff\xff\x01", 0, uint64_t(0));
+ run_test("-.????", 0, uint64_t(0));
+ run_test(
+ "44444444444444444444444444444444444444444444444444A44444444444444444"
+ "44444444444*\x99\xff\xff\xff\xff",
+ 50, uint64_t(0x4a3e68fdd0e0b2d8));
+ run_test("-NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKNNNNNNNNNNNNNNNNNN?"
+ "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN?",
+ 0, uint64_t(0));
+ run_test("0x.666E40", 9, uint64_t(0x3fd99b9000000000));
}
diff --git a/libc/test/src/stdlib/strtof_test.cpp b/libc/test/src/stdlib/strtof_test.cpp
index db6c194904db5..e47541da47ccb 100644
--- a/libc/test/src/stdlib/strtof_test.cpp
+++ b/libc/test/src/stdlib/strtof_test.cpp
@@ -17,8 +17,8 @@
class LlvmLibcStrToFTest : public __llvm_libc::testing::Test {
public:
- void runTest(const char *inputString, const ptr
diff _t expectedStrLen,
- const uint32_t expectedRawData, const int expectedErrno = 0) {
+ void run_test(const char *inputString, const ptr
diff _t expectedStrLen,
+ const uint32_t expectedRawData, const int expectedErrno = 0) {
// expectedRawData is the expected float result as a uint32_t, organized
// according to IEEE754:
//
@@ -33,23 +33,23 @@ class LlvmLibcStrToFTest : public __llvm_libc::testing::Test {
// +-- 8 Exponent Bits
//
// This is so that the result can be compared in parts.
- char *strEnd = nullptr;
+ char *str_end = nullptr;
- __llvm_libc::fputil::FPBits<float> expectedFP =
+ __llvm_libc::fputil::FPBits<float> expected_fp =
__llvm_libc::fputil::FPBits<float>(expectedRawData);
errno = 0;
- float result = __llvm_libc::strtof(inputString, &strEnd);
+ float result = __llvm_libc::strtof(inputString, &str_end);
- __llvm_libc::fputil::FPBits<float> actualFP =
+ __llvm_libc::fputil::FPBits<float> actual_fp =
__llvm_libc::fputil::FPBits<float>(result);
- EXPECT_EQ(strEnd - inputString, expectedStrLen);
+ EXPECT_EQ(str_end - inputString, expectedStrLen);
- EXPECT_EQ(actualFP.bits, expectedFP.bits);
- EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign());
- EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent());
- EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa());
+ EXPECT_EQ(actual_fp.bits, expected_fp.bits);
+ EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
+ EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
+ EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
EXPECT_EQ(errno, expectedErrno);
}
};
@@ -59,115 +59,117 @@ class LlvmLibcStrToFTest : public __llvm_libc::testing::Test {
// them.
TEST_F(LlvmLibcStrToFTest, BasicDecimalTests) {
- runTest("1", 1, 0x3f800000);
- runTest("123", 3, 0x42f60000);
- runTest("1234567890", 10, 0x4e932c06u);
- runTest("123456789012345678901", 21, 0x60d629d4);
- runTest("0.1", 3, 0x3dcccccdu);
- runTest(".1", 2, 0x3dcccccdu);
- runTest("-0.123456789", 12, 0xbdfcd6eau);
- runTest("0.11111111111111111111", 22, 0x3de38e39u);
- runTest("0.0000000000000000000000001", 27, 0x15f79688u);
+ run_test("1", 1, 0x3f800000);
+ run_test("123", 3, 0x42f60000);
+ run_test("1234567890", 10, 0x4e932c06u);
+ run_test("123456789012345678901", 21, 0x60d629d4);
+ run_test("0.1", 3, 0x3dcccccdu);
+ run_test(".1", 2, 0x3dcccccdu);
+ run_test("-0.123456789", 12, 0xbdfcd6eau);
+ run_test("0.11111111111111111111", 22, 0x3de38e39u);
+ run_test("0.0000000000000000000000001", 27, 0x15f79688u);
}
TEST_F(LlvmLibcStrToFTest, DecimalOutOfRangeTests) {
- runTest("555E36", 6, 0x7f800000, ERANGE);
- runTest("1e-10000", 8, 0x0, ERANGE);
+ run_test("555E36", 6, 0x7f800000, ERANGE);
+ run_test("1e-10000", 8, 0x0, ERANGE);
}
TEST_F(LlvmLibcStrToFTest, DecimalsWithRoundingProblems) {
- runTest("20040229", 8, 0x4b98e512);
- runTest("20040401", 8, 0x4b98e568);
- runTest("9E9", 3, 0x50061c46);
+ run_test("20040229", 8, 0x4b98e512);
+ run_test("20040401", 8, 0x4b98e568);
+ run_test("9E9", 3, 0x50061c46);
}
TEST_F(LlvmLibcStrToFTest, DecimalSubnormals) {
- runTest("1.4012984643248170709237295832899161312802619418765e-45", 55, 0x1,
- ERANGE);
+ run_test("1.4012984643248170709237295832899161312802619418765e-45", 55, 0x1,
+ ERANGE);
}
TEST_F(LlvmLibcStrToFTest, DecimalWithLongExponent) {
- runTest("1e2147483648", 12, 0x7f800000, ERANGE);
- runTest("1e2147483646", 12, 0x7f800000, ERANGE);
- runTest("100e2147483646", 14, 0x7f800000, ERANGE);
- runTest("1e-2147483647", 13, 0x0, ERANGE);
- runTest("1e-2147483649", 13, 0x0, ERANGE);
+ run_test("1e2147483648", 12, 0x7f800000, ERANGE);
+ run_test("1e2147483646", 12, 0x7f800000, ERANGE);
+ run_test("100e2147483646", 14, 0x7f800000, ERANGE);
+ run_test("1e-2147483647", 13, 0x0, ERANGE);
+ run_test("1e-2147483649", 13, 0x0, ERANGE);
}
TEST_F(LlvmLibcStrToFTest, BasicHexadecimalTests) {
- runTest("0x1", 3, 0x3f800000);
- runTest("0x10", 4, 0x41800000);
- runTest("0x11", 4, 0x41880000);
- runTest("0x0.1234", 8, 0x3d91a000);
+ run_test("0x1", 3, 0x3f800000);
+ run_test("0x10", 4, 0x41800000);
+ run_test("0x11", 4, 0x41880000);
+ run_test("0x0.1234", 8, 0x3d91a000);
}
TEST_F(LlvmLibcStrToFTest, HexadecimalSubnormalTests) {
- runTest("0x0.0000000000000000000000000000000002", 38, 0x4000, ERANGE);
+ run_test("0x0.0000000000000000000000000000000002", 38, 0x4000, ERANGE);
// This is the largest subnormal number as represented in hex
- runTest("0x0.00000000000000000000000000000003fffff8", 42, 0x7fffff, ERANGE);
+ run_test("0x0.00000000000000000000000000000003fffff8", 42, 0x7fffff, ERANGE);
}
TEST_F(LlvmLibcStrToFTest, HexadecimalSubnormalRoundingTests) {
// This is the largest subnormal number that gets rounded down to 0 (as a
// float)
- runTest("0x0.00000000000000000000000000000000000004", 42, 0x0, ERANGE);
+ run_test("0x0.00000000000000000000000000000000000004", 42, 0x0, ERANGE);
// This is slightly larger, and thus rounded up
- runTest("0x0.000000000000000000000000000000000000041", 43, 0x00000001,
- ERANGE);
+ run_test("0x0.000000000000000000000000000000000000041", 43, 0x00000001,
+ ERANGE);
// These check that we're rounding to even properly
- runTest("0x0.0000000000000000000000000000000000000b", 42, 0x00000001, ERANGE);
- runTest("0x0.0000000000000000000000000000000000000c", 42, 0x00000002, ERANGE);
+ run_test("0x0.0000000000000000000000000000000000000b", 42, 0x00000001,
+ ERANGE);
+ run_test("0x0.0000000000000000000000000000000000000c", 42, 0x00000002,
+ ERANGE);
// These check that we're rounding to even properly even when the input bits
// are longer than the bit fields can contain.
- runTest("0x1.000000000000000000000p-150", 30, 0x00000000, ERANGE);
- runTest("0x1.000010000000000001000p-150", 30, 0x00000001, ERANGE);
- runTest("0x1.000100000000000001000p-134", 30, 0x00008001, ERANGE);
- runTest("0x1.FFFFFC000000000001000p-127", 30, 0x007FFFFF, ERANGE);
- runTest("0x1.FFFFFE000000000000000p-127", 30, 0x00800000);
+ run_test("0x1.000000000000000000000p-150", 30, 0x00000000, ERANGE);
+ run_test("0x1.000010000000000001000p-150", 30, 0x00000001, ERANGE);
+ run_test("0x1.000100000000000001000p-134", 30, 0x00008001, ERANGE);
+ run_test("0x1.FFFFFC000000000001000p-127", 30, 0x007FFFFF, ERANGE);
+ run_test("0x1.FFFFFE000000000000000p-127", 30, 0x00800000);
}
TEST_F(LlvmLibcStrToFTest, HexadecimalNormalRoundingTests) {
// This also checks the round to even behavior by checking three adjacent
// numbers.
// This gets rounded down to even
- runTest("0x123456500", 11, 0x4f91a2b2);
+ run_test("0x123456500", 11, 0x4f91a2b2);
// This doesn't get rounded at all
- runTest("0x123456600", 11, 0x4f91a2b3);
+ run_test("0x123456600", 11, 0x4f91a2b3);
// This gets rounded up to even
- runTest("0x123456700", 11, 0x4f91a2b4);
+ run_test("0x123456700", 11, 0x4f91a2b4);
// Correct rounding for long input
- runTest("0x1.000001000000000000000", 25, 0x3f800000);
- runTest("0x1.000001000000000000100", 25, 0x3f800001);
+ run_test("0x1.000001000000000000000", 25, 0x3f800000);
+ run_test("0x1.000001000000000000100", 25, 0x3f800001);
}
TEST_F(LlvmLibcStrToFTest, HexadecimalsWithRoundingProblems) {
- runTest("0xFFFFFFFF", 10, 0x4f800000);
+ run_test("0xFFFFFFFF", 10, 0x4f800000);
}
TEST_F(LlvmLibcStrToFTest, HexadecimalOutOfRangeTests) {
- runTest("0x123456789123456789123456789123456789", 38, 0x7f800000, ERANGE);
- runTest("-0x123456789123456789123456789123456789", 39, 0xff800000, ERANGE);
- runTest("0x0.00000000000000000000000000000000000001", 42, 0x0, ERANGE);
+ run_test("0x123456789123456789123456789123456789", 38, 0x7f800000, ERANGE);
+ run_test("-0x123456789123456789123456789123456789", 39, 0xff800000, ERANGE);
+ run_test("0x0.00000000000000000000000000000000000001", 42, 0x0, ERANGE);
}
TEST_F(LlvmLibcStrToFTest, InfTests) {
- runTest("INF", 3, 0x7f800000);
- runTest("INFinity", 8, 0x7f800000);
- runTest("infnity", 3, 0x7f800000);
- runTest("infinit", 3, 0x7f800000);
- runTest("infinfinit", 3, 0x7f800000);
- runTest("innf", 0, 0x0);
- runTest("-inf", 4, 0xff800000);
- runTest("-iNfInItY", 9, 0xff800000);
+ run_test("INF", 3, 0x7f800000);
+ run_test("INFinity", 8, 0x7f800000);
+ run_test("infnity", 3, 0x7f800000);
+ run_test("infinit", 3, 0x7f800000);
+ run_test("infinfinit", 3, 0x7f800000);
+ run_test("innf", 0, 0x0);
+ run_test("-inf", 4, 0xff800000);
+ run_test("-iNfInItY", 9, 0xff800000);
}
TEST_F(LlvmLibcStrToFTest, SimpleNaNTests) {
- runTest("NaN", 3, 0x7fc00000);
- runTest("-nAn", 4, 0xffc00000);
+ run_test("NaN", 3, 0x7fc00000);
+ run_test("-nAn", 4, 0xffc00000);
}
// These NaNs are of the form `NaN(n-character-sequence)` where the
@@ -178,26 +180,26 @@ TEST_F(LlvmLibcStrToFTest, SimpleNaNTests) {
// the result is put into the mantissa if it takes up the whole width of the
// parentheses.
TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesEmptyTest) {
- runTest("NaN()", 5, 0x7fc00000);
+ run_test("NaN()", 5, 0x7fc00000);
}
TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesValidNumberTests) {
- runTest("NaN(1234)", 9, 0x7fc004d2);
- runTest("NaN(0x1234)", 11, 0x7fc01234);
- runTest("NaN(01234)", 10, 0x7fc0029c);
+ run_test("NaN(1234)", 9, 0x7fc004d2);
+ run_test("NaN(0x1234)", 11, 0x7fc01234);
+ run_test("NaN(01234)", 10, 0x7fc0029c);
}
TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesInvalidSequenceTests) {
- runTest("NaN( 1234)", 3, 0x7fc00000);
- runTest("NaN(-1234)", 3, 0x7fc00000);
- runTest("NaN(asd&f)", 3, 0x7fc00000);
- runTest("NaN(123 )", 3, 0x7fc00000);
- runTest("NaN(123+asdf)", 3, 0x7fc00000);
- runTest("NaN(123", 3, 0x7fc00000);
+ run_test("NaN( 1234)", 3, 0x7fc00000);
+ run_test("NaN(-1234)", 3, 0x7fc00000);
+ run_test("NaN(asd&f)", 3, 0x7fc00000);
+ run_test("NaN(123 )", 3, 0x7fc00000);
+ run_test("NaN(123+asdf)", 3, 0x7fc00000);
+ run_test("NaN(123", 3, 0x7fc00000);
}
TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesValidSequenceInvalidNumberTests) {
- runTest("NaN(1a)", 7, 0x7fc00000);
- runTest("NaN(asdf)", 9, 0x7fc00000);
- runTest("NaN(1A1)", 8, 0x7fc00000);
+ run_test("NaN(1a)", 7, 0x7fc00000);
+ run_test("NaN(asdf)", 9, 0x7fc00000);
+ run_test("NaN(1A1)", 8, 0x7fc00000);
}
diff --git a/libc/test/src/stdlib/strtold_test.cpp b/libc/test/src/stdlib/strtold_test.cpp
index c1d41bc302f59..0aa8f45e623d2 100644
--- a/libc/test/src/stdlib/strtold_test.cpp
+++ b/libc/test/src/stdlib/strtold_test.cpp
@@ -17,12 +17,12 @@
class LlvmLibcStrToLDTest : public __llvm_libc::testing::Test {
public:
- void runTest(const char *inputString, const ptr
diff _t expectedStrLen,
- const uint64_t expectedRawData64,
- const __uint128_t expectedRawData80,
- const __uint128_t expectedRawData128,
- const int expectedErrno64 = 0, const int expectedErrno80 = 0,
- const int expectedErrno128 = 0) {
+ void run_test(const char *inputString, const ptr
diff _t expectedStrLen,
+ const uint64_t expectedRawData64,
+ const __uint128_t expectedRawData80,
+ const __uint128_t expectedRawData128,
+ const int expectedErrno64 = 0, const int expectedErrno80 = 0,
+ const int expectedErrno128 = 0) {
// expectedRawData64 is the expected long double result as a uint64_t,
// organized according to the IEEE754 double precision format:
//
@@ -61,16 +61,16 @@ class LlvmLibcStrToLDTest : public __llvm_libc::testing::Test {
// +------+------+
// |
// +-- 15 Exponent Bits
- char *strEnd = nullptr;
+ char *str_end = nullptr;
#if defined(LONG_DOUBLE_IS_DOUBLE)
__llvm_libc::fputil::FPBits<long double> expectedFP =
__llvm_libc::fputil::FPBits<long double>(expectedRawData64);
const int expectedErrno = expectedErrno64;
#elif defined(SPECIAL_X86_LONG_DOUBLE)
- __llvm_libc::fputil::FPBits<long double> expectedFP =
+ __llvm_libc::fputil::FPBits<long double> expected_fp =
__llvm_libc::fputil::FPBits<long double>(expectedRawData80);
- const int expectedErrno = expectedErrno80;
+ const int expected_errno = expectedErrno80;
#else
__llvm_libc::fputil::FPBits<long double> expectedFP =
__llvm_libc::fputil::FPBits<long double>(expectedRawData128);
@@ -78,144 +78,146 @@ class LlvmLibcStrToLDTest : public __llvm_libc::testing::Test {
#endif
errno = 0;
- long double result = __llvm_libc::strtold(inputString, &strEnd);
+ long double result = __llvm_libc::strtold(inputString, &str_end);
- __llvm_libc::fputil::FPBits<long double> actualFP =
+ __llvm_libc::fputil::FPBits<long double> actual_fp =
__llvm_libc::fputil::FPBits<long double>();
- actualFP = __llvm_libc::fputil::FPBits<long double>(result);
+ actual_fp = __llvm_libc::fputil::FPBits<long double>(result);
- EXPECT_EQ(strEnd - inputString, expectedStrLen);
+ EXPECT_EQ(str_end - inputString, expectedStrLen);
- EXPECT_EQ(actualFP.bits, expectedFP.bits);
- EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign());
- EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent());
- EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa());
- EXPECT_EQ(errno, expectedErrno);
+ EXPECT_EQ(actual_fp.bits, expected_fp.bits);
+ EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
+ EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
+ EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
+ EXPECT_EQ(errno, expected_errno);
}
};
TEST_F(LlvmLibcStrToLDTest, SimpleTest) {
- runTest("123", 3, uint64_t(0x405ec00000000000),
- __uint128_t(0x4005f60000) << 40,
- __uint128_t(0x4005ec0000000000) << 64);
+ run_test("123", 3, uint64_t(0x405ec00000000000),
+ __uint128_t(0x4005f60000) << 40,
+ __uint128_t(0x4005ec0000000000) << 64);
// This should fail on Eisel-Lemire, forcing a fallback to simple decimal
// conversion.
- runTest("12345678901234549760", 20, uint64_t(0x43e56a95319d63d8),
- (__uint128_t(0x403eab54a9) << 40) + __uint128_t(0x8ceb1ec400),
- (__uint128_t(0x403e56a95319d63d) << 64) +
- __uint128_t(0x8800000000000000));
+ run_test("12345678901234549760", 20, uint64_t(0x43e56a95319d63d8),
+ (__uint128_t(0x403eab54a9) << 40) + __uint128_t(0x8ceb1ec400),
+ (__uint128_t(0x403e56a95319d63d) << 64) +
+ __uint128_t(0x8800000000000000));
// Found while looking for
diff icult test cases here:
// https://github.com/nigeltao/parse-number-fxx-test-data/blob/main/more-test-cases/golang-org-issue-36657.txt
- runTest("1090544144181609348835077142190", 31, uint64_t(0x462b8779f2474dfb),
- (__uint128_t(0x4062dc3bcf) << 40) + __uint128_t(0x923a6fd402),
- (__uint128_t(0x4062b8779f2474df) << 64) +
- __uint128_t(0xa804bfd8c6d5c000));
-
- runTest("0x123", 5, uint64_t(0x4072300000000000),
- (__uint128_t(0x4007918000) << 40),
- (__uint128_t(0x4007230000000000) << 64));
+ run_test("1090544144181609348835077142190", 31, uint64_t(0x462b8779f2474dfb),
+ (__uint128_t(0x4062dc3bcf) << 40) + __uint128_t(0x923a6fd402),
+ (__uint128_t(0x4062b8779f2474df) << 64) +
+ __uint128_t(0xa804bfd8c6d5c000));
+
+ run_test("0x123", 5, uint64_t(0x4072300000000000),
+ (__uint128_t(0x4007918000) << 40),
+ (__uint128_t(0x4007230000000000) << 64));
}
// These are tests that have caused problems for doubles in the past.
TEST_F(LlvmLibcStrToLDTest, Float64SpecificFailures) {
- runTest("3E70000000000000", 16, uint64_t(0x7FF0000000000000),
- (__uint128_t(0x7fff800000) << 40),
- (__uint128_t(0x7fff000000000000) << 64), ERANGE, ERANGE, ERANGE);
- runTest("358416272e-33", 13, uint64_t(0x3adbbb2a68c9d0b9),
- (__uint128_t(0x3fadddd953) << 40) + __uint128_t(0x464e85c400),
- (__uint128_t(0x3fadbbb2a68c9d0b) << 64) +
- __uint128_t(0x8800e7969e1c5fc8));
- runTest(
+ run_test("3E70000000000000", 16, uint64_t(0x7FF0000000000000),
+ (__uint128_t(0x7fff800000) << 40),
+ (__uint128_t(0x7fff000000000000) << 64), ERANGE, ERANGE, ERANGE);
+ run_test("358416272e-33", 13, uint64_t(0x3adbbb2a68c9d0b9),
+ (__uint128_t(0x3fadddd953) << 40) + __uint128_t(0x464e85c400),
+ (__uint128_t(0x3fadbbb2a68c9d0b) << 64) +
+ __uint128_t(0x8800e7969e1c5fc8));
+ run_test(
"2.16656806400000023841857910156251e9", 36, uint64_t(0x41e0246690000001),
(__uint128_t(0x401e812334) << 40) + __uint128_t(0x8000000400),
(__uint128_t(0x401e024669000000) << 64) + __uint128_t(0x800000000000018));
- runTest("27949676547093071875", 20, uint64_t(0x43f83e132bc608c9),
- (__uint128_t(0x403fc1f099) << 40) + __uint128_t(0x5e30464402),
- (__uint128_t(0x403f83e132bc608c) << 64) +
- __uint128_t(0x8803000000000000));
+ run_test("27949676547093071875", 20, uint64_t(0x43f83e132bc608c9),
+ (__uint128_t(0x403fc1f099) << 40) + __uint128_t(0x5e30464402),
+ (__uint128_t(0x403f83e132bc608c) << 64) +
+ __uint128_t(0x8803000000000000));
}
TEST_F(LlvmLibcStrToLDTest, MaxSizeNumbers) {
- runTest("1.1897314953572317650e4932", 26, uint64_t(0x7FF0000000000000),
- (__uint128_t(0x7ffeffffff) << 40) + __uint128_t(0xffffffffff),
- (__uint128_t(0x7ffeffffffffffff) << 64) +
- __uint128_t(0xfffd57322e3f8675),
- ERANGE, 0, 0);
- runTest("1.18973149535723176508e4932", 27, uint64_t(0x7FF0000000000000),
- (__uint128_t(0x7fff800000) << 40),
- (__uint128_t(0x7ffeffffffffffff) << 64) +
- __uint128_t(0xffffd2478338036c),
- ERANGE, ERANGE, 0);
+ run_test("1.1897314953572317650e4932", 26, uint64_t(0x7FF0000000000000),
+ (__uint128_t(0x7ffeffffff) << 40) + __uint128_t(0xffffffffff),
+ (__uint128_t(0x7ffeffffffffffff) << 64) +
+ __uint128_t(0xfffd57322e3f8675),
+ ERANGE, 0, 0);
+ run_test("1.18973149535723176508e4932", 27, uint64_t(0x7FF0000000000000),
+ (__uint128_t(0x7fff800000) << 40),
+ (__uint128_t(0x7ffeffffffffffff) << 64) +
+ __uint128_t(0xffffd2478338036c),
+ ERANGE, ERANGE, 0);
}
// These tests check subnormal behavior for 80 bit and 128 bit floats. They will
// be too small for 64 bit floats.
TEST_F(LlvmLibcStrToLDTest, SubnormalTests) {
- runTest("1e-4950", 7, uint64_t(0), (__uint128_t(0x00000000000000000003)),
- (__uint128_t(0x000000000000000000057c9647e1a018)), ERANGE, ERANGE,
- ERANGE);
- runTest("1.89e-4951", 10, uint64_t(0), (__uint128_t(0x00000000000000000001)),
- (__uint128_t(0x0000000000000000000109778a006738)), ERANGE, ERANGE,
- ERANGE);
- runTest("4e-4966", 7, uint64_t(0), (__uint128_t(0)),
- (__uint128_t(0x00000000000000000000000000000001)), ERANGE, ERANGE,
- ERANGE);
+ run_test("1e-4950", 7, uint64_t(0), (__uint128_t(0x00000000000000000003)),
+ (__uint128_t(0x000000000000000000057c9647e1a018)), ERANGE, ERANGE,
+ ERANGE);
+ run_test("1.89e-4951", 10, uint64_t(0), (__uint128_t(0x00000000000000000001)),
+ (__uint128_t(0x0000000000000000000109778a006738)), ERANGE, ERANGE,
+ ERANGE);
+ run_test("4e-4966", 7, uint64_t(0), (__uint128_t(0)),
+ (__uint128_t(0x00000000000000000000000000000001)), ERANGE, ERANGE,
+ ERANGE);
}
TEST_F(LlvmLibcStrToLDTest, SmallNormalTests) {
- runTest("3.37e-4932", 10, uint64_t(0),
- (__uint128_t(0x1804cf7) << 40) + __uint128_t(0x908850712),
- (__uint128_t(0x10099ee12110a) << 64) + __uint128_t(0xe24b75c0f50dc0c),
- ERANGE, 0, 0);
+ run_test("3.37e-4932", 10, uint64_t(0),
+ (__uint128_t(0x1804cf7) << 40) + __uint128_t(0x908850712),
+ (__uint128_t(0x10099ee12110a) << 64) +
+ __uint128_t(0xe24b75c0f50dc0c),
+ ERANGE, 0, 0);
}
TEST_F(LlvmLibcStrToLDTest, ComplexHexadecimalTests) {
- runTest("0x1p16383", 9, 0x7ff0000000000000, (__uint128_t(0x7ffe800000) << 40),
- (__uint128_t(0x7ffe000000000000) << 64));
- runTest("0x123456789abcdef", 17, 0x43723456789abcdf,
- (__uint128_t(0x403791a2b3) << 40) + __uint128_t(0xc4d5e6f780),
- (__uint128_t(0x403723456789abcd) << 64) +
- __uint128_t(0xef00000000000000));
- runTest("0x123456789abcdef0123456789ABCDEF", 33, 0x7ff0000000000000,
- (__uint128_t(0x407791a2b3) << 40) + __uint128_t(0xc4d5e6f781),
- (__uint128_t(0x407723456789abcd) << 64) +
- __uint128_t(0xef0123456789abce));
+ run_test("0x1p16383", 9, 0x7ff0000000000000,
+ (__uint128_t(0x7ffe800000) << 40),
+ (__uint128_t(0x7ffe000000000000) << 64));
+ run_test("0x123456789abcdef", 17, 0x43723456789abcdf,
+ (__uint128_t(0x403791a2b3) << 40) + __uint128_t(0xc4d5e6f780),
+ (__uint128_t(0x403723456789abcd) << 64) +
+ __uint128_t(0xef00000000000000));
+ run_test("0x123456789abcdef0123456789ABCDEF", 33, 0x7ff0000000000000,
+ (__uint128_t(0x407791a2b3) << 40) + __uint128_t(0xc4d5e6f781),
+ (__uint128_t(0x407723456789abcd) << 64) +
+ __uint128_t(0xef0123456789abce));
}
TEST_F(LlvmLibcStrToLDTest, InfTests) {
- runTest("INF", 3, 0x7ff0000000000000, (__uint128_t(0x7fff800000) << 40),
- (__uint128_t(0x7fff000000000000) << 64));
- runTest("INFinity", 8, 0x7ff0000000000000, (__uint128_t(0x7fff800000) << 40),
- (__uint128_t(0x7fff000000000000) << 64));
- runTest("-inf", 4, 0xfff0000000000000, (__uint128_t(0xffff800000) << 40),
- (__uint128_t(0xffff000000000000) << 64));
+ run_test("INF", 3, 0x7ff0000000000000, (__uint128_t(0x7fff800000) << 40),
+ (__uint128_t(0x7fff000000000000) << 64));
+ run_test("INFinity", 8, 0x7ff0000000000000, (__uint128_t(0x7fff800000) << 40),
+ (__uint128_t(0x7fff000000000000) << 64));
+ run_test("-inf", 4, 0xfff0000000000000, (__uint128_t(0xffff800000) << 40),
+ (__uint128_t(0xffff000000000000) << 64));
}
TEST_F(LlvmLibcStrToLDTest, NaNTests) {
- runTest("NaN", 3, 0x7ff8000000000000, (__uint128_t(0x7fffc00000) << 40),
- (__uint128_t(0x7fff800000000000) << 64));
- runTest("-nAn", 4, 0xfff8000000000000, (__uint128_t(0xffffc00000) << 40),
- (__uint128_t(0xffff800000000000) << 64));
- runTest("NaN()", 5, 0x7ff8000000000000, (__uint128_t(0x7fffc00000) << 40),
- (__uint128_t(0x7fff800000000000) << 64));
- runTest("NaN(1234)", 9, 0x7ff80000000004d2,
- (__uint128_t(0x7fffc00000) << 40) + __uint128_t(0x4d2),
- (__uint128_t(0x7fff800000000000) << 64) + __uint128_t(0x4d2));
- runTest("NaN(0xffffffffffff)", 19, 0x7ff8ffffffffffff,
- (__uint128_t(0x7fffc000ff) << 40) + __uint128_t(0xffffffffff),
- (__uint128_t(0x7fff800000000000) << 64) +
- __uint128_t(0xffffffffffff));
- runTest("NaN(0xfffffffffffff)", 20, 0x7fffffffffffffff,
- (__uint128_t(0x7fffc00fff) << 40) + __uint128_t(0xffffffffff),
- (__uint128_t(0x7fff800000000000) << 64) +
- __uint128_t(0xfffffffffffff));
- runTest("NaN(0xffffffffffffffff)", 23, 0x7fffffffffffffff,
- (__uint128_t(0x7fffffffff) << 40) + __uint128_t(0xffffffffff),
- (__uint128_t(0x7fff800000000000) << 64) +
- __uint128_t(0xffffffffffffffff));
- runTest("NaN( 1234)", 3, 0x7ff8000000000000,
- (__uint128_t(0x7fffc00000) << 40),
- (__uint128_t(0x7fff800000000000) << 64));
+ run_test("NaN", 3, 0x7ff8000000000000, (__uint128_t(0x7fffc00000) << 40),
+ (__uint128_t(0x7fff800000000000) << 64));
+ run_test("-nAn", 4, 0xfff8000000000000, (__uint128_t(0xffffc00000) << 40),
+ (__uint128_t(0xffff800000000000) << 64));
+ run_test("NaN()", 5, 0x7ff8000000000000, (__uint128_t(0x7fffc00000) << 40),
+ (__uint128_t(0x7fff800000000000) << 64));
+ run_test("NaN(1234)", 9, 0x7ff80000000004d2,
+ (__uint128_t(0x7fffc00000) << 40) + __uint128_t(0x4d2),
+ (__uint128_t(0x7fff800000000000) << 64) + __uint128_t(0x4d2));
+ run_test("NaN(0xffffffffffff)", 19, 0x7ff8ffffffffffff,
+ (__uint128_t(0x7fffc000ff) << 40) + __uint128_t(0xffffffffff),
+ (__uint128_t(0x7fff800000000000) << 64) +
+ __uint128_t(0xffffffffffff));
+ run_test("NaN(0xfffffffffffff)", 20, 0x7fffffffffffffff,
+ (__uint128_t(0x7fffc00fff) << 40) + __uint128_t(0xffffffffff),
+ (__uint128_t(0x7fff800000000000) << 64) +
+ __uint128_t(0xfffffffffffff));
+ run_test("NaN(0xffffffffffffffff)", 23, 0x7fffffffffffffff,
+ (__uint128_t(0x7fffffffff) << 40) + __uint128_t(0xffffffffff),
+ (__uint128_t(0x7fff800000000000) << 64) +
+ __uint128_t(0xffffffffffffffff));
+ run_test("NaN( 1234)", 3, 0x7ff8000000000000,
+ (__uint128_t(0x7fffc00000) << 40),
+ (__uint128_t(0x7fff800000000000) << 64));
}
diff --git a/libc/test/src/string/bcmp_test.cpp b/libc/test/src/string/bcmp_test.cpp
index dfcad7aff259a..19df7ad2637a2 100644
--- a/libc/test/src/string/bcmp_test.cpp
+++ b/libc/test/src/string/bcmp_test.cpp
@@ -34,25 +34,25 @@ TEST(LlvmLibcBcmpTest, LhsAfterRhsLexically) {
}
TEST(LlvmLibcBcmpTest, Sweep) {
- static constexpr size_t kMaxSize = 1024;
- char lhs[kMaxSize];
- char rhs[kMaxSize];
+ static constexpr size_t K_MAX_SIZE = 1024;
+ char lhs[K_MAX_SIZE];
+ char rhs[K_MAX_SIZE];
const auto reset = [](char *const ptr) {
- for (size_t i = 0; i < kMaxSize; ++i)
+ for (size_t i = 0; i < K_MAX_SIZE; ++i)
ptr[i] = 'a';
};
reset(lhs);
reset(rhs);
- for (size_t i = 0; i < kMaxSize; ++i)
+ for (size_t i = 0; i < K_MAX_SIZE; ++i)
EXPECT_EQ(__llvm_libc::bcmp(lhs, rhs, i), 0);
reset(lhs);
reset(rhs);
- for (size_t i = 0; i < kMaxSize; ++i) {
+ for (size_t i = 0; i < K_MAX_SIZE; ++i) {
rhs[i] = 'b';
- EXPECT_NE(__llvm_libc::bcmp(lhs, rhs, kMaxSize), 0);
+ EXPECT_NE(__llvm_libc::bcmp(lhs, rhs, K_MAX_SIZE), 0);
rhs[i] = 'a';
}
}
diff --git a/libc/test/src/string/bzero_test.cpp b/libc/test/src/string/bzero_test.cpp
index a997cbc43f46f..f8edfa542d77f 100644
--- a/libc/test/src/string/bzero_test.cpp
+++ b/libc/test/src/string/bzero_test.cpp
@@ -14,10 +14,10 @@ using __llvm_libc::cpp::Array;
using __llvm_libc::cpp::ArrayRef;
using Data = Array<char, 2048>;
-static const ArrayRef<char> kDeadcode("DEADC0DE", 8);
+static const ArrayRef<char> k_deadcode("DEADC0DE", 8);
// Returns a Data object filled with a repetition of `filler`.
-Data getData(ArrayRef<char> filler) {
+Data get_data(ArrayRef<char> filler) {
Data out;
for (size_t i = 0; i < out.size(); ++i)
out[i] = filler[i % filler.size()];
@@ -25,7 +25,7 @@ Data getData(ArrayRef<char> filler) {
}
TEST(LlvmLibcBzeroTest, Thorough) {
- const Data dirty = getData(kDeadcode);
+ const Data dirty = get_data(k_deadcode);
for (size_t count = 0; count < 1024; ++count) {
for (size_t align = 0; align < 64; ++align) {
auto buffer = dirty;
diff --git a/libc/test/src/string/memcmp_test.cpp b/libc/test/src/string/memcmp_test.cpp
index 35ee741514aa5..0cd33ebdaf85a 100644
--- a/libc/test/src/string/memcmp_test.cpp
+++ b/libc/test/src/string/memcmp_test.cpp
@@ -34,25 +34,25 @@ TEST(LlvmLibcMemcmpTest, LhsAfterRhsLexically) {
}
TEST(LlvmLibcMemcmpTest, Sweep) {
- static constexpr size_t kMaxSize = 1024;
- char lhs[kMaxSize];
- char rhs[kMaxSize];
+ static constexpr size_t K_MAX_SIZE = 1024;
+ char lhs[K_MAX_SIZE];
+ char rhs[K_MAX_SIZE];
const auto reset = [](char *const ptr) {
- for (size_t i = 0; i < kMaxSize; ++i)
+ for (size_t i = 0; i < K_MAX_SIZE; ++i)
ptr[i] = 'a';
};
reset(lhs);
reset(rhs);
- for (size_t i = 0; i < kMaxSize; ++i)
+ for (size_t i = 0; i < K_MAX_SIZE; ++i)
EXPECT_EQ(__llvm_libc::memcmp(lhs, rhs, i), 0);
reset(lhs);
reset(rhs);
- for (size_t i = 0; i < kMaxSize; ++i) {
+ for (size_t i = 0; i < K_MAX_SIZE; ++i) {
rhs[i] = 'z';
- EXPECT_LT(__llvm_libc::memcmp(lhs, rhs, kMaxSize), 0);
+ EXPECT_LT(__llvm_libc::memcmp(lhs, rhs, K_MAX_SIZE), 0);
rhs[i] = 'a';
}
}
diff --git a/libc/test/src/string/memcpy_test.cpp b/libc/test/src/string/memcpy_test.cpp
index 9a7c9ba7f7a04..ed4bbd45c4104 100644
--- a/libc/test/src/string/memcpy_test.cpp
+++ b/libc/test/src/string/memcpy_test.cpp
@@ -14,11 +14,11 @@ using __llvm_libc::cpp::Array;
using __llvm_libc::cpp::ArrayRef;
using Data = Array<char, 2048>;
-static const ArrayRef<char> kNumbers("0123456789", 10);
-static const ArrayRef<char> kDeadcode("DEADC0DE", 8);
+static const ArrayRef<char> k_numbers("0123456789", 10);
+static const ArrayRef<char> k_deadcode("DEADC0DE", 8);
// Returns a Data object filled with a repetition of `filler`.
-Data getData(ArrayRef<char> filler) {
+Data get_data(ArrayRef<char> filler) {
Data out;
for (size_t i = 0; i < out.size(); ++i)
out[i] = filler[i % filler.size()];
@@ -26,8 +26,8 @@ Data getData(ArrayRef<char> filler) {
}
TEST(LlvmLibcMemcpyTest, Thorough) {
- const Data groundtruth = getData(kNumbers);
- const Data dirty = getData(kDeadcode);
+ const Data groundtruth = get_data(k_numbers);
+ const Data dirty = get_data(k_deadcode);
for (size_t count = 0; count < 1024; ++count) {
for (size_t align = 0; align < 64; ++align) {
auto buffer = dirty;
diff --git a/libc/test/src/string/memset_test.cpp b/libc/test/src/string/memset_test.cpp
index c3f65cf6fd6c9..2d07e7bb0c73c 100644
--- a/libc/test/src/string/memset_test.cpp
+++ b/libc/test/src/string/memset_test.cpp
@@ -14,10 +14,10 @@ using __llvm_libc::cpp::Array;
using __llvm_libc::cpp::ArrayRef;
using Data = Array<char, 2048>;
-static const ArrayRef<char> kDeadcode("DEADC0DE", 8);
+static const ArrayRef<char> k_deadcode("DEADC0DE", 8);
// Returns a Data object filled with a repetition of `filler`.
-Data getData(ArrayRef<char> filler) {
+Data get_data(ArrayRef<char> filler) {
Data out;
for (size_t i = 0; i < out.size(); ++i)
out[i] = filler[i % filler.size()];
@@ -25,7 +25,7 @@ Data getData(ArrayRef<char> filler) {
}
TEST(LlvmLibcMemsetTest, Thorough) {
- const Data dirty = getData(kDeadcode);
+ const Data dirty = get_data(k_deadcode);
for (int value = -1; value <= 1; ++value) {
for (size_t count = 0; count < 1024; ++count) {
for (size_t align = 0; align < 64; ++align) {
diff --git a/libc/test/src/string/stpcpy_test.cpp b/libc/test/src/string/stpcpy_test.cpp
index 90ec5311b9b91..e5ed3fb06f785 100644
--- a/libc/test/src/string/stpcpy_test.cpp
+++ b/libc/test/src/string/stpcpy_test.cpp
@@ -13,33 +13,33 @@
TEST(LlvmLibcStpCpyTest, EmptySrc) {
const char *empty = "";
- size_t srcSize = __llvm_libc::internal::string_length(empty);
+ size_t src_size = __llvm_libc::internal::string_length(empty);
char dest[4] = {'a', 'b', 'c', '\0'};
char *result = __llvm_libc::stpcpy(dest, empty);
- ASSERT_EQ(dest + srcSize, result);
+ ASSERT_EQ(dest + src_size, result);
ASSERT_EQ(result[0], '\0');
ASSERT_STREQ(dest, empty);
}
TEST(LlvmLibcStpCpyTest, EmptyDest) {
const char *abc = "abc";
- size_t srcSize = __llvm_libc::internal::string_length(abc);
+ size_t src_size = __llvm_libc::internal::string_length(abc);
char dest[4];
char *result = __llvm_libc::stpcpy(dest, abc);
- ASSERT_EQ(dest + srcSize, result);
+ ASSERT_EQ(dest + src_size, result);
ASSERT_EQ(result[0], '\0');
ASSERT_STREQ(dest, abc);
}
TEST(LlvmLibcStpCpyTest, OffsetDest) {
const char *abc = "abc";
- size_t srcSize = __llvm_libc::internal::string_length(abc);
+ size_t src_size = __llvm_libc::internal::string_length(abc);
char dest[7] = {'x', 'y', 'z'};
char *result = __llvm_libc::stpcpy(dest + 3, abc);
- ASSERT_EQ(dest + 3 + srcSize, result);
+ ASSERT_EQ(dest + 3 + src_size, result);
ASSERT_EQ(result[0], '\0');
ASSERT_STREQ(dest, "xyzabc");
}
diff --git a/libc/test/src/threads/call_once_test.cpp b/libc/test/src/threads/call_once_test.cpp
index 18ed710157634..b0e9fb8ccc715 100644
--- a/libc/test/src/threads/call_once_test.cpp
+++ b/libc/test/src/threads/call_once_test.cpp
@@ -18,7 +18,7 @@
#include <stdatomic.h>
-static constexpr unsigned int num_threads = 5;
+static constexpr unsigned int NUM_THREADS = 5;
static atomic_uint thread_count;
static unsigned int call_count;
@@ -38,13 +38,13 @@ TEST(LlvmLibcCallOnceTest, CallFrom5Threads) {
call_count = 0;
thread_count = 0;
- thrd_t threads[num_threads];
- for (unsigned int i = 0; i < num_threads; ++i) {
+ thrd_t threads[NUM_THREADS];
+ for (unsigned int i = 0; i < NUM_THREADS; ++i) {
ASSERT_EQ(__llvm_libc::thrd_create(threads + i, func, nullptr),
static_cast<int>(thrd_success));
}
- for (unsigned int i = 0; i < num_threads; ++i) {
+ for (unsigned int i = 0; i < NUM_THREADS; ++i) {
int retval;
ASSERT_EQ(__llvm_libc::thrd_join(threads + i, &retval),
static_cast<int>(thrd_success));
diff --git a/libc/test/src/threads/mtx_test.cpp b/libc/test/src/threads/mtx_test.cpp
index 8ee8cf5bb0dd7..3abe77e0eab72 100644
--- a/libc/test/src/threads/mtx_test.cpp
+++ b/libc/test/src/threads/mtx_test.cpp
@@ -69,11 +69,11 @@ TEST(LlvmLibcMutexTest, RelayCounter) {
}
mtx_t start_lock, step_lock;
-bool start, step;
+bool started, step;
int stepper(void *arg) {
__llvm_libc::mtx_lock(&start_lock);
- start = true;
+ started = true;
__llvm_libc::mtx_unlock(&start_lock);
__llvm_libc::mtx_lock(&step_lock);
@@ -92,7 +92,7 @@ TEST(LlvmLibcMutexTest, WaitAndStep) {
// step. Once we ensure that the thread is blocked, we unblock it.
// After unblocking, we then verify that the thread was indeed unblocked.
step = false;
- start = false;
+ started = false;
ASSERT_EQ(__llvm_libc::mtx_lock(&step_lock), static_cast<int>(thrd_success));
thrd_t thread;
@@ -102,7 +102,7 @@ TEST(LlvmLibcMutexTest, WaitAndStep) {
// Make sure the thread actually started.
ASSERT_EQ(__llvm_libc::mtx_lock(&start_lock),
static_cast<int>(thrd_success));
- bool s = start;
+ bool s = started;
ASSERT_EQ(__llvm_libc::mtx_unlock(&start_lock),
static_cast<int>(thrd_success));
if (s)
diff --git a/libc/test/src/time/TmHelper.h b/libc/test/src/time/TmHelper.h
index 1ab2a5eeeba6e..54d9f4eb72ce3 100644
--- a/libc/test/src/time/TmHelper.h
+++ b/libc/test/src/time/TmHelper.h
@@ -20,9 +20,9 @@ namespace tmhelper {
namespace testing {
// A helper function to initialize tm data structure.
-static inline void InitializeTmData(struct tm *tm_data, int year, int month,
- int mday, int hour, int min, int sec,
- int wday, int yday) {
+static inline void initialize_tm_data(struct tm *tm_data, int year, int month,
+ int mday, int hour, int min, int sec,
+ int wday, int yday) {
struct tm temp = {.tm_sec = sec,
.tm_min = min,
.tm_hour = hour,
diff --git a/libc/test/src/time/asctime_r_test.cpp b/libc/test/src/time/asctime_r_test.cpp
index 1f883cf0cac14..f9ccdda50a32d 100644
--- a/libc/test/src/time/asctime_r_test.cpp
+++ b/libc/test/src/time/asctime_r_test.cpp
@@ -17,8 +17,8 @@ using __llvm_libc::time_utils::TimeConstants;
static inline char *call_asctime_r(struct tm *tm_data, int year, int month,
int mday, int hour, int min, int sec,
int wday, int yday, char *buffer) {
- __llvm_libc::tmhelper::testing::InitializeTmData(tm_data, year, month, mday,
- hour, min, sec, wday, yday);
+ __llvm_libc::tmhelper::testing::initialize_tm_data(
+ tm_data, year, month, mday, hour, min, sec, wday, yday);
return __llvm_libc::asctime_r(tm_data, buffer);
}
diff --git a/libc/test/src/time/asctime_test.cpp b/libc/test/src/time/asctime_test.cpp
index 14201fd5a0de9..0b0c159eb53a6 100644
--- a/libc/test/src/time/asctime_test.cpp
+++ b/libc/test/src/time/asctime_test.cpp
@@ -13,8 +13,8 @@
static inline char *call_asctime(struct tm *tm_data, int year, int month,
int mday, int hour, int min, int sec, int wday,
int yday) {
- __llvm_libc::tmhelper::testing::InitializeTmData(tm_data, year, month, mday,
- hour, min, sec, wday, yday);
+ __llvm_libc::tmhelper::testing::initialize_tm_data(
+ tm_data, year, month, mday, hour, min, sec, wday, yday);
return __llvm_libc::asctime(tm_data);
}
diff --git a/libc/test/src/time/mktime_test.cpp b/libc/test/src/time/mktime_test.cpp
index d08a6b9640dde..16b814f1d4255 100644
--- a/libc/test/src/time/mktime_test.cpp
+++ b/libc/test/src/time/mktime_test.cpp
@@ -24,14 +24,14 @@ using __llvm_libc::time_utils::TimeConstants;
static inline time_t call_mktime(struct tm *tm_data, int year, int month,
int mday, int hour, int min, int sec, int wday,
int yday) {
- __llvm_libc::tmhelper::testing::InitializeTmData(tm_data, year, month, mday,
- hour, min, sec, wday, yday);
+ __llvm_libc::tmhelper::testing::initialize_tm_data(
+ tm_data, year, month, mday, hour, min, sec, wday, yday);
return __llvm_libc::mktime(tm_data);
}
TEST(LlvmLibcMkTime, FailureSetsErrno) {
struct tm tm_data;
- __llvm_libc::tmhelper::testing::InitializeTmData(
+ __llvm_libc::tmhelper::testing::initialize_tm_data(
&tm_data, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, -1, 0, 0);
EXPECT_THAT(__llvm_libc::mktime(&tm_data), Fails(EOVERFLOW));
}
diff --git a/libc/test/src/unistd/write_test.cpp b/libc/test/src/unistd/write_test.cpp
index 2313d97d58887..56243846083af 100644
--- a/libc/test/src/unistd/write_test.cpp
+++ b/libc/test/src/unistd/write_test.cpp
@@ -14,10 +14,10 @@
TEST(LlvmLibcUniStd, WriteBasic) {
using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
- constexpr const char *hello = "hello";
+ constexpr const char *HELLO = "hello";
__llvm_libc::testutils::FDReader reader;
- EXPECT_THAT(__llvm_libc::write(reader.getWriteFD(), hello, 5), Succeeds(5));
- EXPECT_TRUE(reader.matchWritten(hello));
+ EXPECT_THAT(__llvm_libc::write(reader.get_write_fd(), HELLO, 5), Succeeds(5));
+ EXPECT_TRUE(reader.match_written(HELLO));
}
TEST(LlvmLibcUniStd, WriteFails) {
diff --git a/libc/utils/UnitTest/LibcTest.cpp b/libc/utils/UnitTest/LibcTest.cpp
index 710ee15bba3f9..c998337039a60 100644
--- a/libc/utils/UnitTest/LibcTest.cpp
+++ b/libc/utils/UnitTest/LibcTest.cpp
@@ -291,22 +291,22 @@ bool Test::testMatch(bool MatchResult, MatcherBase &Matcher, const char *LHSStr,
bool Test::testProcessKilled(testutils::FunctionCaller *Func, int Signal,
const char *LHSStr, const char *RHSStr,
const char *File, unsigned long Line) {
- testutils::ProcessStatus Result = testutils::invokeInSubprocess(Func, 500);
+ testutils::ProcessStatus Result = testutils::invoke_in_subprocess(Func, 500);
- if (const char *error = Result.getError()) {
+ if (const char *error = Result.get_error()) {
Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n" << error << '\n';
return false;
}
- if (Result.timedOut()) {
+ if (Result.timed_out()) {
Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n"
<< "Process timed out after " << 500 << " milliseconds.\n";
return false;
}
- if (Result.exitedNormally()) {
+ if (Result.exited_normally()) {
Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n"
<< "Expected " << LHSStr
@@ -314,41 +314,41 @@ bool Test::testProcessKilled(testutils::FunctionCaller *Func, int Signal,
return false;
}
- int KilledBy = Result.getFatalSignal();
+ int KilledBy = Result.get_fatal_signal();
assert(KilledBy != 0 && "Not killed by any signal");
if (Signal == -1 || KilledBy == Signal)
return true;
- using testutils::signalAsString;
+ using testutils::signal_as_string;
Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n"
<< " Expected: " << LHSStr << '\n'
<< "To be killed by signal: " << Signal << '\n'
- << " Which is: " << signalAsString(Signal) << '\n'
+ << " Which is: " << signal_as_string(Signal) << '\n'
<< " But it was killed by: " << KilledBy << '\n'
- << " Which is: " << signalAsString(KilledBy) << '\n';
+ << " Which is: " << signal_as_string(KilledBy) << '\n';
return false;
}
bool Test::testProcessExits(testutils::FunctionCaller *Func, int ExitCode,
const char *LHSStr, const char *RHSStr,
const char *File, unsigned long Line) {
- testutils::ProcessStatus Result = testutils::invokeInSubprocess(Func, 500);
+ testutils::ProcessStatus Result = testutils::invoke_in_subprocess(Func, 500);
- if (const char *error = Result.getError()) {
+ if (const char *error = Result.get_error()) {
Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n" << error << '\n';
return false;
}
- if (Result.timedOut()) {
+ if (Result.timed_out()) {
Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n"
<< "Process timed out after " << 500 << " milliseconds.\n";
return false;
}
- if (!Result.exitedNormally()) {
+ if (!Result.exited_normally()) {
Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n"
<< "Expected " << LHSStr << '\n'
@@ -357,7 +357,7 @@ bool Test::testProcessExits(testutils::FunctionCaller *Func, int ExitCode,
return false;
}
- int ActualExit = Result.getExitCode();
+ int ActualExit = Result.get_exit_code();
if (ActualExit == ExitCode)
return true;
diff --git a/libc/utils/testutils/ExecuteFunction.h b/libc/utils/testutils/ExecuteFunction.h
index 32482ebaf3bf4..a22336575d823 100644
--- a/libc/utils/testutils/ExecuteFunction.h
+++ b/libc/utils/testutils/ExecuteFunction.h
@@ -21,28 +21,29 @@ class FunctionCaller {
};
struct ProcessStatus {
- int PlatformDefined;
+ int platform_defined;
const char *failure = nullptr;
- static constexpr uintptr_t timeout = -1L;
+ static constexpr uintptr_t TIMEOUT = -1L;
- static ProcessStatus Error(const char *error) { return {0, error}; }
- static ProcessStatus TimedOut() {
- return {0, reinterpret_cast<const char *>(timeout)};
+ static ProcessStatus error(const char *error) { return {0, error}; }
+ static ProcessStatus timed_out_ps() {
+ return {0, reinterpret_cast<const char *>(TIMEOUT)};
}
- bool timedOut() const {
- return failure == reinterpret_cast<const char *>(timeout);
+ bool timed_out() const {
+ return failure == reinterpret_cast<const char *>(TIMEOUT);
}
- const char *getError() const { return timedOut() ? nullptr : failure; }
- bool exitedNormally() const;
- int getExitCode() const;
- int getFatalSignal() const;
+ const char *get_error() const { return timed_out() ? nullptr : failure; }
+ bool exited_normally() const;
+ int get_exit_code() const;
+ int get_fatal_signal() const;
};
-ProcessStatus invokeInSubprocess(FunctionCaller *Func, unsigned TimeoutMS = -1);
+ProcessStatus invoke_in_subprocess(FunctionCaller *Func,
+ unsigned TimeoutMS = -1);
-const char *signalAsString(int Signum);
+const char *signal_as_string(int Signum);
} // namespace testutils
} // namespace __llvm_libc
diff --git a/libc/utils/testutils/ExecuteFunctionUnix.cpp b/libc/utils/testutils/ExecuteFunctionUnix.cpp
index 4050a0ca8a6ec..a3871d07386d6 100644
--- a/libc/utils/testutils/ExecuteFunctionUnix.cpp
+++ b/libc/utils/testutils/ExecuteFunctionUnix.cpp
@@ -20,33 +20,33 @@
namespace __llvm_libc {
namespace testutils {
-bool ProcessStatus::exitedNormally() const {
- return WIFEXITED(PlatformDefined);
+bool ProcessStatus::exited_normally() const {
+ return WIFEXITED(platform_defined);
}
-int ProcessStatus::getExitCode() const {
- assert(exitedNormally() && "Abnormal termination, no exit code");
- return WEXITSTATUS(PlatformDefined);
+int ProcessStatus::get_exit_code() const {
+ assert(exited_normally() && "Abnormal termination, no exit code");
+ return WEXITSTATUS(platform_defined);
}
-int ProcessStatus::getFatalSignal() const {
- if (exitedNormally())
+int ProcessStatus::get_fatal_signal() const {
+ if (exited_normally())
return 0;
- return WTERMSIG(PlatformDefined);
+ return WTERMSIG(platform_defined);
}
-ProcessStatus invokeInSubprocess(FunctionCaller *Func, unsigned timeoutMS) {
+ProcessStatus invoke_in_subprocess(FunctionCaller *Func, unsigned timeoutMS) {
std::unique_ptr<FunctionCaller> X(Func);
int pipeFDs[2];
if (::pipe(pipeFDs) == -1)
- return ProcessStatus::Error("pipe(2) failed");
+ return ProcessStatus::error("pipe(2) failed");
// Don't copy the buffers into the child process and print twice.
std::cout.flush();
std::cerr.flush();
pid_t Pid = ::fork();
if (Pid == -1)
- return ProcessStatus::Error("fork(2) failed");
+ return ProcessStatus::error("fork(2) failed");
if (!Pid) {
(*Func)();
@@ -60,11 +60,11 @@ ProcessStatus invokeInSubprocess(FunctionCaller *Func, unsigned timeoutMS) {
// No events requested so this call will only return after the timeout or if
// the pipes peer was closed, signaling the process exited.
if (::poll(&pollFD, 1, timeoutMS) == -1)
- return ProcessStatus::Error("poll(2) failed");
+ return ProcessStatus::error("poll(2) failed");
// If the pipe wasn't closed by the child yet then timeout has expired.
if (!(pollFD.revents & POLLHUP)) {
::kill(Pid, SIGKILL);
- return ProcessStatus::TimedOut();
+ return ProcessStatus::timed_out_ps();
}
int WStatus = 0;
@@ -72,13 +72,13 @@ ProcessStatus invokeInSubprocess(FunctionCaller *Func, unsigned timeoutMS) {
// and doesn't turn into a zombie.
pid_t status = ::waitpid(Pid, &WStatus, 0);
if (status == -1)
- return ProcessStatus::Error("waitpid(2) failed");
+ return ProcessStatus::error("waitpid(2) failed");
assert(status == Pid);
(void)status;
return {WStatus};
}
-const char *signalAsString(int Signum) { return ::strsignal(Signum); }
+const char *signal_as_string(int Signum) { return ::strsignal(Signum); }
} // namespace testutils
} // namespace __llvm_libc
diff --git a/libc/utils/testutils/FDReader.h b/libc/utils/testutils/FDReader.h
index e25dcea290a64..8a39a92dcc33c 100644
--- a/libc/utils/testutils/FDReader.h
+++ b/libc/utils/testutils/FDReader.h
@@ -19,8 +19,8 @@ class FDReader {
FDReader();
~FDReader();
- int getWriteFD() { return pipefd[1]; }
- bool matchWritten(const char *);
+ int get_write_fd() { return pipefd[1]; }
+ bool match_written(const char *);
};
} // namespace testutils
diff --git a/libc/utils/testutils/FDReaderUnix.cpp b/libc/utils/testutils/FDReaderUnix.cpp
index db1f63f0dcc38..be6cde331f370 100644
--- a/libc/utils/testutils/FDReaderUnix.cpp
+++ b/libc/utils/testutils/FDReaderUnix.cpp
@@ -27,7 +27,7 @@ FDReader::~FDReader() {
::close(pipefd[1]);
}
-bool FDReader::matchWritten(const char *str) {
+bool FDReader::match_written(const char *str) {
::close(pipefd[1]);
diff --git a/libc/utils/testutils/StreamWrapper.cpp b/libc/utils/testutils/StreamWrapper.cpp
index 84ab583f66445..f65c9c3055cef 100644
--- a/libc/utils/testutils/StreamWrapper.cpp
+++ b/libc/utils/testutils/StreamWrapper.cpp
@@ -19,8 +19,8 @@ namespace testutils {
StreamWrapper outs() { return {std::addressof(std::cout)}; }
template <typename T> StreamWrapper &StreamWrapper::operator<<(T t) {
- assert(OS);
- std::ostream &Stream = *reinterpret_cast<std::ostream *>(OS);
+ assert(os);
+ std::ostream &Stream = *reinterpret_cast<std::ostream *>(os);
Stream << t;
Stream.flush();
return *this;
@@ -52,7 +52,7 @@ OutputFileStream::OutputFileStream(const char *FN)
: StreamWrapper(new std::ofstream(FN)) {}
OutputFileStream::~OutputFileStream() {
- delete reinterpret_cast<std::ofstream *>(OS);
+ delete reinterpret_cast<std::ofstream *>(os);
}
} // namespace testutils
diff --git a/libc/utils/testutils/StreamWrapper.h b/libc/utils/testutils/StreamWrapper.h
index 2434ab06bb71f..f4309abdedef6 100644
--- a/libc/utils/testutils/StreamWrapper.h
+++ b/libc/utils/testutils/StreamWrapper.h
@@ -17,10 +17,10 @@ namespace testutils {
// expose the system libc headers.
class StreamWrapper {
protected:
- void *OS;
+ void *os;
public:
- StreamWrapper(void *OS) : OS(OS) {}
+ StreamWrapper(void *OS) : os(OS) {}
template <typename T> StreamWrapper &operator<<(T t);
};
More information about the libc-commits
mailing list