This is an archive of the discontinued LLVM Phabricator instance.

Differential D116127

[libc] apply formatting to tests
ClosedPublic

Authored by michaelrj on Dec 21 2021, 1:15 PM.

Details

Reviewers
sivachandra
lntue
Commits
rG25226f3e4a42: [libc] apply formatting to tests
Summary

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.

Diff Detail

Event Timeline

michaelrj created this revision.Dec 21 2021, 1:15 PM
Herald added a project: Restricted Project. · View Herald TranscriptDec 21 2021, 1:15 PM
Herald added subscribers: libc-commits, ecnelises, tschuett. · View Herald Transcript
michaelrj requested review of this revision.Dec 21 2021, 1:15 PM
Harbormaster completed remote builds in B140301: Diff 395744.Dec 21 2021, 1:24 PM
sivachandra accepted this revision.Dec 21 2021, 9:39 PM
sivachandra mentioned this in D116126: [libc] add test formatting rules.

Feel free to update the description and land this change as a standalone cleanup.

This revision is now accepted and ready to land.Dec 21 2021, 9:40 PM
lntue accepted this revision.Dec 22 2021, 5:39 AM
michaelrj updated this revision to Diff 395902.Dec 22 2021, 10:39 AM

update description to reflect that this patch is landing solo

michaelrj edited the summary of this revision. (Show Details)Dec 22 2021, 10:40 AM
Harbormaster completed remote builds in B140421: Diff 395902.Dec 22 2021, 10:44 AM
Closed by commit rG25226f3e4a42: [libc] apply formatting to tests (authored by michaelrj). · Explain WhyDec 22 2021, 10:53 AM
This revision was automatically updated to reflect the committed changes.
michaelrj added a commit: rG25226f3e4a42: [libc] apply formatting to tests.

Revision Contents

PathSize
libc/
benchmarks/
4 lines
automemcpy/
lib/
2 lines
test/
config/
linux/
x86_64/
2 lines
src/
__support/
220 lines
fenv/
4 lines
8 lines
math/
6 lines
6 lines
6 lines
18 lines
8 lines
8 lines
6 lines
26 lines
8 lines
22 lines
26 lines
60 lines
8 lines
6 lines
116 lines
66 lines
14 lines
6 lines
156 lines
16 lines
6 lines
6 lines
10 lines
6 lines
6 lines
6 lines
12 lines
12 lines
12 lines
6 lines
6 lines
8 lines
6 lines
10 lines
10 lines
10 lines
6 lines
2 lines
6 lines
10 lines
10 lines
6 lines
signal/
4 lines
stdlib/
24 lines
28 lines
74 lines
59 lines
162 lines
218 lines
string/
14 lines
6 lines
14 lines
10 lines
6 lines
12 lines
threads/
8 lines
8 lines
time/
6 lines
4 lines
4 lines
6 lines
unistd/
6 lines
utils/
UnitTest/
26 lines
testutils/
27 lines
30 lines
4 lines
2 lines
4 lines
6 lines

Diff 395903

libc/benchmarks/LibcBenchmarkTest.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines if (!MaybeTimepoints)
return {}; return {};
assert(!MaybeTimepoints->empty()); assert(!MaybeTimepoints->empty());
const Duration timepoint = MaybeTimepoints->front(); const Duration timepoint = MaybeTimepoints->front();
MaybeTimepoints->pop(); MaybeTimepoints->pop();
return timepoint; return timepoint;
} }
protected: 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. // We make sure all the expected measurements were performed.
if (MaybeTimepoints) if (MaybeTimepoints)
EXPECT_THAT(*MaybeTimepoints, IsEmpty()); EXPECT_THAT(*MaybeTimepoints, IsEmpty());
} }
BenchmarkResult run() { BenchmarkResult run() {
return benchmark(Options, ParameterProvider, DummyFunction, *this); return benchmark(Options, ParameterProvider, DummyFunction, *this);
} }
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

libc/benchmarks/automemcpy/lib/ResultAnalyzerMain.cpp

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
JsonFile parseJsonResultFile(StringRef Filename) { JsonFile parseJsonResultFile(StringRef Filename) {
auto Buf = ExitOnErr(errorOrToExpected( auto Buf = ExitOnErr(errorOrToExpected(
MemoryBuffer::getFile(Filename, /*bool IsText=*/true, MemoryBuffer::getFile(Filename, /*bool IsText=*/true,
/*RequiresNullTerminator=*/false))); /*RequiresNullTerminator=*/false)));
auto JsonValue = ExitOnErr(json::parse(Buf->getBuffer())); auto JsonValue = ExitOnErr(json::parse(Buf->getBuffer()));
json::Path::Root Root; json::Path::Root Root;
JsonFile JF; JsonFile JF;
if (!fromJSON(JsonValue, JF, Root)) if (!fromJSON(JsonValue, JF, Root))
ExitOnErr(Root.getError()); ExitOnErr(Root.get_error());
return JF; return JF;
} }
// Serializes the 'GradeHisto' to the provided 'Stream'. // Serializes the 'GradeHisto' to the provided 'Stream'.
static void Serialize(raw_ostream &Stream, const GradeHistogram &GH) { static void Serialize(raw_ostream &Stream, const GradeHistogram &GH) {
static constexpr std::array<StringRef, 9> kCharacters = { static constexpr std::array<StringRef, 9> kCharacters = {
" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"}; " ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"};
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libc/test/config/linux/x86_64/syscall_test.cpp

Show All 33 Lines Function<long(long, long, long, long, long, long)> f5(
[](long n, long a1, long a2, long a3, long a4, long a5) { [](long n, long a1, long a2, long a3, long a4, long a5) {
return __llvm_libc::syscall(n, a1, a2, a3, a4, a5); return __llvm_libc::syscall(n, a1, a2, a3, a4, a5);
}); });
Function<long(long, long, long, long, long, long, long)> f6( Function<long(long, long, long, long, long, long, long)> f6(
[](long n, long a1, long a2, long a3, long a4, long a5, long a6) { [](long n, long a1, long a2, long a3, long a4, long a5, long a6) {
return __llvm_libc::syscall(n, a1, a2, a3, a4, a5, a6); 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); }); [](long n, void *a1) { return __llvm_libc::syscall(n, a1); });
} }

libc/test/src/__support/str_to_float_test.cpp

//===-- Unittests for str_to_float ----------------------------------------===// //===-- Unittests for str_to_float ----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/__support/str_to_float.h" #include "src/__support/str_to_float.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
class LlvmLibcStrToFloatTest : public __llvm_libc::testing::Test { class LlvmLibcStrToFloatTest : public __llvm_libc::testing::Test {
public: public:
template <class T> template <class T>
void ClingerFastPathTest( void clinger_fast_path_test(
const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa, const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa,
const int32_t inputExp10, const int32_t inputExp10,
const typename __llvm_libc::fputil::FPBits<T>::UIntType const typename __llvm_libc::fputil::FPBits<T>::UIntType
expectedOutputMantissa, expectedOutputMantissa,
const uint32_t expectedOutputExp2) { const uint32_t expectedOutputExp2) {
typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0; typename __llvm_libc::fputil::FPBits<T>::UIntType actual_output_mantissa =
uint32_t actualOutputExp2 = 0; 0;
uint32_t actual_output_exp2 = 0;
ASSERT_TRUE(__llvm_libc::internal::clinger_fast_path<T>( ASSERT_TRUE(__llvm_libc::internal::clinger_fast_path<T>(
inputMantissa, inputExp10, &actualOutputMantissa, &actualOutputExp2)); inputMantissa, inputExp10, &actual_output_mantissa,
EXPECT_EQ(actualOutputMantissa, expectedOutputMantissa); &actual_output_exp2));
EXPECT_EQ(actualOutputExp2, expectedOutputExp2); EXPECT_EQ(actual_output_mantissa, expectedOutputMantissa);
EXPECT_EQ(actual_output_exp2, expectedOutputExp2);
} }
template <class T> template <class T>
void ClingerFastPathFailsTest( void clinger_fast_path_fails_test(
const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa, const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa,
const int32_t inputExp10) { const int32_t inputExp10) {
typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0; typename __llvm_libc::fputil::FPBits<T>::UIntType actual_output_mantissa =
uint32_t actualOutputExp2 = 0; 0;
uint32_t actual_output_exp2 = 0;
ASSERT_FALSE(__llvm_libc::internal::clinger_fast_path<T>( ASSERT_FALSE(__llvm_libc::internal::clinger_fast_path<T>(
inputMantissa, inputExp10, &actualOutputMantissa, &actualOutputExp2)); inputMantissa, inputExp10, &actual_output_mantissa,
&actual_output_exp2));
} }
template <class T> template <class T>
void EiselLemireTest( void eisel_lemire_test(
const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa, const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa,
const int32_t inputExp10, const int32_t inputExp10,
const typename __llvm_libc::fputil::FPBits<T>::UIntType const typename __llvm_libc::fputil::FPBits<T>::UIntType
expectedOutputMantissa, expectedOutputMantissa,
const uint32_t expectedOutputExp2) { const uint32_t expectedOutputExp2) {
typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0; typename __llvm_libc::fputil::FPBits<T>::UIntType actual_output_mantissa =
uint32_t actualOutputExp2 = 0; 0;
uint32_t actual_output_exp2 = 0;
ASSERT_TRUE(__llvm_libc::internal::eisel_lemire<T>( ASSERT_TRUE(__llvm_libc::internal::eisel_lemire<T>(
inputMantissa, inputExp10, &actualOutputMantissa, &actualOutputExp2)); inputMantissa, inputExp10, &actual_output_mantissa,
EXPECT_EQ(actualOutputMantissa, expectedOutputMantissa); &actual_output_exp2));
EXPECT_EQ(actualOutputExp2, expectedOutputExp2); EXPECT_EQ(actual_output_mantissa, expectedOutputMantissa);
EXPECT_EQ(actual_output_exp2, expectedOutputExp2);
} }
template <class T> template <class T>
void SimpleDecimalConversionTest( void simple_decimal_conversion_test(
const char *__restrict numStart, const char *__restrict numStart,
const typename __llvm_libc::fputil::FPBits<T>::UIntType const typename __llvm_libc::fputil::FPBits<T>::UIntType
expectedOutputMantissa, expectedOutputMantissa,
const uint32_t expectedOutputExp2, const int expectedErrno = 0) { const uint32_t expectedOutputExp2, const int expectedErrno = 0) {
typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0; typename __llvm_libc::fputil::FPBits<T>::UIntType actual_output_mantissa =
uint32_t actualOutputExp2 = 0; 0;
uint32_t actual_output_exp2 = 0;
errno = 0; errno = 0;
__llvm_libc::internal::simple_decimal_conversion<T>( __llvm_libc::internal::simple_decimal_conversion<T>(
numStart, &actualOutputMantissa, &actualOutputExp2); numStart, &actual_output_mantissa, &actual_output_exp2);
EXPECT_EQ(actualOutputMantissa, expectedOutputMantissa); EXPECT_EQ(actual_output_mantissa, expectedOutputMantissa);
EXPECT_EQ(actualOutputExp2, expectedOutputExp2); EXPECT_EQ(actual_output_exp2, expectedOutputExp2);
EXPECT_EQ(errno, expectedErrno); EXPECT_EQ(errno, expectedErrno);
} }
}; };
TEST(LlvmLibcStrToFloatTest, LeadingZeroes) { TEST(LlvmLibcStrToFloatTest, LeadingZeroes) {
uint64_t testNum64 = 1; uint64_t test_num64 = 1;
uint32_t numOfZeroes = 63; uint32_t num_of_zeroes = 63;
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(0), 64u); EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(0), 64u);
for (; numOfZeroes < 64; testNum64 <<= 1, numOfZeroes--) { for (; num_of_zeroes < 64; test_num64 <<= 1, num_of_zeroes--) {
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(testNum64), EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(test_num64),
numOfZeroes); num_of_zeroes);
} }
testNum64 = 3; test_num64 = 3;
numOfZeroes = 62; num_of_zeroes = 62;
for (; numOfZeroes > 63; testNum64 <<= 1, numOfZeroes--) { for (; num_of_zeroes > 63; test_num64 <<= 1, num_of_zeroes--) {
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(testNum64), EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(test_num64),
numOfZeroes); num_of_zeroes);
} }
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(0xffffffffffffffff), EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(0xffffffffffffffff),
0u); 0u);
testNum64 = 1; test_num64 = 1;
numOfZeroes = 63; num_of_zeroes = 63;
for (; numOfZeroes > 63; testNum64 = (testNum64 << 1) + 1, numOfZeroes--) { for (; num_of_zeroes > 63;
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(testNum64), test_num64 = (test_num64 << 1) + 1, num_of_zeroes--) {
numOfZeroes); EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(test_num64),
num_of_zeroes);
} }
uint64_t testNum32 = 1; uint64_t test_num32 = 1;
numOfZeroes = 31; num_of_zeroes = 31;
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(0), 32u); EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(0), 32u);
for (; numOfZeroes < 32; testNum32 <<= 1, numOfZeroes--) { for (; num_of_zeroes < 32; test_num32 <<= 1, num_of_zeroes--) {
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(testNum32), EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(test_num32),
numOfZeroes); num_of_zeroes);
} }
EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(0xffffffff), 0u); EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(0xffffffff), 0u);
} }
TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64Simple) { TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64Simple) {
ClingerFastPathTest<double>(123, 0, 0xEC00000000000, 1029); clinger_fast_path_test<double>(123, 0, 0xEC00000000000, 1029);
ClingerFastPathTest<double>(1234567890123456, 1, 0x5ee2a2eb5a5c0, 1076); clinger_fast_path_test<double>(1234567890123456, 1, 0x5ee2a2eb5a5c0, 1076);
ClingerFastPathTest<double>(1234567890, -10, 0xf9add3739635f, 1019); clinger_fast_path_test<double>(1234567890, -10, 0xf9add3739635f, 1019);
} }
TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64ExtendedExp) { TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64ExtendedExp) {
ClingerFastPathTest<double>(1, 30, 0x93e5939a08cea, 1122); clinger_fast_path_test<double>(1, 30, 0x93e5939a08cea, 1122);
ClingerFastPathTest<double>(1, 37, 0xe17b84357691b, 1145); clinger_fast_path_test<double>(1, 37, 0xe17b84357691b, 1145);
ClingerFastPathFailsTest<double>(10, 37); clinger_fast_path_fails_test<double>(10, 37);
ClingerFastPathFailsTest<double>(1, 100); clinger_fast_path_fails_test<double>(1, 100);
} }
TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64NegativeExp) { TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64NegativeExp) {
ClingerFastPathTest<double>(1, -10, 0xb7cdfd9d7bdbb, 989); clinger_fast_path_test<double>(1, -10, 0xb7cdfd9d7bdbb, 989);
ClingerFastPathTest<double>(1, -20, 0x79ca10c924223, 956); clinger_fast_path_test<double>(1, -20, 0x79ca10c924223, 956);
ClingerFastPathFailsTest<double>(1, -25); clinger_fast_path_fails_test<double>(1, -25);
} }
TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat32Simple) { TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat32Simple) {
ClingerFastPathTest<float>(123, 0, 0x760000, 133); clinger_fast_path_test<float>(123, 0, 0x760000, 133);
ClingerFastPathTest<float>(1234567, 1, 0x3c6146, 150); clinger_fast_path_test<float>(1234567, 1, 0x3c6146, 150);
ClingerFastPathTest<float>(12345, -5, 0x7cd35b, 123); clinger_fast_path_test<float>(12345, -5, 0x7cd35b, 123);
} }
TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat32ExtendedExp) { TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat32ExtendedExp) {
ClingerFastPathTest<float>(1, 15, 0x635fa9, 176); clinger_fast_path_test<float>(1, 15, 0x635fa9, 176);
ClingerFastPathTest<float>(1, 17, 0x31a2bc, 183); clinger_fast_path_test<float>(1, 17, 0x31a2bc, 183);
ClingerFastPathFailsTest<float>(10, 17); clinger_fast_path_fails_test<float>(10, 17);
ClingerFastPathFailsTest<float>(1, 50); clinger_fast_path_fails_test<float>(1, 50);
} }
TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat32NegativeExp) { TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat32NegativeExp) {
ClingerFastPathTest<float>(1, -5, 0x27c5ac, 110); clinger_fast_path_test<float>(1, -5, 0x27c5ac, 110);
ClingerFastPathTest<float>(1, -10, 0x5be6ff, 93); clinger_fast_path_test<float>(1, -10, 0x5be6ff, 93);
ClingerFastPathFailsTest<float>(1, -15); clinger_fast_path_fails_test<float>(1, -15);
} }
TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat64Simple) { TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat64Simple) {
EiselLemireTest<double>(12345678901234567890u, 1, 0x1AC53A7E04BCDA, 1089); eisel_lemire_test<double>(12345678901234567890u, 1, 0x1AC53A7E04BCDA, 1089);
EiselLemireTest<double>(123, 0, 0x1EC00000000000, 1029); eisel_lemire_test<double>(123, 0, 0x1EC00000000000, 1029);
EiselLemireTest<double>(12345678901234568192u, 0, 0x156A95319D63E2, 1086); eisel_lemire_test<double>(12345678901234568192u, 0, 0x156A95319D63E2, 1086);
} }
TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat64SpecificFailures) { TEST_F(LlvmLibcStrToFloatTest, EiselLemireFloat64SpecificFailures) {
// These test cases have caused failures in the past. // These test cases have caused failures in the past.
EiselLemireTest<double>(358416272, -33, 0x1BBB2A68C9D0B9, 941); eisel_lemire_test<double>(358416272, -33, 0x1BBB2A68C9D0B9, 941);
EiselLemireTest<double>(2166568064000000238u, -9, 0x10246690000000, 1054); eisel_lemire_test<double>(2166568064000000238u, -9, 0x10246690000000, 1054);
EiselLemireTest<double>(2794967654709307187u, 1, 0x183e132bc608c8, 1087); eisel_lemire_test<double>(2794967654709307187u, 1, 0x183e132bc608c8, 1087);
EiselLemireTest<double>(2794967654709307188u, 1, 0x183e132bc608c9, 1087); eisel_lemire_test<double>(2794967654709307188u, 1, 0x183e132bc608c9, 1087);
} }
TEST_F(LlvmLibcStrToFloatTest, EiselLemireFallbackStates) { TEST_F(LlvmLibcStrToFloatTest, EiselLemireFallbackStates) {
// Check the fallback states for the algorithm: // Check the fallback states for the algorithm:
uint32_t floatOutputMantissa = 0; uint32_t float_output_mantissa = 0;
uint64_t doubleOutputMantissa = 0; uint64_t double_output_mantissa = 0;
__uint128_t tooLongMantissa = 0; __uint128_t too_long_mantissa = 0;
uint32_t outputExp2 = 0; uint32_t output_exp2 = 0;
// This Eisel-Lemire implementation doesn't support long doubles yet. // This Eisel-Lemire implementation doesn't support long doubles yet.
ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<long double>( 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 // This number can't be evaluated by Eisel-Lemire since it's exactly 1024 away
// from both of its closest floating point approximations // from both of its closest floating point approximations
// (12345678901234548736 and 12345678901234550784) // (12345678901234548736 and 12345678901234550784)
ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<double>( 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>( ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<float>(
20040229, 0, &floatOutputMantissa, &outputExp2)); 20040229, 0, &float_output_mantissa, &output_exp2));
} }
TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicWholeNumbers) { TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicWholeNumbers) {
SimpleDecimalConversionTest<double>("123456789012345678900", 0x1AC53A7E04BCDA, simple_decimal_conversion_test<double>("123456789012345678900",
1089); 0x1AC53A7E04BCDA, 1089);
SimpleDecimalConversionTest<double>("123", 0x1EC00000000000, 1029); simple_decimal_conversion_test<double>("123", 0x1EC00000000000, 1029);
SimpleDecimalConversionTest<double>("12345678901234549760", 0x156A95319D63D8, simple_decimal_conversion_test<double>("12345678901234549760",
1086); 0x156A95319D63D8, 1086);
} }
TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicDecimals) { TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicDecimals) {
SimpleDecimalConversionTest<double>("1.2345", 0x13c083126e978d, 1023); simple_decimal_conversion_test<double>("1.2345", 0x13c083126e978d, 1023);
SimpleDecimalConversionTest<double>(".2345", 0x1e04189374bc6a, 1020); simple_decimal_conversion_test<double>(".2345", 0x1e04189374bc6a, 1020);
SimpleDecimalConversionTest<double>(".299792458", 0x132fccb4aca314, 1021); simple_decimal_conversion_test<double>(".299792458", 0x132fccb4aca314, 1021);
} }
TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicExponents) { TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicExponents) {
SimpleDecimalConversionTest<double>("1e10", 0x12a05f20000000, 1056); simple_decimal_conversion_test<double>("1e10", 0x12a05f20000000, 1056);
SimpleDecimalConversionTest<double>("1e-10", 0x1b7cdfd9d7bdbb, 989); simple_decimal_conversion_test<double>("1e-10", 0x1b7cdfd9d7bdbb, 989);
SimpleDecimalConversionTest<double>("1e300", 0x17e43c8800759c, 2019); simple_decimal_conversion_test<double>("1e300", 0x17e43c8800759c, 2019);
SimpleDecimalConversionTest<double>("1e-300", 0x156e1fc2f8f359, 26); simple_decimal_conversion_test<double>("1e-300", 0x156e1fc2f8f359, 26);
} }
TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicSubnormals) { TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicSubnormals) {
SimpleDecimalConversionTest<double>("1e-320", 0x7e8, 0, ERANGE); simple_decimal_conversion_test<double>("1e-320", 0x7e8, 0, ERANGE);
SimpleDecimalConversionTest<double>("1e-308", 0x730d67819e8d2, 0, ERANGE); simple_decimal_conversion_test<double>("1e-308", 0x730d67819e8d2, 0, ERANGE);
SimpleDecimalConversionTest<double>("2.9e-308", 0x14da6df5e4bcc8, 1); simple_decimal_conversion_test<double>("2.9e-308", 0x14da6df5e4bcc8, 1);
} }
TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64SubnormalRounding) { TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64SubnormalRounding) {
// Technically you can keep adding digits until you hit the truncation limit, // 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 // but this is the shortest string that results in the maximum subnormal that
// I found. // I found.
SimpleDecimalConversionTest<double>("2.225073858507201e-308", 0xfffffffffffff, simple_decimal_conversion_test<double>("2.225073858507201e-308",
0, ERANGE); 0xfffffffffffff, 0, ERANGE);
// Same here, if you were to extend the max subnormal out for another 800 // 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. // digits, incrementing any one of those digits would create a normal number.
SimpleDecimalConversionTest<double>("2.2250738585072012e-308", simple_decimal_conversion_test<double>("2.2250738585072012e-308",
0x10000000000000, 1); 0x10000000000000, 1);
} }
TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion32SpecificFailures) { TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion32SpecificFailures) {
SimpleDecimalConversionTest<float>( simple_decimal_conversion_test<float>(
"1.4012984643248170709237295832899161312802619418765e-45", 0x1, 0, "1.4012984643248170709237295832899161312802619418765e-45", 0x1, 0,
ERANGE); ERANGE);
} }
TEST(LlvmLibcStrToFloatTest, SimpleDecimalConversionExtraTypes) { TEST(LlvmLibcStrToFloatTest, SimpleDecimalConversionExtraTypes) {
uint32_t floatOutputMantissa = 0; uint32_t float_output_mantissa = 0;
uint32_t outputExp2 = 0; uint32_t output_exp2 = 0;
errno = 0; errno = 0;
__llvm_libc::internal::simple_decimal_conversion<float>( __llvm_libc::internal::simple_decimal_conversion<float>(
"123456789012345678900", &floatOutputMantissa, &outputExp2); "123456789012345678900", &float_output_mantissa, &output_exp2);
EXPECT_EQ(floatOutputMantissa, uint32_t(0xd629d4)); EXPECT_EQ(float_output_mantissa, uint32_t(0xd629d4));
EXPECT_EQ(outputExp2, uint32_t(193)); EXPECT_EQ(output_exp2, uint32_t(193));
EXPECT_EQ(errno, 0); EXPECT_EQ(errno, 0);
uint64_t doubleOutputMantissa = 0; uint64_t double_output_mantissa = 0;
outputExp2 = 0; output_exp2 = 0;
errno = 0; errno = 0;
__llvm_libc::internal::simple_decimal_conversion<double>( __llvm_libc::internal::simple_decimal_conversion<double>(
"123456789012345678900", &doubleOutputMantissa, &outputExp2); "123456789012345678900", &double_output_mantissa, &output_exp2);
EXPECT_EQ(doubleOutputMantissa, uint64_t(0x1AC53A7E04BCDA)); EXPECT_EQ(double_output_mantissa, uint64_t(0x1AC53A7E04BCDA));
EXPECT_EQ(outputExp2, uint32_t(1089)); EXPECT_EQ(output_exp2, uint32_t(1089));
EXPECT_EQ(errno, 0); EXPECT_EQ(errno, 0);
// TODO(michaelrj): Get long double support working. // TODO(michaelrj): Get long double support working.
// __uint128_t longDoubleOutputMantissa = 0; // __uint128_t longDoubleOutputMantissa = 0;
// outputExp2 = 0; // outputExp2 = 0;
// errno = 0; // errno = 0;
// __llvm_libc::internal::simple_decimal_conversion<long double>( // __llvm_libc::internal::simple_decimal_conversion<long double>(
// "123456789012345678900", &longDoubleOutputMantissa, &outputExp2); // "123456789012345678900", &longDoubleOutputMantissa, &outputExp2);
// EXPECT_EQ(longDoubleOutputMantissa, __uint128_t(0x1AC53A7E04BCDA)); // EXPECT_EQ(longDoubleOutputMantissa, __uint128_t(0x1AC53A7E04BCDA));
// EXPECT_EQ(outputExp2, uint32_t(1089)); // EXPECT_EQ(outputExp2, uint32_t(1089));
// EXPECT_EQ(errno, 0); // EXPECT_EQ(errno, 0);
} }

libc/test/src/fenv/enabled_exceptions_test.cpp

Show All 40 Lines#endif // defined(LLVM_LIBC_ARCH_AARCH64)
// longjmp implemented. // longjmp implemented.
int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW, int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
FE_UNDERFLOW}; FE_UNDERFLOW};
// We '|' the individual exception flags instead of using FE_ALL_EXCEPT // We '|' the individual exception flags instead of using FE_ALL_EXCEPT
// as it can include non-standard extensions. Note that we should be able // as it can include non-standard extensions. Note that we should be able
// to compile this file with headers from other libcs as well. // 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; FE_DIVBYZERO | FE_INVALID | FE_INEXACT | FE_OVERFLOW | FE_UNDERFLOW;
for (int e : excepts) { for (int e : excepts) {
__llvm_libc::fputil::disable_except(FE_ALL_EXCEPT); __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
__llvm_libc::fputil::enable_except(e); __llvm_libc::fputil::enable_except(e);
ASSERT_EQ(__llvm_libc::feclearexcept(FE_ALL_EXCEPT), 0); ASSERT_EQ(__llvm_libc::feclearexcept(FE_ALL_EXCEPT), 0);
// Raising all exceptions except |e| should not call the // Raising all exceptions except |e| should not call the
// SIGFPE handler. They should set the exception flag though, // SIGFPE handler. They should set the exception flag though,
// so we verify that. Since other exceptions like FE_DIVBYZERO // so we verify that. Since other exceptions like FE_DIVBYZERO
// can raise FE_INEXACT as well, we don't verify the other // can raise FE_INEXACT as well, we don't verify the other
// exception flags when FE_INEXACT is enabled. // exception flags when FE_INEXACT is enabled.
if (e != FE_INEXACT) { if (e != FE_INEXACT) {
int others = allExcepts & ~e; int others = ALL_EXCEPTS & ~e;
ASSERT_EQ(__llvm_libc::feraiseexcept(others), 0); ASSERT_EQ(__llvm_libc::feraiseexcept(others), 0);
ASSERT_EQ(__llvm_libc::fetestexcept(others), others); ASSERT_EQ(__llvm_libc::fetestexcept(others), others);
} }
ASSERT_RAISES_FP_EXCEPT([=] { ASSERT_RAISES_FP_EXCEPT([=] {
// In test frameworks like Fuchsia's zxtest, this translates to // In test frameworks like Fuchsia's zxtest, this translates to
// a death test which runs this closure in a different thread. So, // a death test which runs this closure in a different thread. So,
// we enable the exception again inside this closure so that the // we enable the exception again inside this closure so that the
Show All 10 Lines

libc/test/src/fenv/exception_status_test.cpp

Show All 19 LinesTEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
// status flags are updated. The intention is really not to invoke the // status flags are updated. The intention is really not to invoke the
// exception handler. Hence, we will disable all exceptions at the // exception handler. Hence, we will disable all exceptions at the
// beginning. // beginning.
__llvm_libc::fputil::disable_except(FE_ALL_EXCEPT); __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW, int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
FE_UNDERFLOW}; FE_UNDERFLOW};
constexpr int allExcepts = constexpr int ALL_EXCEPTS =
FE_DIVBYZERO | FE_INVALID | FE_INEXACT | FE_OVERFLOW | FE_UNDERFLOW; FE_DIVBYZERO | FE_INVALID | FE_INEXACT | FE_OVERFLOW | FE_UNDERFLOW;
for (int e : excepts) { for (int e : excepts) {
int r = __llvm_libc::feraiseexcept(e); int r = __llvm_libc::feraiseexcept(e);
ASSERT_EQ(r, 0); ASSERT_EQ(r, 0);
int s = __llvm_libc::fetestexcept(e); int s = __llvm_libc::fetestexcept(e);
ASSERT_EQ(s, e); ASSERT_EQ(s, e);
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines for (int e2 : excepts) {
s = __llvm_libc::fetestexcept(e); s = __llvm_libc::fetestexcept(e);
ASSERT_EQ(s, 0); ASSERT_EQ(s, 0);
} }
} }
} }
} }
} }
int r = __llvm_libc::feraiseexcept(allExcepts); int r = __llvm_libc::feraiseexcept(ALL_EXCEPTS);
ASSERT_EQ(r, 0); ASSERT_EQ(r, 0);
int s = __llvm_libc::fetestexcept(allExcepts); int s = __llvm_libc::fetestexcept(ALL_EXCEPTS);
ASSERT_EQ(s, allExcepts); ASSERT_EQ(s, ALL_EXCEPTS);
} }

libc/test/src/math/CeilTest.h

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines void testFractions(CeilFunc func) {
EXPECT_FP_EQ(T(-10.0), func(T(-10.65))); EXPECT_FP_EQ(T(-10.0), func(T(-10.65)));
EXPECT_FP_EQ(T(1235.0), func(T(1234.38))); EXPECT_FP_EQ(T(1235.0), func(T(1234.38)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38))); EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38)));
EXPECT_FP_EQ(T(1235.0), func(T(1234.96))); EXPECT_FP_EQ(T(1235.0), func(T(1234.96)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96))); EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96)));
} }
void testRange(CeilFunc func) { void testRange(CeilFunc func) {
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, func(x), 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, func(x), 0.0);
} }
} }
}; };
#define LIST_CEIL_TESTS(T, func) \ #define LIST_CEIL_TESTS(T, func) \
using LlvmLibcCeilTest = CeilTest<T>; \ using LlvmLibcCeilTest = CeilTest<T>; \
TEST_F(LlvmLibcCeilTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcCeilTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcCeilTest, RoundedNubmers) { testRoundedNumbers(&func); } \ TEST_F(LlvmLibcCeilTest, RoundedNubmers) { testRoundedNumbers(&func); } \
TEST_F(LlvmLibcCeilTest, Fractions) { testFractions(&func); } \ TEST_F(LlvmLibcCeilTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcCeilTest, Range) { testRange(&func); } TEST_F(LlvmLibcCeilTest, Range) { testRange(&func); }

libc/test/src/math/CopySignTest.h

Show All 27 Lines void testSpecialNumbers(CopySignFunc func) {
EXPECT_FP_EQ(neg_inf, func(inf, -1.0)); EXPECT_FP_EQ(neg_inf, func(inf, -1.0));
EXPECT_FP_EQ(inf, func(neg_inf, 1.0)); EXPECT_FP_EQ(inf, func(neg_inf, 1.0));
EXPECT_FP_EQ(neg_zero, func(zero, -1.0)); EXPECT_FP_EQ(neg_zero, func(zero, -1.0));
EXPECT_FP_EQ(zero, func(neg_zero, 1.0)); EXPECT_FP_EQ(zero, func(neg_zero, 1.0));
} }
void testRange(CopySignFunc func) { void testRange(CopySignFunc func) {
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
double res1 = func(x, -x); double res1 = func(x, -x);
ASSERT_FP_EQ(res1, -x); ASSERT_FP_EQ(res1, -x);
double res2 = func(x, x); double res2 = func(x, x);
Show All 9 Lines

libc/test/src/math/FAbsTest.h

Show All 26 Lines void testSpecialNumbers(FabsFunc func) {
EXPECT_FP_EQ(inf, func(inf)); EXPECT_FP_EQ(inf, func(inf));
EXPECT_FP_EQ(inf, func(neg_inf)); EXPECT_FP_EQ(inf, func(neg_inf));
EXPECT_FP_EQ(zero, func(zero)); EXPECT_FP_EQ(zero, func(zero));
EXPECT_FP_EQ(zero, func(neg_zero)); EXPECT_FP_EQ(zero, func(neg_zero));
} }
void testRange(FabsFunc func) { void testRange(FabsFunc func) {
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, func(x), 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, func(x), 0.0);
} }
} }
}; };
#define LIST_FABS_TESTS(T, func) \ #define LIST_FABS_TESTS(T, func) \
using LlvmLibcFAbsTest = FAbsTest<T>; \ using LlvmLibcFAbsTest = FAbsTest<T>; \
TEST_F(LlvmLibcFAbsTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcFAbsTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcFAbsTest, Range) { testRange(&func); } TEST_F(LlvmLibcFAbsTest, Range) { testRange(&func); }

libc/test/src/math/FDimTest.h

Show All 13 Lines
template <typename T> template <typename T>
class FDimTestTemplate : public __llvm_libc::testing::Test { class FDimTestTemplate : public __llvm_libc::testing::Test {
public: public:
using FuncPtr = T (*)(T, T); using FuncPtr = T (*)(T, T);
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPBits = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; 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(nan, inf));
EXPECT_FP_EQ(nan, func(neg_inf, nan)); EXPECT_FP_EQ(nan, func(neg_inf, nan));
EXPECT_FP_EQ(nan, func(nan, zero)); EXPECT_FP_EQ(nan, func(nan, zero));
EXPECT_FP_EQ(nan, func(neg_zero, nan)); EXPECT_FP_EQ(nan, func(neg_zero, nan));
EXPECT_FP_EQ(nan, func(nan, T(-1.2345))); EXPECT_FP_EQ(nan, func(nan, T(-1.2345)));
EXPECT_FP_EQ(nan, func(T(1.2345), nan)); EXPECT_FP_EQ(nan, func(T(1.2345), nan));
EXPECT_FP_EQ(func(nan, nan), nan); 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(zero, func(neg_inf, inf));
EXPECT_FP_EQ(inf, func(inf, zero)); EXPECT_FP_EQ(inf, func(inf, zero));
EXPECT_FP_EQ(zero, func(neg_zero, inf)); EXPECT_FP_EQ(zero, func(neg_zero, inf));
EXPECT_FP_EQ(inf, func(inf, T(1.2345))); EXPECT_FP_EQ(inf, func(inf, T(1.2345)));
EXPECT_FP_EQ(zero, func(T(-1.2345), inf)); 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(inf, func(inf, neg_inf));
EXPECT_FP_EQ(zero, func(neg_inf, zero)); EXPECT_FP_EQ(zero, func(neg_inf, zero));
EXPECT_FP_EQ(inf, func(neg_zero, neg_inf)); EXPECT_FP_EQ(inf, func(neg_zero, neg_inf));
EXPECT_FP_EQ(zero, func(neg_inf, T(-1.2345))); EXPECT_FP_EQ(zero, func(neg_inf, T(-1.2345)));
EXPECT_FP_EQ(inf, func(T(1.2345), neg_inf)); 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, zero));
EXPECT_FP_EQ(zero, func(zero, neg_zero)); EXPECT_FP_EQ(zero, func(zero, neg_zero));
EXPECT_FP_EQ(zero, func(neg_zero, zero)); EXPECT_FP_EQ(zero, func(neg_zero, zero));
EXPECT_FP_EQ(zero, func(neg_zero, neg_zero)); EXPECT_FP_EQ(zero, func(neg_zero, neg_zero));
} }
void testInRange(FuncPtr func) { void test_in_range(FuncPtr func) {
constexpr UIntType count = 10000001; constexpr UIntType COUNT = 10000001;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
++i, v += step, w -= step) { ++i, v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w)); T x = T(FPBits(v)), y = T(FPBits(w));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if (x > y) { if (x > y) {
EXPECT_FP_EQ(x - y, func(x, y)); EXPECT_FP_EQ(x - y, func(x, y));
Show All 15 Lines

libc/test/src/math/FMaxTest.h

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linespublic:
void testBothZero(FMaxFunc func) { void testBothZero(FMaxFunc func) {
EXPECT_FP_EQ(0.0, func(0.0, 0.0)); EXPECT_FP_EQ(0.0, func(0.0, 0.0));
EXPECT_FP_EQ(0.0, func(-0.0, 0.0)); EXPECT_FP_EQ(0.0, func(-0.0, 0.0));
EXPECT_FP_EQ(0.0, func(0.0, -0.0)); EXPECT_FP_EQ(0.0, func(0.0, -0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
} }
void testRange(FMaxFunc func) { void testRange(FMaxFunc func) {
constexpr UIntType count = 10000001; constexpr UIntType COUNT = 10000001;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
++i, v += step, w -= step) { ++i, v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w)); T x = T(FPBits(v)), y = T(FPBits(w));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if ((x == 0) && (y == 0)) if ((x == 0) && (y == 0))
continue; continue;
Show All 16 Lines

libc/test/src/math/FMinTest.h

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linespublic:
void testBothZero(FMinFunc func) { void testBothZero(FMinFunc func) {
EXPECT_FP_EQ(0.0, func(0.0, 0.0)); EXPECT_FP_EQ(0.0, func(0.0, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, 0.0)); EXPECT_FP_EQ(-0.0, func(-0.0, 0.0));
EXPECT_FP_EQ(-0.0, func(0.0, -0.0)); EXPECT_FP_EQ(-0.0, func(0.0, -0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
} }
void testRange(FMinFunc func) { void testRange(FMinFunc func) {
constexpr UIntType count = 10000001; constexpr UIntType COUNT = 10000001;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
++i, v += step, w -= step) { ++i, v += STEP, w -= STEP) {
T x = T(FPBits(v)), y = T(FPBits(w)); T x = T(FPBits(v)), y = T(FPBits(w));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
if (isnan(y) || isinf(y)) if (isnan(y) || isinf(y))
continue; continue;
if ((x == 0) && (y == 0)) if ((x == 0) && (y == 0))
continue; continue;
Show All 16 Lines

libc/test/src/math/FloorTest.h

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines void testFractions(FloorFunc func) {
EXPECT_FP_EQ(T(-11.0), func(T(-10.65))); EXPECT_FP_EQ(T(-11.0), func(T(-10.65)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.38))); EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
EXPECT_FP_EQ(T(-1235.0), func(T(-1234.38))); EXPECT_FP_EQ(T(-1235.0), func(T(-1234.38)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.96))); EXPECT_FP_EQ(T(1234.0), func(T(1234.96)));
EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96))); EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96)));
} }
void testRange(FloorFunc func) { void testRange(FloorFunc func) {
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, func(x), 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, func(x), 0.0);
} }
} }
}; };
#define LIST_FLOOR_TESTS(T, func) \ #define LIST_FLOOR_TESTS(T, func) \
using LlvmLibcFloorTest = FloorTest<T>; \ using LlvmLibcFloorTest = FloorTest<T>; \
TEST_F(LlvmLibcFloorTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcFloorTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcFloorTest, RoundedNubmers) { testRoundedNumbers(&func); } \ TEST_F(LlvmLibcFloorTest, RoundedNubmers) { testRoundedNumbers(&func); } \
TEST_F(LlvmLibcFloorTest, Fractions) { testFractions(&func); } \ TEST_F(LlvmLibcFloorTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcFloorTest, Range) { testRange(&func); } TEST_F(LlvmLibcFloorTest, Range) { testRange(&func); }

libc/test/src/math/FmaTest.h

Show All 23 Linesprivate:
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPBits = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPBits::UIntType;
const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1)); const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
const T inf = T(__llvm_libc::fputil::FPBits<T>::inf()); const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf()); const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
const T zero = T(__llvm_libc::fputil::FPBits<T>::zero()); const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero()); const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
UIntType getRandomBitPattern() { UIntType get_random_bit_pattern() {
UIntType bits{0}; UIntType bits{0};
for (UIntType i = 0; i < sizeof(UIntType) / 2; ++i) { for (UIntType i = 0; i < sizeof(UIntType) / 2; ++i) {
bits = bits =
(bits << 2) + static_cast<uint16_t>(__llvm_libc::testutils::rand()); (bits << 2) + static_cast<uint16_t>(__llvm_libc::testutils::rand());
} }
return bits; return bits;
} }
public: public:
void testSpecialNumbers(Func func) { void test_special_numbers(Func func) {
EXPECT_FP_EQ(func(zero, zero, zero), zero); EXPECT_FP_EQ(func(zero, zero, zero), zero);
EXPECT_FP_EQ(func(zero, neg_zero, neg_zero), neg_zero); EXPECT_FP_EQ(func(zero, neg_zero, neg_zero), neg_zero);
EXPECT_FP_EQ(func(inf, inf, zero), inf); EXPECT_FP_EQ(func(inf, inf, zero), inf);
EXPECT_FP_EQ(func(neg_inf, inf, neg_inf), neg_inf); EXPECT_FP_EQ(func(neg_inf, inf, neg_inf), neg_inf);
EXPECT_FP_EQ(func(inf, zero, zero), nan); EXPECT_FP_EQ(func(inf, zero, zero), nan);
EXPECT_FP_EQ(func(inf, neg_inf, inf), nan); EXPECT_FP_EQ(func(inf, neg_inf, inf), nan);
EXPECT_FP_EQ(func(nan, zero, inf), nan); EXPECT_FP_EQ(func(nan, zero, inf), nan);
EXPECT_FP_EQ(func(inf, neg_inf, nan), nan); EXPECT_FP_EQ(func(inf, neg_inf, nan), nan);
// Test underflow rounding up. // Test underflow rounding up.
EXPECT_FP_EQ(func(T(0.5), T(FPBits(FPBits::MIN_SUBNORMAL)), EXPECT_FP_EQ(func(T(0.5), T(FPBits(FPBits::MIN_SUBNORMAL)),
T(FPBits(FPBits::MIN_SUBNORMAL))), T(FPBits(FPBits::MIN_SUBNORMAL))),
T(FPBits(UIntType(2)))); T(FPBits(UIntType(2))));
// Test underflow rounding down. // Test underflow rounding down.
T v = T(FPBits(FPBits::MIN_NORMAL + UIntType(1))); T v = T(FPBits(FPBits::MIN_NORMAL + UIntType(1)));
EXPECT_FP_EQ(func(T(1) / T(FPBits::MIN_NORMAL << 1), v, EXPECT_FP_EQ(func(T(1) / T(FPBits::MIN_NORMAL << 1), v,
T(FPBits(FPBits::MIN_NORMAL))), T(FPBits(FPBits::MIN_NORMAL))),
v); v);
// Test overflow. // Test overflow.
T z = T(FPBits(FPBits::MAX_NORMAL)); T z = T(FPBits(FPBits::MAX_NORMAL));
EXPECT_FP_EQ(func(T(1.75), z, -z), T(0.75) * z); EXPECT_FP_EQ(func(T(1.75), z, -z), T(0.75) * z);
} }
void testSubnormalRange(Func func) { void test_subnormal_range(Func func) {
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType step = constexpr UIntType STEP =
(FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count; (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL; for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL;
v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL; v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL;
v += step, w -= step) { v += STEP, w -= STEP) {
T x = T(FPBits(getRandomBitPattern())), y = T(FPBits(v)), T x = T(FPBits(get_random_bit_pattern())), y = T(FPBits(v)),
z = T(FPBits(w)); z = T(FPBits(w));
T result = func(x, y, z); T result = func(x, y, z);
mpfr::TernaryInput<T> input{x, y, z}; mpfr::TernaryInput<T> input{x, y, z};
ASSERT_MPFR_MATCH(mpfr::Operation::Fma, input, result, 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Fma, input, result, 0.5);
} }
} }
void testNormalRange(Func func) { void test_normal_range(Func func) {
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count; constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL; for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_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)), 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); T result = func(x, y, z);
mpfr::TernaryInput<T> input{x, y, z}; mpfr::TernaryInput<T> input{x, y, z};
ASSERT_MPFR_MATCH(mpfr::Operation::Fma, input, result, 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Fma, input, result, 0.5);
} }
} }
}; };
#endif // LLVM_LIBC_TEST_SRC_MATH_FMATEST_H #endif // LLVM_LIBC_TEST_SRC_MATH_FMATEST_H

libc/test/src/math/FrexpTest.h

Show All 13 Lines
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class FrexpTest : public __llvm_libc::testing::Test { template <typename T> class FrexpTest : public __llvm_libc::testing::Test {
DECLARE_SPECIAL_CONSTANTS(T) DECLARE_SPECIAL_CONSTANTS(T)
static constexpr UIntType HiddenBit = static constexpr UIntType HIDDEN_BIT =
UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE; UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE;
public: public:
typedef T (*FrexpFunc)(T, int *); typedef T (*FrexpFunc)(T, int *);
void testSpecialNumbers(FrexpFunc func) { void testSpecialNumbers(FrexpFunc func) {
int exponent; int exponent;
ASSERT_FP_EQ(aNaN, func(aNaN, &exponent)); ASSERT_FP_EQ(aNaN, func(aNaN, &exponent));
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines void testSomeIntegers(FrexpFunc func) {
EXPECT_FP_EQ(T(0.78125), func(T(800.0), &exponent)); EXPECT_FP_EQ(T(0.78125), func(T(800.0), &exponent));
EXPECT_EQ(exponent, 10); EXPECT_EQ(exponent, 10);
EXPECT_FP_EQ(T(-0.78125), func(T(-800.0), &exponent)); EXPECT_FP_EQ(T(-0.78125), func(T(-800.0), &exponent));
EXPECT_EQ(exponent, 10); EXPECT_EQ(exponent, 10);
} }
void testRange(FrexpFunc func) { void testRange(FrexpFunc func) {
using UIntType = typename FPBits::UIntType; using UIntType = typename FPBits::UIntType;
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = static_cast<T>(FPBits(v)); T x = static_cast<T>(FPBits(v));
if (isnan(x) || isinf(x) || x == 0.0l) if (isnan(x) || isinf(x) || x == 0.0l)
continue; continue;
mpfr::BinaryOutput<T> result; mpfr::BinaryOutput<T> result;
result.f = func(x, &result.i); result.f = func(x, &result.i);
ASSERT_TRUE(__llvm_libc::fputil::abs(result.f) < 1.0); ASSERT_TRUE(__llvm_libc::fputil::abs(result.f) < 1.0);
Show All 12 Lines

libc/test/src/math/HypotTest.h

Show All 26 Linesprivate:
using UIntType = typename FPBits::UIntType; using UIntType = typename FPBits::UIntType;
const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1)); const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
const T inf = T(__llvm_libc::fputil::FPBits<T>::inf()); const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf()); const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
const T zero = T(__llvm_libc::fputil::FPBits<T>::zero()); const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero()); const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
public: public:
void testSpecialNumbers(Func func) { void test_special_numbers(Func func) {
EXPECT_FP_EQ(func(inf, nan), inf); EXPECT_FP_EQ(func(inf, nan), inf);
EXPECT_FP_EQ(func(nan, neg_inf), inf); EXPECT_FP_EQ(func(nan, neg_inf), inf);
EXPECT_FP_EQ(func(zero, inf), inf); EXPECT_FP_EQ(func(zero, inf), inf);
EXPECT_FP_EQ(func(neg_inf, neg_zero), inf); EXPECT_FP_EQ(func(neg_inf, neg_zero), inf);
EXPECT_FP_EQ(func(nan, nan), nan); EXPECT_FP_EQ(func(nan, nan), nan);
EXPECT_FP_EQ(func(nan, zero), nan); EXPECT_FP_EQ(func(nan, zero), nan);
EXPECT_FP_EQ(func(neg_zero, nan), nan); EXPECT_FP_EQ(func(neg_zero, nan), nan);
EXPECT_FP_EQ(func(neg_zero, zero), zero); EXPECT_FP_EQ(func(neg_zero, zero), zero);
} }
void testSubnormalRange(Func func) { void test_subnormal_range(Func func) {
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
for (unsigned scale = 0; scale < 4; ++scale) { for (unsigned scale = 0; scale < 4; ++scale) {
UIntType maxValue = FPBits::MAX_SUBNORMAL << scale; UIntType max_value = FPBits::MAX_SUBNORMAL << scale;
UIntType step = (maxValue - FPBits::MIN_SUBNORMAL) / count; UIntType step = (max_value - FPBits::MIN_SUBNORMAL) / COUNT;
for (int signs = 0; signs < 4; ++signs) { for (int signs = 0; signs < 4; ++signs) {
for (UIntType v = FPBits::MIN_SUBNORMAL, w = maxValue; for (UIntType v = FPBits::MIN_SUBNORMAL, w = max_value;
v <= maxValue && w >= FPBits::MIN_SUBNORMAL; v <= max_value && w >= FPBits::MIN_SUBNORMAL;
v += step, w -= step) { v += step, w -= step) {
T x = T(FPBits(v)), y = T(FPBits(w)); T x = T(FPBits(v)), y = T(FPBits(w));
if (signs % 2 == 1) { if (signs % 2 == 1) {
x = -x; x = -x;
} }
if (signs >= 2) { if (signs >= 2) {
y = -y; y = -y;
} }
T result = func(x, y); T result = func(x, y);
mpfr::BinaryInput<T> input{x, y}; mpfr::BinaryInput<T> input{x, y};
ASSERT_MPFR_MATCH(mpfr::Operation::Hypot, input, result, 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Hypot, input, result, 0.5);
} }
} }
} }
} }
void testNormalRange(Func func) { void test_normal_range(Func func) {
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count; constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
for (int signs = 0; signs < 4; ++signs) { for (int signs = 0; signs < 4; ++signs) {
for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL; for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_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)); T x = T(FPBits(v)), y = T(FPBits(w));
if (signs % 2 == 1) { if (signs % 2 == 1) {
x = -x; x = -x;
} }
if (signs >= 2) { if (signs >= 2) {
y = -y; y = -y;
} }
Show All 9 Lines

libc/test/src/math/ILogbTest.h

Show All 15 Lines
#include <limits.h> #include <limits.h>
class LlvmLibcILogbTest : public __llvm_libc::testing::Test { class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
public: public:
template <typename T> struct ILogbFunc { typedef int (*Func)(T); }; template <typename T> struct ILogbFunc { typedef int (*Func)(T); };
template <typename 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>::zero())));
EXPECT_EQ(FP_ILOGB0, func(T(__llvm_libc::fputil::FPBits<T>::neg_zero()))); EXPECT_EQ(FP_ILOGB0, func(T(__llvm_libc::fputil::FPBits<T>::neg_zero())));
EXPECT_EQ(FP_ILOGBNAN, EXPECT_EQ(FP_ILOGBNAN,
func(T(__llvm_libc::fputil::FPBits<T>::build_nan(1)))); func(T(__llvm_libc::fputil::FPBits<T>::build_nan(1))));
EXPECT_EQ(INT_MAX, func(T(__llvm_libc::fputil::FPBits<T>::inf()))); EXPECT_EQ(INT_MAX, func(T(__llvm_libc::fputil::FPBits<T>::inf())));
EXPECT_EQ(INT_MAX, func(T(__llvm_libc::fputil::FPBits<T>::neg_inf()))); 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)));
EXPECT_EQ(0, func(T(-1.0))); EXPECT_EQ(0, func(T(-1.0)));
EXPECT_EQ(1, func(T(2.0))); EXPECT_EQ(1, func(T(2.0)));
EXPECT_EQ(1, func(T(-2.0))); EXPECT_EQ(1, func(T(-2.0)));
EXPECT_EQ(2, func(T(4.0))); EXPECT_EQ(2, func(T(4.0)));
EXPECT_EQ(2, func(T(-4.0))); EXPECT_EQ(2, func(T(-4.0)));
EXPECT_EQ(3, func(T(8.0))); EXPECT_EQ(3, func(T(8.0)));
EXPECT_EQ(3, func(-8.0)); EXPECT_EQ(3, func(-8.0));
EXPECT_EQ(4, func(16.0)); EXPECT_EQ(4, func(16.0));
EXPECT_EQ(4, func(-16.0)); EXPECT_EQ(4, func(-16.0));
EXPECT_EQ(5, func(32.0)); EXPECT_EQ(5, func(32.0));
EXPECT_EQ(5, func(-32.0)); EXPECT_EQ(5, func(-32.0));
} }
template <typename T> 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)));
EXPECT_EQ(1, func(T(-3.0))); EXPECT_EQ(1, func(T(-3.0)));
EXPECT_EQ(2, func(T(7.0))); EXPECT_EQ(2, func(T(7.0)));
EXPECT_EQ(2, func(T(-7.0))); EXPECT_EQ(2, func(T(-7.0)));
EXPECT_EQ(3, func(T(10.0))); EXPECT_EQ(3, func(T(10.0)));
EXPECT_EQ(3, func(T(-10.0))); EXPECT_EQ(3, func(T(-10.0)));
EXPECT_EQ(4, func(T(31.0))); EXPECT_EQ(4, func(T(31.0)));
EXPECT_EQ(4, func(-31.0)); EXPECT_EQ(4, func(-31.0));
EXPECT_EQ(5, func(55.0)); EXPECT_EQ(5, func(55.0));
EXPECT_EQ(5, func(-55.0)); EXPECT_EQ(5, func(-55.0));
} }
template <typename T> 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 FPBits = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPBits::UIntType;
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType step = constexpr UIntType STEP =
(FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count; (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
for (UIntType v = FPBits::MIN_SUBNORMAL; v <= FPBits::MAX_SUBNORMAL; for (UIntType v = FPBits::MIN_SUBNORMAL; v <= FPBits::MAX_SUBNORMAL;
v += step) { v += STEP) {
T x = T(FPBits(v)); T x = T(FPBits(v));
if (isnan(x) || isinf(x) || x == 0.0) if (isnan(x) || isinf(x) || x == 0.0)
continue; continue;
int exponent; int exponent;
__llvm_libc::fputil::frexp(x, exponent); __llvm_libc::fputil::frexp(x, exponent);
ASSERT_EQ(exponent, func(x) + 1); ASSERT_EQ(exponent, func(x) + 1);
} }
} }
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 FPBits = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPBits::UIntType;
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count; constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
for (UIntType v = FPBits::MIN_NORMAL; v <= FPBits::MAX_NORMAL; v += step) { for (UIntType v = FPBits::MIN_NORMAL; v <= FPBits::MAX_NORMAL; v += STEP) {
T x = T(FPBits(v)); T x = T(FPBits(v));
if (isnan(x) || isinf(x) || x == 0.0) if (isnan(x) || isinf(x) || x == 0.0)
continue; continue;
int exponent; int exponent;
__llvm_libc::fputil::frexp(x, exponent); __llvm_libc::fputil::frexp(x, exponent);
ASSERT_EQ(exponent, func(x) + 1); ASSERT_EQ(exponent, func(x) + 1);
} }
} }
}; };
#endif // LLVM_LIBC_TEST_SRC_MATH_ILOGBTEST_H #endif // LLVM_LIBC_TEST_SRC_MATH_ILOGBTEST_H

libc/test/src/math/LdExpTest.h

Show All 17 Lines
#include <math.h> #include <math.h>
#include <stdint.h> #include <stdint.h>
template <typename T> template <typename T>
class LdExpTestTemplate : public __llvm_libc::testing::Test { class LdExpTestTemplate : public __llvm_libc::testing::Test {
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPBits = __llvm_libc::fputil::FPBits<T>;
using NormalFloat = __llvm_libc::fputil::NormalFloat<T>; using NormalFloat = __llvm_libc::fputil::NormalFloat<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPBits::UIntType;
static constexpr UIntType mantissaWidth = static constexpr UIntType MANTISSA_WIDTH =
__llvm_libc::fputil::MantissaWidth<T>::VALUE; __llvm_libc::fputil::MantissaWidth<T>::VALUE;
// A normalized mantissa to be used with tests. // 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 zero = T(__llvm_libc::fputil::FPBits<T>::zero());
const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero()); const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
const T inf = T(__llvm_libc::fputil::FPBits<T>::inf()); const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf()); const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1)); const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
public: public:
typedef T (*LdExpFunc)(T, int); typedef T (*LdExpFunc)(T, int);
void testSpecialNumbers(LdExpFunc func) { void testSpecialNumbers(LdExpFunc func) {
int expArray[5] = {-INT_MAX - 1, -10, 0, 10, INT_MAX}; int exp_array[5] = {-INT_MAX - 1, -10, 0, 10, INT_MAX};
for (int exp : expArray) { for (int exp : exp_array) {
ASSERT_FP_EQ(zero, func(zero, exp)); ASSERT_FP_EQ(zero, func(zero, exp));
ASSERT_FP_EQ(neg_zero, func(neg_zero, exp)); ASSERT_FP_EQ(neg_zero, func(neg_zero, exp));
ASSERT_FP_EQ(inf, func(inf, exp)); ASSERT_FP_EQ(inf, func(inf, exp));
ASSERT_FP_EQ(neg_inf, func(neg_inf, exp)); ASSERT_FP_EQ(neg_inf, func(neg_inf, exp));
ASSERT_FP_EQ(nan, func(nan, exp)); ASSERT_FP_EQ(nan, func(nan, exp));
} }
} }
void testPowersOfTwo(LdExpFunc func) { void testPowersOfTwo(LdExpFunc func) {
int32_t expArray[5] = {1, 2, 3, 4, 5}; int32_t exp_array[5] = {1, 2, 3, 4, 5};
int32_t valArray[6] = {1, 2, 4, 8, 16, 32}; int32_t val_array[6] = {1, 2, 4, 8, 16, 32};
for (int32_t exp : expArray) { for (int32_t exp : exp_array) {
for (int32_t val : valArray) { for (int32_t val : val_array) {
ASSERT_FP_EQ(T(val << exp), func(T(val), exp)); ASSERT_FP_EQ(T(val << exp), func(T(val), exp));
ASSERT_FP_EQ(T(-1 * (val << exp)), func(T(-val), exp)); ASSERT_FP_EQ(T(-1 * (val << exp)), func(T(-val), exp));
} }
} }
} }
void testOverflow(LdExpFunc func) { void testOverflow(LdExpFunc func) {
NormalFloat x(FPBits::MAX_EXPONENT - 10, NormalFloat::ONE + 0xF00BA, 0); NormalFloat x(FPBits::MAX_EXPONENT - 10, NormalFloat::ONE + 0xF00BA, 0);
for (int32_t exp = 10; exp < 100; ++exp) { for (int32_t exp = 10; exp < 100; ++exp) {
ASSERT_FP_EQ(inf, func(T(x), exp)); ASSERT_FP_EQ(inf, func(T(x), exp));
ASSERT_FP_EQ(neg_inf, func(-T(x), exp)); ASSERT_FP_EQ(neg_inf, func(-T(x), exp));
} }
} }
void testUnderflowToZeroOnNormal(LdExpFunc func) { void testUnderflowToZeroOnNormal(LdExpFunc func) {
// In this test, we pass a normal nubmer to func and expect zero // In this test, we pass a normal nubmer to func and expect zero
// to be returned due to underflow. // to be returned due to underflow.
int32_t baseExponent = FPBits::EXPONENT_BIAS + mantissaWidth; int32_t base_exponent = FPBits::EXPONENT_BIAS + MANTISSA_WIDTH;
int32_t expArray[] = {baseExponent + 5, baseExponent + 4, baseExponent + 3, int32_t exp_array[] = {base_exponent + 5, base_exponent + 4,
baseExponent + 2, baseExponent + 1}; base_exponent + 3, base_exponent + 2,
T x = NormalFloat(0, mantissa, 0); base_exponent + 1};
for (int32_t exp : expArray) { T x = NormalFloat(0, MANTISSA, 0);
for (int32_t exp : exp_array) {
ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero); ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero);
} }
} }
void testUnderflowToZeroOnSubnormal(LdExpFunc func) { void testUnderflowToZeroOnSubnormal(LdExpFunc func) {
// In this test, we pass a normal nubmer to func and expect zero // In this test, we pass a normal nubmer to func and expect zero
// to be returned due to underflow. // to be returned due to underflow.
int32_t baseExponent = FPBits::EXPONENT_BIAS + mantissaWidth; int32_t base_exponent = FPBits::EXPONENT_BIAS + MANTISSA_WIDTH;
int32_t expArray[] = {baseExponent + 5, baseExponent + 4, baseExponent + 3, int32_t exp_array[] = {base_exponent + 5, base_exponent + 4,
baseExponent + 2, baseExponent + 1}; base_exponent + 3, base_exponent + 2,
T x = NormalFloat(-FPBits::EXPONENT_BIAS, mantissa, 0); base_exponent + 1};
for (int32_t exp : expArray) { 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); ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero);
} }
} }
void testNormalOperation(LdExpFunc func) { void testNormalOperation(LdExpFunc func) {
T valArray[] = { T val_array[] = {
// Normal numbers // Normal numbers
NormalFloat(100, mantissa, 0), NormalFloat(-100, mantissa, 0), NormalFloat(100, MANTISSA, 0), NormalFloat(-100, MANTISSA, 0),
NormalFloat(100, mantissa, 1), NormalFloat(-100, mantissa, 1), NormalFloat(100, MANTISSA, 1), NormalFloat(-100, MANTISSA, 1),
// Subnormal numbers // Subnormal numbers
NormalFloat(-FPBits::EXPONENT_BIAS, mantissa, 0), NormalFloat(-FPBits::EXPONENT_BIAS, MANTISSA, 0),
NormalFloat(-FPBits::EXPONENT_BIAS, mantissa, 1)}; NormalFloat(-FPBits::EXPONENT_BIAS, MANTISSA, 1)};
for (int32_t exp = 0; exp <= static_cast<int32_t>(mantissaWidth); ++exp) { for (int32_t exp = 0; exp <= static_cast<int32_t>(MANTISSA_WIDTH); ++exp) {
for (T x : valArray) { for (T x : val_array) {
// We compare the result of ldexp with the result // We compare the result of ldexp with the result
// of the native multiplication/division instruction. // of the native multiplication/division instruction.
ASSERT_FP_EQ(func(x, exp), x * (UIntType(1) << exp)); ASSERT_FP_EQ(func(x, exp), x * (UIntType(1) << exp));
ASSERT_FP_EQ(func(x, -exp), x / (UIntType(1) << exp)); ASSERT_FP_EQ(func(x, -exp), x / (UIntType(1) << exp));
} }
} }
// Normal which trigger mantissa overflow. // Normal which trigger mantissa overflow.
T x = NormalFloat(-FPBits::EXPONENT_BIAS + 1, 2 * NormalFloat::ONE - 1, 0); T x = NormalFloat(-FPBits::EXPONENT_BIAS + 1, 2 * NormalFloat::ONE - 1, 0);
ASSERT_FP_EQ(func(x, -1), x / 2); ASSERT_FP_EQ(func(x, -1), x / 2);
ASSERT_FP_EQ(func(-x, -1), -x / 2); ASSERT_FP_EQ(func(-x, -1), -x / 2);
// Start with a normal number high exponent but pass a very low number for // Start with a normal number high exponent but pass a very low number for
// exp. The result should be a subnormal number. // exp. The result should be a subnormal number.
x = NormalFloat(FPBits::EXPONENT_BIAS, NormalFloat::ONE, 0); x = NormalFloat(FPBits::EXPONENT_BIAS, NormalFloat::ONE, 0);
int exp = -FPBits::MAX_EXPONENT - 5; int exp = -FPBits::MAX_EXPONENT - 5;
T result = func(x, exp); T result = func(x, exp);
FPBits resultBits(result); FPBits result_bits(result);
ASSERT_FALSE(resultBits.is_zero()); ASSERT_FALSE(result_bits.is_zero());
// Verify that the result is indeed subnormal. // 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 // But if the exp is so less that normalization leads to zero, then
// the result should be zero. // 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()); ASSERT_TRUE(FPBits(result).is_zero());
// Start with a subnormal number but pass a very high number for exponent. // Start with a subnormal number but pass a very high number for exponent.
// The result should not be infinity. // The result should not be infinity.
x = NormalFloat(-FPBits::EXPONENT_BIAS + 1, NormalFloat::ONE >> 10, 0); x = NormalFloat(-FPBits::EXPONENT_BIAS + 1, NormalFloat::ONE >> 10, 0);
exp = FPBits::MAX_EXPONENT + 5; exp = FPBits::MAX_EXPONENT + 5;
ASSERT_FALSE(FPBits(func(x, exp)).is_inf()); ASSERT_FALSE(FPBits(func(x, exp)).is_inf());
// But if the exp is large enough to oversome than the normalization shift, // But if the exp is large enough to oversome than the normalization shift,
Show All 20 Lines

libc/test/src/math/LogbTest.h

Show All 13 Lines
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class LogbTest : public __llvm_libc::testing::Test { template <typename T> class LogbTest : public __llvm_libc::testing::Test {
DECLARE_SPECIAL_CONSTANTS(T) DECLARE_SPECIAL_CONSTANTS(T)
static constexpr UIntType HiddenBit = static constexpr UIntType HIDDEN_BIT =
UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE; UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE;
public: public:
typedef T (*LogbFunc)(T); typedef T (*LogbFunc)(T);
void testSpecialNumbers(LogbFunc func) { void testSpecialNumbers(LogbFunc func) {
ASSERT_FP_EQ(aNaN, func(aNaN)); ASSERT_FP_EQ(aNaN, func(aNaN));
ASSERT_FP_EQ(inf, func(inf)); ASSERT_FP_EQ(inf, func(inf));
Show All 36 Lines void testSomeIntegers(LogbFunc func) {
EXPECT_FP_EQ(T(4.0), func(T(-31.0))); EXPECT_FP_EQ(T(4.0), func(T(-31.0)));
EXPECT_FP_EQ(T(5.0), func(T(55.0))); EXPECT_FP_EQ(T(5.0), func(T(55.0)));
EXPECT_FP_EQ(T(5.0), func(T(-55.0))); EXPECT_FP_EQ(T(5.0), func(T(-55.0)));
} }
void testRange(LogbFunc func) { void testRange(LogbFunc func) {
using UIntType = typename FPBits::UIntType; using UIntType = typename FPBits::UIntType;
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = static_cast<T>(FPBits(v)); T x = static_cast<T>(FPBits(v));
if (isnan(x) || isinf(x) || x == 0.0l) if (isnan(x) || isinf(x) || x == 0.0l)
continue; continue;
int exponent; int exponent;
__llvm_libc::fputil::frexp(x, exponent); __llvm_libc::fputil::frexp(x, exponent);
ASSERT_FP_EQ(T(exponent), func(x) + T(1.0)); ASSERT_FP_EQ(T(exponent), func(x) + T(1.0));
} }
Show All 9 Lines

libc/test/src/math/ModfTest.h

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines void testFractions(ModfFunc func) {
EXPECT_FP_EQ(T(0.125), func(T(100.125), &integral)); EXPECT_FP_EQ(T(0.125), func(T(100.125), &integral));
EXPECT_FP_EQ(integral, T(100.0)); EXPECT_FP_EQ(integral, T(100.0));
EXPECT_FP_EQ(T(-0.125), func(T(-100.125), &integral)); EXPECT_FP_EQ(T(-0.125), func(T(-100.125), &integral));
EXPECT_FP_EQ(integral, T(-100.0)); EXPECT_FP_EQ(integral, T(-100.0));
} }
void testRange(ModfFunc func) { void testRange(ModfFunc func) {
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPBits(v));
if (isnan(x) || isinf(x) || x == T(0.0)) if (isnan(x) || isinf(x) || x == T(0.0))
continue; continue;
T integral; T integral;
T frac = func(x, &integral); T frac = func(x, &integral);
ASSERT_TRUE(__llvm_libc::fputil::abs(frac) < 1.0l); ASSERT_TRUE(__llvm_libc::fputil::abs(frac) < 1.0l);
ASSERT_TRUE(__llvm_libc::fputil::trunc(x) == integral); ASSERT_TRUE(__llvm_libc::fputil::trunc(x) == integral);
Show All 11 Lines

libc/test/src/math/NextAfterTest.h

Show All 16 Lines
#include <math.h> #include <math.h>
template <typename T> template <typename T>
class NextAfterTestTemplate : public __llvm_libc::testing::Test { class NextAfterTestTemplate : public __llvm_libc::testing::Test {
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPBits = __llvm_libc::fputil::FPBits<T>;
using MantissaWidth = __llvm_libc::fputil::MantissaWidth<T>; using MantissaWidth = __llvm_libc::fputil::MantissaWidth<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPBits::UIntType;
static constexpr int bitWidthOfType = static constexpr int BIT_WIDTH_OF_TYPE =
__llvm_libc::fputil::FloatProperties<T>::BIT_WIDTH; __llvm_libc::fputil::FloatProperties<T>::BIT_WIDTH;
const T zero = T(FPBits::zero()); const T zero = T(FPBits::zero());
const T neg_zero = T(FPBits::neg_zero()); const T neg_zero = T(FPBits::neg_zero());
const T inf = T(FPBits::inf()); const T inf = T(FPBits::inf());
const T neg_inf = T(FPBits::neg_inf()); const T neg_inf = T(FPBits::neg_inf());
const T nan = T(FPBits::build_nan(1)); const T nan = T(FPBits::build_nan(1));
const UIntType MIN_SUBNORMAL = FPBits::MIN_SUBNORMAL; const UIntType min_subnormal = FPBits::MIN_SUBNORMAL;
const UIntType MAX_SUBNORMAL = FPBits::MAX_SUBNORMAL; const UIntType max_subnormal = FPBits::MAX_SUBNORMAL;
const UIntType MIN_NORMAL = FPBits::MIN_NORMAL; const UIntType min_normal = FPBits::MIN_NORMAL;
const UIntType MAX_NORMAL = FPBits::MAX_NORMAL; const UIntType max_normal = FPBits::MAX_NORMAL;
public: public:
typedef T (*NextAfterFunc)(T, T); typedef T (*NextAfterFunc)(T, T);
void testNaN(NextAfterFunc func) { void testNaN(NextAfterFunc func) {
ASSERT_FP_EQ(func(nan, 0), nan); ASSERT_FP_EQ(func(nan, 0), nan);
ASSERT_FP_EQ(func(0, nan), nan); ASSERT_FP_EQ(func(0, nan), nan);
} }
void testBoundaries(NextAfterFunc func) { void testBoundaries(NextAfterFunc func) {
ASSERT_FP_EQ(func(zero, neg_zero), neg_zero); ASSERT_FP_EQ(func(zero, neg_zero), neg_zero);
ASSERT_FP_EQ(func(neg_zero, zero), zero); ASSERT_FP_EQ(func(neg_zero, zero), zero);
// 'from' is zero|neg_zero. // 'from' is zero|neg_zero.
T x = zero; T x = zero;
T result = func(x, T(1)); T result = func(x, T(1));
UIntType expectedBits = 1; UIntType expected_bits = 1;
T expected = *reinterpret_cast<T *>(&expectedBits); T expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
result = func(x, T(-1)); result = func(x, T(-1));
expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + 1; expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + 1;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
x = neg_zero; x = neg_zero;
result = func(x, 1); result = func(x, 1);
expectedBits = 1; expected_bits = 1;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
result = func(x, -1); result = func(x, -1);
expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + 1; expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + 1;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
// 'from' is max subnormal value. // 'from' is max subnormal value.
x = *reinterpret_cast<const T *>(&MAX_SUBNORMAL); x = *reinterpret_cast<const T *>(&max_subnormal);
result = func(x, 1); result = func(x, 1);
expected = *reinterpret_cast<const T *>(&MIN_NORMAL); expected = *reinterpret_cast<const T *>(&min_normal);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
result = func(x, 0); result = func(x, 0);
expectedBits = MAX_SUBNORMAL - 1; expected_bits = max_subnormal - 1;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
x = -x; x = -x;
result = func(x, -1); result = func(x, -1);
expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MIN_NORMAL; expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + min_normal;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
result = func(x, 0); result = func(x, 0);
expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MAX_SUBNORMAL - 1; expected_bits =
expected = *reinterpret_cast<T *>(&expectedBits); (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + max_subnormal - 1;
expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
// 'from' is min subnormal value. // 'from' is min subnormal value.
x = *reinterpret_cast<const T *>(&MIN_SUBNORMAL); x = *reinterpret_cast<const T *>(&min_subnormal);
result = func(x, 1); result = func(x, 1);
expectedBits = MIN_SUBNORMAL + 1; expected_bits = min_subnormal + 1;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
ASSERT_FP_EQ(func(x, 0), 0); ASSERT_FP_EQ(func(x, 0), 0);
x = -x; x = -x;
result = func(x, -1); result = func(x, -1);
expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MIN_SUBNORMAL + 1; expected_bits =
expected = *reinterpret_cast<T *>(&expectedBits); (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + min_subnormal + 1;
expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
ASSERT_FP_EQ(func(x, 0), T(-0.0)); ASSERT_FP_EQ(func(x, 0), T(-0.0));
// 'from' is min normal. // 'from' is min normal.
x = *reinterpret_cast<const T *>(&MIN_NORMAL); x = *reinterpret_cast<const T *>(&min_normal);
result = func(x, 0); result = func(x, 0);
expectedBits = MAX_SUBNORMAL; expected_bits = max_subnormal;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
result = func(x, inf); result = func(x, inf);
expectedBits = MIN_NORMAL + 1; expected_bits = min_normal + 1;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
x = -x; x = -x;
result = func(x, 0); result = func(x, 0);
expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MAX_SUBNORMAL; expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + max_subnormal;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
result = func(x, -inf); result = func(x, -inf);
expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MIN_NORMAL + 1; expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + min_normal + 1;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
// 'from' is max normal and 'to' is infinity. // '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); result = func(x, inf);
ASSERT_FP_EQ(result, inf); ASSERT_FP_EQ(result, inf);
result = func(-x, -inf); result = func(-x, -inf);
ASSERT_FP_EQ(result, -inf); ASSERT_FP_EQ(result, -inf);
// 'from' is infinity. // 'from' is infinity.
x = inf; x = inf;
result = func(x, 0); result = func(x, 0);
expectedBits = MAX_NORMAL; expected_bits = max_normal;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
ASSERT_FP_EQ(func(x, inf), inf); ASSERT_FP_EQ(func(x, inf), inf);
x = neg_inf; x = neg_inf;
result = func(x, 0); result = func(x, 0);
expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MAX_NORMAL; expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + max_normal;
expected = *reinterpret_cast<T *>(&expectedBits); expected = *reinterpret_cast<T *>(&expected_bits);
ASSERT_FP_EQ(result, expected); ASSERT_FP_EQ(result, expected);
ASSERT_FP_EQ(func(x, neg_inf), neg_inf); ASSERT_FP_EQ(func(x, neg_inf), neg_inf);
// 'from' is a power of 2. // 'from' is a power of 2.
x = T(32.0); x = T(32.0);
result = func(x, 0); result = func(x, 0);
FPBits xBits = FPBits(x); FPBits x_bits = FPBits(x);
FPBits resultBits = FPBits(result); FPBits result_bits = FPBits(result);
ASSERT_EQ(resultBits.get_unbiased_exponent(), ASSERT_EQ(result_bits.get_unbiased_exponent(),
uint16_t(xBits.get_unbiased_exponent() - 1)); uint16_t(x_bits.get_unbiased_exponent() - 1));
ASSERT_EQ(resultBits.get_mantissa(), ASSERT_EQ(result_bits.get_mantissa(),
(UIntType(1) << MantissaWidth::VALUE) - 1); (UIntType(1) << MantissaWidth::VALUE) - 1);
result = func(x, T(33.0)); result = func(x, T(33.0));
resultBits = FPBits(result); result_bits = FPBits(result);
ASSERT_EQ(resultBits.get_unbiased_exponent(), ASSERT_EQ(result_bits.get_unbiased_exponent(),
xBits.get_unbiased_exponent()); x_bits.get_unbiased_exponent());
ASSERT_EQ(resultBits.get_mantissa(), xBits.get_mantissa() + UIntType(1)); ASSERT_EQ(result_bits.get_mantissa(), x_bits.get_mantissa() + UIntType(1));
x = -x; x = -x;
result = func(x, 0); result = func(x, 0);
resultBits = FPBits(result); result_bits = FPBits(result);
ASSERT_EQ(resultBits.get_unbiased_exponent(), ASSERT_EQ(result_bits.get_unbiased_exponent(),
uint16_t(xBits.get_unbiased_exponent() - 1)); uint16_t(x_bits.get_unbiased_exponent() - 1));
ASSERT_EQ(resultBits.get_mantissa(), ASSERT_EQ(result_bits.get_mantissa(),
(UIntType(1) << MantissaWidth::VALUE) - 1); (UIntType(1) << MantissaWidth::VALUE) - 1);
result = func(x, T(-33.0)); result = func(x, T(-33.0));
resultBits = FPBits(result); result_bits = FPBits(result);
ASSERT_EQ(resultBits.get_unbiased_exponent(), ASSERT_EQ(result_bits.get_unbiased_exponent(),
xBits.get_unbiased_exponent()); x_bits.get_unbiased_exponent());
ASSERT_EQ(resultBits.get_mantissa(), xBits.get_mantissa() + UIntType(1)); ASSERT_EQ(result_bits.get_mantissa(), x_bits.get_mantissa() + UIntType(1));
} }
}; };
#define LIST_NEXTAFTER_TESTS(T, func) \ #define LIST_NEXTAFTER_TESTS(T, func) \
using LlvmLibcNextAfterTest = NextAfterTestTemplate<T>; \ using LlvmLibcNextAfterTest = NextAfterTestTemplate<T>; \
TEST_F(LlvmLibcNextAfterTest, TestNaN) { testNaN(&func); } \ TEST_F(LlvmLibcNextAfterTest, TestNaN) { testNaN(&func); } \
TEST_F(LlvmLibcNextAfterTest, TestBoundaries) { testBoundaries(&func); } TEST_F(LlvmLibcNextAfterTest, TestBoundaries) { testBoundaries(&func); }
#endif // LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H #endif // LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H

libc/test/src/math/RIntTest.h

Show All 15 Lines
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <fenv.h> #include <fenv.h>
#include <math.h> #include <math.h>
#include <stdio.h> #include <stdio.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
static constexpr int roundingModes[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO, static constexpr int ROUNDING_MODES[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
FE_TONEAREST}; FE_TONEAREST};
template <typename T> template <typename T>
class RIntTestTemplate : public __llvm_libc::testing::Test { class RIntTestTemplate : public __llvm_libc::testing::Test {
public: public:
typedef T (*RIntFunc)(T); typedef T (*RIntFunc)(T);
private: private:
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPBits = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPBits::UIntType;
const T zero = T(FPBits::zero()); const T zero = T(FPBits::zero());
const T neg_zero = T(FPBits::neg_zero()); const T neg_zero = T(FPBits::neg_zero());
const T inf = T(FPBits::inf()); const T inf = T(FPBits::inf());
const T neg_inf = T(FPBits::neg_inf()); const T neg_inf = T(FPBits::neg_inf());
const T nan = T(FPBits::build_nan(1)); 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) { switch (mode) {
case FE_UPWARD: case FE_UPWARD:
return mpfr::RoundingMode::Upward; return mpfr::RoundingMode::Upward;
case FE_DOWNWARD: case FE_DOWNWARD:
return mpfr::RoundingMode::Downward; return mpfr::RoundingMode::Downward;
case FE_TOWARDZERO: case FE_TOWARDZERO:
return mpfr::RoundingMode::TowardZero; return mpfr::RoundingMode::TowardZero;
case FE_TONEAREST: case FE_TONEAREST:
return mpfr::RoundingMode::Nearest; return mpfr::RoundingMode::Nearest;
default: default:
__builtin_unreachable(); __builtin_unreachable();
} }
} }
public: public:
void testSpecialNumbers(RIntFunc func) { void testSpecialNumbers(RIntFunc func) {
for (int mode : roundingModes) { for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode); __llvm_libc::fputil::set_round(mode);
ASSERT_FP_EQ(inf, func(inf)); ASSERT_FP_EQ(inf, func(inf));
ASSERT_FP_EQ(neg_inf, func(neg_inf)); ASSERT_FP_EQ(neg_inf, func(neg_inf));
ASSERT_FP_EQ(nan, func(nan)); ASSERT_FP_EQ(nan, func(nan));
ASSERT_FP_EQ(zero, func(zero)); ASSERT_FP_EQ(zero, func(zero));
ASSERT_FP_EQ(neg_zero, func(neg_zero)); ASSERT_FP_EQ(neg_zero, func(neg_zero));
} }
} }
void testRoundNumbers(RIntFunc func) { void testRoundNumbers(RIntFunc func) {
for (int mode : roundingModes) { for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode); __llvm_libc::fputil::set_round(mode);
mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode); mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(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), mpfr_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), mpfr_mode));
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), mpfr_mode));
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), mpfr_mode));
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), mpfr_mode));
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), mpfr_mode));
} }
} }
void testFractions(RIntFunc func) { void testFractions(RIntFunc func) {
for (int mode : roundingModes) { for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode); __llvm_libc::fputil::set_round(mode);
mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode); mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(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), mpfr_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), mpfr_mode));
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), mpfr_mode));
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), mpfr_mode));
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), mpfr_mode));
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), mpfr_mode));
} }
} }
void testSubnormalRange(RIntFunc func) { void testSubnormalRange(RIntFunc func) {
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType step = constexpr UIntType STEP =
(FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count; (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL; for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL;
i += step) { i += STEP) {
T x = T(FPBits(i)); T x = T(FPBits(i));
for (int mode : roundingModes) { for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode); __llvm_libc::fputil::set_round(mode);
mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode); mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(mode);
ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfrMode)); ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfr_mode));
} }
} }
} }
void testNormalRange(RIntFunc func) { void testNormalRange(RIntFunc func) {
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count; constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += step) { for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += STEP) {
T x = T(FPBits(i)); T x = T(FPBits(i));
// In normal range on x86 platforms, the long double implicit 1 bit can be // In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. We will skip them. // zero making the numbers NaN. We will skip them.
if (isnan(x)) { if (isnan(x)) {
continue; continue;
} }
for (int mode : roundingModes) { for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode); __llvm_libc::fputil::set_round(mode);
mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode); mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(mode);
ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfrMode)); ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfr_mode));
} }
} }
} }
}; };
#define LIST_RINT_TESTS(F, func) \ #define LIST_RINT_TESTS(F, func) \
using LlvmLibcRIntTest = RIntTestTemplate<F>; \ using LlvmLibcRIntTest = RIntTestTemplate<F>; \
TEST_F(LlvmLibcRIntTest, specialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcRIntTest, specialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcRIntTest, RoundNumbers) { testRoundNumbers(&func); } \ TEST_F(LlvmLibcRIntTest, RoundNumbers) { testRoundNumbers(&func); } \
TEST_F(LlvmLibcRIntTest, Fractions) { testFractions(&func); } \ TEST_F(LlvmLibcRIntTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcRIntTest, SubnormalRange) { testSubnormalRange(&func); } \ TEST_F(LlvmLibcRIntTest, SubnormalRange) { testSubnormalRange(&func); } \
TEST_F(LlvmLibcRIntTest, NormalRange) { testNormalRange(&func); } TEST_F(LlvmLibcRIntTest, NormalRange) { testNormalRange(&func); }
#endif // LLVM_LIBC_TEST_SRC_MATH_RINTTEST_H #endif // LLVM_LIBC_TEST_SRC_MATH_RINTTEST_H

libc/test/src/math/RemQuoTest.h

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines void testEqualNumeratorAndDenominator(RemQuoFunc func) {
EXPECT_FP_EQ(func(-x, y, &q), neg_zero); EXPECT_FP_EQ(func(-x, y, &q), neg_zero);
EXPECT_EQ(q, -1); EXPECT_EQ(q, -1);
EXPECT_FP_EQ(func(-x, -y, &q), neg_zero); EXPECT_FP_EQ(func(-x, -y, &q), neg_zero);
EXPECT_EQ(q, 1); EXPECT_EQ(q, 1);
} }
void testSubnormalRange(RemQuoFunc func) { void testSubnormalRange(RemQuoFunc func) {
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType step = constexpr UIntType STEP =
(FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count; (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL; for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL;
v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_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)); T x = T(FPBits(v)), y = T(FPBits(w));
mpfr::BinaryOutput<T> result; mpfr::BinaryOutput<T> result;
mpfr::BinaryInput<T> input{x, y}; mpfr::BinaryInput<T> input{x, y};
result.f = func(x, y, &result.i); result.f = func(x, y, &result.i);
ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
} }
} }
void testNormalRange(RemQuoFunc func) { void testNormalRange(RemQuoFunc func) {
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count; constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL; for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_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)); T x = T(FPBits(v)), y = T(FPBits(w));
mpfr::BinaryOutput<T> result; mpfr::BinaryOutput<T> result;
mpfr::BinaryInput<T> input{x, y}; mpfr::BinaryInput<T> input{x, y};
result.f = func(x, y, &result.i); result.f = func(x, y, &result.i);
// In normal range on x86 platforms, the long double implicit 1 bit can be // In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. Hence we test for them separately. // zero making the numbers NaN. Hence we test for them separately.
if (isnan(x) || isnan(y)) { if (isnan(x) || isnan(y)) {
Show All 19 Lines

libc/test/src/math/RoundTest.h

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines void testFractions(RoundFunc func) {
EXPECT_FP_EQ(T(-11.0), func(T(-10.65))); EXPECT_FP_EQ(T(-11.0), func(T(-10.65)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.38))); EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38))); EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38)));
EXPECT_FP_EQ(T(1235.0), func(T(1234.96))); EXPECT_FP_EQ(T(1235.0), func(T(1234.96)));
EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96))); EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96)));
} }
void testRange(RoundFunc func) { void testRange(RoundFunc func) {
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, func(x), 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, func(x), 0.0);
} }
} }
}; };
#define LIST_ROUND_TESTS(T, func) \ #define LIST_ROUND_TESTS(T, func) \
using LlvmLibcRoundTest = RoundTest<T>; \ using LlvmLibcRoundTest = RoundTest<T>; \
TEST_F(LlvmLibcRoundTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcRoundTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcRoundTest, RoundedNubmers) { testRoundedNumbers(&func); } \ TEST_F(LlvmLibcRoundTest, RoundedNubmers) { testRoundedNumbers(&func); } \
TEST_F(LlvmLibcRoundTest, Fractions) { testFractions(&func); } \ TEST_F(LlvmLibcRoundTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcRoundTest, Range) { testRange(&func); } TEST_F(LlvmLibcRoundTest, Range) { testRange(&func); }

libc/test/src/math/RoundToIntegerTest.h

Show All 17 Lines
#include <errno.h> #include <errno.h>
#endif #endif
#if math_errhandling & MATH_ERREXCEPT #if math_errhandling & MATH_ERREXCEPT
#include "src/__support/FPUtil/FEnvUtils.h" #include "src/__support/FPUtil/FEnvUtils.h"
#endif #endif
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
static constexpr int roundingModes[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO, static constexpr int ROUNDING_MODES[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
FE_TONEAREST}; FE_TONEAREST};
template <typename F, typename I, bool TestModes = false> template <typename F, typename I, bool TestModes = false>
class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test { class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
public: public:
typedef I (*RoundToIntegerFunc)(F); typedef I (*RoundToIntegerFunc)(F);
private: private:
using FPBits = __llvm_libc::fputil::FPBits<F>; using FPBits = __llvm_libc::fputil::FPBits<F>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPBits::UIntType;
const F zero = F(__llvm_libc::fputil::FPBits<F>::zero()); const F zero = F(__llvm_libc::fputil::FPBits<F>::zero());
const F neg_zero = F(__llvm_libc::fputil::FPBits<F>::neg_zero()); const F neg_zero = F(__llvm_libc::fputil::FPBits<F>::neg_zero());
const F inf = F(__llvm_libc::fputil::FPBits<F>::inf()); const F inf = F(__llvm_libc::fputil::FPBits<F>::inf());
const F neg_inf = F(__llvm_libc::fputil::FPBits<F>::neg_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)); 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 INTEGER_MIN = I(1) << (sizeof(I) * 8 - 1);
static constexpr I IntegerMax = -(IntegerMin + 1); static constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
void testOneInput(RoundToIntegerFunc func, F input, I expected, void test_one_input(RoundToIntegerFunc func, F input, I expected,
bool expectError) { bool expectError) {
#if math_errhandling & MATH_ERRNO #if math_errhandling & MATH_ERRNO
errno = 0; errno = 0;
#endif #endif
#if math_errhandling & MATH_ERREXCEPT #if math_errhandling & MATH_ERREXCEPT
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT); __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
#endif #endif
ASSERT_EQ(func(input), expected); ASSERT_EQ(func(input), expected);
Show All 10 Lines#if math_errhandling & MATH_ERREXCEPT
ASSERT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT), 0); ASSERT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT), 0);
#endif #endif
#if math_errhandling & MATH_ERRNO #if math_errhandling & MATH_ERRNO
ASSERT_EQ(errno, 0); ASSERT_EQ(errno, 0);
#endif #endif
} }
} }
static inline mpfr::RoundingMode toMPFRRoundingMode(int mode) { static inline mpfr::RoundingMode to_mpfr_rounding_mode(int mode) {
switch (mode) { switch (mode) {
case FE_UPWARD: case FE_UPWARD:
return mpfr::RoundingMode::Upward; return mpfr::RoundingMode::Upward;
case FE_DOWNWARD: case FE_DOWNWARD:
return mpfr::RoundingMode::Downward; return mpfr::RoundingMode::Downward;
case FE_TOWARDZERO: case FE_TOWARDZERO:
return mpfr::RoundingMode::TowardZero; return mpfr::RoundingMode::TowardZero;
case FE_TONEAREST: case FE_TONEAREST:
return mpfr::RoundingMode::Nearest; return mpfr::RoundingMode::Nearest;
default: default:
__builtin_unreachable(); __builtin_unreachable();
} }
} }
public: public:
void SetUp() override { void SetUp() override {
#if math_errhandling & MATH_ERREXCEPT #if math_errhandling & MATH_ERREXCEPT
// We will disable all exceptions so that the test will not // We will disable all exceptions so that the test will not
// crash with SIGFPE. We can still use fetestexcept to check // crash with SIGFPE. We can still use fetestexcept to check
// if the appropriate flag was raised. // if the appropriate flag was raised.
__llvm_libc::fputil::disable_except(FE_ALL_EXCEPT); __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
#endif #endif
} }
void doInfinityAndNaNTest(RoundToIntegerFunc func) { void do_infinity_and_na_n_test(RoundToIntegerFunc func) {
testOneInput(func, inf, IntegerMax, true); test_one_input(func, inf, INTEGER_MAX, true);
testOneInput(func, neg_inf, IntegerMin, true); test_one_input(func, neg_inf, INTEGER_MIN, true);
testOneInput(func, nan, IntegerMax, true); test_one_input(func, nan, INTEGER_MAX, true);
} }
void testInfinityAndNaN(RoundToIntegerFunc func) { void testInfinityAndNaN(RoundToIntegerFunc func) {
if (TestModes) { if (TestModes) {
for (int mode : roundingModes) { for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode); __llvm_libc::fputil::set_round(mode);
doInfinityAndNaNTest(func); do_infinity_and_na_n_test(func);
} }
} else { } else {
doInfinityAndNaNTest(func); do_infinity_and_na_n_test(func);
} }
} }
void doRoundNumbersTest(RoundToIntegerFunc func) { void do_round_numbers_test(RoundToIntegerFunc func) {
testOneInput(func, zero, I(0), false); test_one_input(func, zero, I(0), false);
testOneInput(func, neg_zero, I(0), false); test_one_input(func, neg_zero, I(0), false);
testOneInput(func, F(1.0), I(1), false); test_one_input(func, F(1.0), I(1), false);
testOneInput(func, F(-1.0), I(-1), false); test_one_input(func, F(-1.0), I(-1), false);
testOneInput(func, F(10.0), I(10), false); test_one_input(func, F(10.0), I(10), false);
testOneInput(func, F(-10.0), I(-10), false); test_one_input(func, F(-10.0), I(-10), false);
testOneInput(func, F(1234.0), I(1234), false); test_one_input(func, F(1234.0), I(1234), false);
testOneInput(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 // The rest of this this function compares with an equivalent MPFR function
// which rounds floating point numbers to long values. There is no MPFR // which rounds floating point numbers to long values. There is no MPFR
// function to round to long long or wider integer values. So, we will // function to round to long long or wider integer values. So, we will
// the remaining tests only if the width of I less than equal to that of // the remaining tests only if the width of I less than equal to that of
// long. // long.
if (sizeof(I) > sizeof(long)) if (sizeof(I) > sizeof(long))
return; 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 // We start with 1.0 so that the implicit bit for x86 long doubles
// is set. // is set.
FPBits bits(F(1.0)); 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_sign(1);
bits.set_mantissa(0); bits.set_mantissa(0);
F x = F(bits); F x = F(bits);
long mpfrResult; long mpfr_result;
bool erangeflag = mpfr::RoundToLong(x, mpfrResult); bool erangeflag = mpfr::RoundToLong(x, mpfr_result);
ASSERT_FALSE(erangeflag); ASSERT_FALSE(erangeflag);
testOneInput(func, x, mpfrResult, false); test_one_input(func, x, mpfr_result, false);
} }
void testRoundNumbers(RoundToIntegerFunc func) { void testRoundNumbers(RoundToIntegerFunc func) {
if (TestModes) { if (TestModes) {
for (int mode : roundingModes) { for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode); __llvm_libc::fputil::set_round(mode);
doRoundNumbersTest(func); do_round_numbers_test(func);
} }
} else { } else {
doRoundNumbersTest(func); do_round_numbers_test(func);
} }
} }
void doFractionsTest(RoundToIntegerFunc func, int mode) { void do_fractions_test(RoundToIntegerFunc func, int mode) {
constexpr F fractions[] = {0.5, -0.5, 0.115, -0.115, 0.715, -0.715}; constexpr F FRACTIONS[] = {0.5, -0.5, 0.115, -0.115, 0.715, -0.715};
for (F x : fractions) { for (F x : FRACTIONS) {
long mpfrLongResult; long mpfr_long_result;
bool erangeflag; bool erangeflag;
if (TestModes) if (TestModes)
erangeflag = erangeflag =
mpfr::RoundToLong(x, toMPFRRoundingMode(mode), mpfrLongResult); mpfr::RoundToLong(x, to_mpfr_rounding_mode(mode), mpfr_long_result);
else else
erangeflag = mpfr::RoundToLong(x, mpfrLongResult); erangeflag = mpfr::RoundToLong(x, mpfr_long_result);
ASSERT_FALSE(erangeflag); ASSERT_FALSE(erangeflag);
I mpfrResult = mpfrLongResult; I mpfr_result = mpfr_long_result;
testOneInput(func, x, mpfrResult, false); test_one_input(func, x, mpfr_result, false);
} }
} }
void testFractions(RoundToIntegerFunc func) { void testFractions(RoundToIntegerFunc func) {
if (TestModes) { if (TestModes) {
for (int mode : roundingModes) { for (int mode : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(mode); __llvm_libc::fputil::set_round(mode);
doFractionsTest(func, mode); do_fractions_test(func, mode);
} }
} else { } else {
// Passing 0 for mode has no effect as it is not used in doFractionsTest // Passing 0 for mode has no effect as it is not used in doFractionsTest
// when `TestModes` is false; // when `TestModes` is false;
doFractionsTest(func, 0); do_fractions_test(func, 0);
} }
} }
void testIntegerOverflow(RoundToIntegerFunc func) { void testIntegerOverflow(RoundToIntegerFunc func) {
// This function compares with an equivalent MPFR function which rounds // This function compares with an equivalent MPFR function which rounds
// floating point numbers to long values. There is no MPFR function to // floating point numbers to long values. There is no MPFR function to
// round to long long or wider integer values. So, we will peform the // round to long long or wider integer values. So, we will peform the
// comparisons in this function only if the width of I less than equal to // comparisons in this function only if the width of I less than equal to
// that of long. // that of long.
if (sizeof(I) > sizeof(long)) if (sizeof(I) > sizeof(long))
return; 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 // We start with 1.0 so that the implicit bit for x86 long doubles
// is set. // is set.
FPBits bits(F(1.0)); 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_sign(1);
bits.set_mantissa(UIntType(0x1) bits.set_mantissa(UIntType(0x1)
<< (__llvm_libc::fputil::MantissaWidth<F>::VALUE - 1)); << (__llvm_libc::fputil::MantissaWidth<F>::VALUE - 1));
F x = F(bits); F x = F(bits);
if (TestModes) { if (TestModes) {
for (int m : roundingModes) { for (int m : ROUNDING_MODES) {
__llvm_libc::fputil::set_round(m); __llvm_libc::fputil::set_round(m);
long mpfrLongResult; long mpfr_long_result;
bool erangeflag = bool erangeflag =
mpfr::RoundToLong(x, toMPFRRoundingMode(m), mpfrLongResult); mpfr::RoundToLong(x, to_mpfr_rounding_mode(m), mpfr_long_result);
ASSERT_TRUE(erangeflag); ASSERT_TRUE(erangeflag);
testOneInput(func, x, IntegerMin, true); test_one_input(func, x, INTEGER_MIN, true);
} }
} else { } else {
long mpfrLongResult; long mpfr_long_result;
bool erangeflag = mpfr::RoundToLong(x, mpfrLongResult); bool erangeflag = mpfr::RoundToLong(x, mpfr_long_result);
ASSERT_TRUE(erangeflag); ASSERT_TRUE(erangeflag);
testOneInput(func, x, IntegerMin, true); test_one_input(func, x, INTEGER_MIN, true);
} }
} }
void testSubnormalRange(RoundToIntegerFunc func) { void testSubnormalRange(RoundToIntegerFunc func) {
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType step = constexpr UIntType STEP =
(FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count; (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL; for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL;
i += step) { i += STEP) {
F x = F(FPBits(i)); F x = F(FPBits(i));
if (x == F(0.0)) if (x == F(0.0))
continue; continue;
// All subnormal numbers should round to zero. // All subnormal numbers should round to zero.
if (TestModes) { if (TestModes) {
if (x > 0) { if (x > 0) {
__llvm_libc::fputil::set_round(FE_UPWARD); __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); __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); __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); __llvm_libc::fputil::set_round(FE_TONEAREST);
testOneInput(func, x, I(0), false); test_one_input(func, x, I(0), false);
} else { } else {
__llvm_libc::fputil::set_round(FE_UPWARD); __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); __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); __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); __llvm_libc::fputil::set_round(FE_TONEAREST);
testOneInput(func, x, I(0), false); test_one_input(func, x, I(0), false);
} }
} else { } else {
testOneInput(func, x, 0L, false); test_one_input(func, x, 0L, false);
} }
} }
} }
void testNormalRange(RoundToIntegerFunc func) { void testNormalRange(RoundToIntegerFunc func) {
// This function compares with an equivalent MPFR function which rounds // This function compares with an equivalent MPFR function which rounds
// floating point numbers to long values. There is no MPFR function to // floating point numbers to long values. There is no MPFR function to
// round to long long or wider integer values. So, we will peform the // round to long long or wider integer values. So, we will peform the
// comparisons in this function only if the width of I less than equal to // comparisons in this function only if the width of I less than equal to
// that of long. // that of long.
if (sizeof(I) > sizeof(long)) if (sizeof(I) > sizeof(long))
return; return;
constexpr UIntType count = 1000001; constexpr UIntType COUNT = 1000001;
constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count; constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += step) { for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += STEP) {
F x = F(FPBits(i)); F x = F(FPBits(i));
// In normal range on x86 platforms, the long double implicit 1 bit can be // In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. We will skip them. // zero making the numbers NaN. We will skip them.
if (isnan(x)) { if (isnan(x)) {
continue; continue;
} }
if (TestModes) { if (TestModes) {
for (int m : roundingModes) { for (int m : ROUNDING_MODES) {
long mpfrLongResult; long mpfr_long_result;
bool erangeflag = bool erangeflag =
mpfr::RoundToLong(x, toMPFRRoundingMode(m), mpfrLongResult); mpfr::RoundToLong(x, to_mpfr_rounding_mode(m), mpfr_long_result);
I mpfrResult = mpfrLongResult; I mpfr_result = mpfr_long_result;
__llvm_libc::fputil::set_round(m); __llvm_libc::fputil::set_round(m);
if (erangeflag) if (erangeflag)
testOneInput(func, x, x > 0 ? IntegerMax : IntegerMin, true); test_one_input(func, x, x > 0 ? INTEGER_MAX : INTEGER_MIN, true);
else else
testOneInput(func, x, mpfrResult, false); test_one_input(func, x, mpfr_result, false);
} }
} else { } else {
long mpfrLongResult; long mpfr_long_result;
bool erangeflag = mpfr::RoundToLong(x, mpfrLongResult); bool erangeflag = mpfr::RoundToLong(x, mpfr_long_result);
I mpfrResult = mpfrLongResult; I mpfr_result = mpfr_long_result;
if (erangeflag) if (erangeflag)
testOneInput(func, x, x > 0 ? IntegerMax : IntegerMin, true); test_one_input(func, x, x > 0 ? INTEGER_MAX : INTEGER_MIN, true);
else else
testOneInput(func, x, mpfrResult, false); test_one_input(func, x, mpfr_result, false);
} }
} }
} }
}; };
#define LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, I, func, TestModes) \ #define LIST_ROUND_TO_INTEGER_TESTS_HELPER(F, I, func, TestModes) \
using LlvmLibcRoundToIntegerTest = \ using LlvmLibcRoundToIntegerTest = \
RoundToIntegerTestTemplate<F, I, TestModes>; \ RoundToIntegerTestTemplate<F, I, TestModes>; \
Show All 22 Lines

libc/test/src/math/SqrtTest.h

Show All 12 Lines
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class SqrtTest : public __llvm_libc::testing::Test { template <typename T> class SqrtTest : public __llvm_libc::testing::Test {
DECLARE_SPECIAL_CONSTANTS(T) DECLARE_SPECIAL_CONSTANTS(T)
static constexpr UIntType HiddenBit = static constexpr UIntType HIDDEN_BIT =
UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE; UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE;
public: public:
typedef T (*SqrtFunc)(T); typedef T (*SqrtFunc)(T);
void testSpecialNumbers(SqrtFunc func) { void testSpecialNumbers(SqrtFunc func) {
ASSERT_FP_EQ(aNaN, func(aNaN)); ASSERT_FP_EQ(aNaN, func(aNaN));
ASSERT_FP_EQ(inf, func(inf)); ASSERT_FP_EQ(inf, func(inf));
ASSERT_FP_EQ(aNaN, func(neg_inf)); ASSERT_FP_EQ(aNaN, func(neg_inf));
ASSERT_FP_EQ(0.0, func(0.0)); ASSERT_FP_EQ(0.0, func(0.0));
ASSERT_FP_EQ(-0.0, func(-0.0)); ASSERT_FP_EQ(-0.0, func(-0.0));
ASSERT_FP_EQ(aNaN, func(T(-1.0))); ASSERT_FP_EQ(aNaN, func(T(-1.0)));
ASSERT_FP_EQ(T(1.0), func(T(1.0))); ASSERT_FP_EQ(T(1.0), func(T(1.0)));
ASSERT_FP_EQ(T(2.0), func(T(4.0))); ASSERT_FP_EQ(T(2.0), func(T(4.0)));
ASSERT_FP_EQ(T(3.0), func(T(9.0))); ASSERT_FP_EQ(T(3.0), func(T(9.0)));
} }
void testDenormalValues(SqrtFunc func) { 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)); FPBits denormal(T(0.0));
denormal.set_mantissa(mant); denormal.set_mantissa(mant);
ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, T(denormal), func(T(denormal)), ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, T(denormal), func(T(denormal)),
T(0.5)); T(0.5));
} }
constexpr UIntType count = 1'000'001; constexpr UIntType COUNT = 1'000'001;
constexpr UIntType step = HiddenBit / count; constexpr UIntType STEP = HIDDEN_BIT / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = *reinterpret_cast<T *>(&v); T x = *reinterpret_cast<T *>(&v);
ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5);
} }
} }
void testNormalRange(SqrtFunc func) { void testNormalRange(SqrtFunc func) {
constexpr UIntType count = 10'000'001; constexpr UIntType COUNT = 10'000'001;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = *reinterpret_cast<T *>(&v); T x = *reinterpret_cast<T *>(&v);
if (isnan(x) || (x < 0)) { if (isnan(x) || (x < 0)) {
continue; continue;
} }
ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, func(x), 0.5);
} }
} }
}; };
#define LIST_SQRT_TESTS(T, func) \ #define LIST_SQRT_TESTS(T, func) \
using LlvmLibcSqrtTest = SqrtTest<T>; \ using LlvmLibcSqrtTest = SqrtTest<T>; \
TEST_F(LlvmLibcSqrtTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcSqrtTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcSqrtTest, DenormalValues) { testDenormalValues(&func); } \ TEST_F(LlvmLibcSqrtTest, DenormalValues) { testDenormalValues(&func); } \
TEST_F(LlvmLibcSqrtTest, NormalRange) { testNormalRange(&func); } TEST_F(LlvmLibcSqrtTest, NormalRange) { testNormalRange(&func); }

libc/test/src/math/TruncTest.h

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines void testFractions(TruncFunc func) {
EXPECT_FP_EQ(T(-10.0), func(T(-10.65))); EXPECT_FP_EQ(T(-10.0), func(T(-10.65)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.38))); EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38))); EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.96))); EXPECT_FP_EQ(T(1234.0), func(T(1234.96)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96))); EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96)));
} }
void testRange(TruncFunc func) { void testRange(TruncFunc func) {
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
T x = T(FPBits(v)); T x = T(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, func(x), 0.0); ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, func(x), 0.0);
} }
} }
}; };
#define LIST_TRUNC_TESTS(T, func) \ #define LIST_TRUNC_TESTS(T, func) \
using LlvmLibcTruncTest = TruncTest<T>; \ using LlvmLibcTruncTest = TruncTest<T>; \
TEST_F(LlvmLibcTruncTest, SpecialNumbers) { testSpecialNumbers(&func); } \ TEST_F(LlvmLibcTruncTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcTruncTest, RoundedNubmers) { testRoundedNumbers(&func); } \ TEST_F(LlvmLibcTruncTest, RoundedNubmers) { testRoundedNumbers(&func); } \
TEST_F(LlvmLibcTruncTest, Fractions) { testFractions(&func); } \ TEST_F(LlvmLibcTruncTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcTruncTest, Range) { testRange(&func); } TEST_F(LlvmLibcTruncTest, Range) { testRange(&func); }

libc/test/src/math/cos_test.cpp

Show All 13 Lines
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibccosTest, Range) { TEST(LlvmLibccosTest, Range) {
static constexpr double _2pi = 6.283185307179586; static constexpr double _2pi = 6.283185307179586;
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
double x = double(FPBits(v)); double x = double(FPBits(v));
// TODO: Expand the range of testing after range reduction is implemented. // TODO: Expand the range of testing after range reduction is implemented.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi) if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cos(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cos(x), 1.0);
} }
} }

libc/test/src/math/cosf_test.cpp

Show All 12 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::sdcomp26094Values; using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcCosfTest, SpecialNumbers) { TEST(LlvmLibcCosfTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 12 LinesTEST(LlvmLibcCosfTest, SpecialNumbers) {
EXPECT_EQ(errno, EDOM); EXPECT_EQ(errno, EDOM);
errno = 0; errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(neg_inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(neg_inf));
EXPECT_EQ(errno, EDOM); EXPECT_EQ(errno, EDOM);
} }
TEST(LlvmLibcCosfTest, InFloatRange) { TEST(LlvmLibcCosfTest, InFloatRange) {
constexpr uint32_t count = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t step = UINT32_MAX / count; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), 1.0);
} }
} }
// For small values, cos(x) is 1. // For small values, cos(x) is 1.
TEST(LlvmLibcCosfTest, SmallValues) { TEST(LlvmLibcCosfTest, SmallValues) {
float x = float(FPBits(0x17800000U)); float x = float(FPBits(0x17800000U));
float result = __llvm_libc::cosf(x); float result = __llvm_libc::cosf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, result, 1.0); EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, result, 1.0);
EXPECT_FP_EQ(1.0f, result); EXPECT_FP_EQ(1.0f, result);
x = float(FPBits(0x0040000U)); x = float(FPBits(0x0040000U));
result = __llvm_libc::cosf(x); result = __llvm_libc::cosf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, result, 1.0); EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, result, 1.0);
EXPECT_FP_EQ(1.0f, result); EXPECT_FP_EQ(1.0f, result);
} }
// SDCOMP-26094: check cosf in the cases for which the range reducer // SDCOMP-26094: check cosf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4. // returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcCosfTest, SDCOMP_26094) { TEST(LlvmLibcCosfTest, SDCOMP_26094) {
for (uint32_t v : sdcomp26094Values) { for (uint32_t v : SDCOMP26094_VALUES) {
float x = float(FPBits(v)); float x = float(FPBits(v));
ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), 1.0);
} }
} }

libc/test/src/math/exp2f_test.cpp

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 LinesTEST(LlvmLibcExpfTest, Underflow) {
errno = 0; errno = 0;
x = float(FPBits(0xc3165432U)); x = float(FPBits(0xc3165432U));
EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0); EXPECT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0);
EXPECT_EQ(errno, ERANGE); EXPECT_EQ(errno, ERANGE);
} }
TEST(LlvmLibcexp2fTest, InFloatRange) { TEST(LlvmLibcexp2fTest, InFloatRange) {
constexpr uint32_t count = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t step = UINT32_MAX / count; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::exp2f(x); float result = __llvm_libc::exp2f(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Exp2, x, __llvm_libc::exp2f(x), 1.0);
} }
} }

libc/test/src/math/expf_test.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 LinesTEST(LlvmLibcExpfTest, Borderline) {
EXPECT_EQ(errno, 0); EXPECT_EQ(errno, 0);
x = float(FPBits(0xc2b00008U)); x = float(FPBits(0xc2b00008U));
ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), 1.0);
EXPECT_EQ(errno, 0); EXPECT_EQ(errno, 0);
} }
TEST(LlvmLibcExpfTest, InFloatRange) { TEST(LlvmLibcExpfTest, InFloatRange) {
constexpr uint32_t count = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t step = UINT32_MAX / count; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::expf(x); float result = __llvm_libc::expf(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), 1.0);
} }
} }

libc/test/src/math/expm1f_test.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 LinesTEST(LlvmLibcExpm1fTest, Borderline) {
EXPECT_EQ(errno, 0); EXPECT_EQ(errno, 0);
x = float(FPBits(0xc2b00008U)); x = float(FPBits(0xc2b00008U));
ASSERT_MPFR_MATCH(mpfr::Operation::Expm1, x, __llvm_libc::expm1f(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Expm1, x, __llvm_libc::expm1f(x), 1.0);
EXPECT_EQ(errno, 0); EXPECT_EQ(errno, 0);
} }
TEST(LlvmLibcExpm1fTest, InFloatRange) { TEST(LlvmLibcExpm1fTest, InFloatRange) {
constexpr uint32_t count = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t step = UINT32_MAX / count; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::expm1f(x); float result = __llvm_libc::expm1f(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Expm1, x, __llvm_libc::expm1f(x), 2.2); ASSERT_MPFR_MATCH(mpfr::Operation::Expm1, x, __llvm_libc::expm1f(x), 2.2);
} }
} }

libc/test/src/math/fdim_test.cpp

Show All 10 Lines
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/fdim.h" #include "src/math/fdim.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
using LlvmLibcFDimTest = FDimTestTemplate<double>; 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) { TEST_F(LlvmLibcFDimTest, InDoubleRange_fdim) {
testInRange(&__llvm_libc::fdim); test_in_range(&__llvm_libc::fdim);
} }

libc/test/src/math/fdimf_test.cpp

Show All 10 Lines
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/fdimf.h" #include "src/math/fdimf.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
using LlvmLibcFDimTest = FDimTestTemplate<float>; 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) { 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) { TEST_F(LlvmLibcFDimTest, InFloatRange_fdimf) {
testInRange(&__llvm_libc::fdimf); test_in_range(&__llvm_libc::fdimf);
} }

libc/test/src/math/fdiml_test.cpp

Show All 10 Lines
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/math/fdiml.h" #include "src/math/fdiml.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
using LlvmLibcFDimTest = FDimTestTemplate<long double>; 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) { 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) { TEST_F(LlvmLibcFDimTest, InLongDoubleRange_fdiml) {
testInRange(&__llvm_libc::fdiml); test_in_range(&__llvm_libc::fdiml);
} }

libc/test/src/math/fma_test.cpp

//===-- Unittests for fma ------------------------------------------------===// //===-- Unittests for fma ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FmaTest.h" #include "FmaTest.h"
#include "src/math/fma.h" #include "src/math/fma.h"
using LlvmLibcFmaTest = FmaTestTemplate<double>; using LlvmLibcFmaTest = FmaTestTemplate<double>;
TEST_F(LlvmLibcFmaTest, SpecialNumbers) { TEST_F(LlvmLibcFmaTest, SpecialNumbers) {
testSpecialNumbers(&__llvm_libc::fma); test_special_numbers(&__llvm_libc::fma);
} }
TEST_F(LlvmLibcFmaTest, SubnormalRange) { 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); }

libc/test/src/math/fmaf_test.cpp

//===-- Unittests for fmaf ------------------------------------------------===// //===-- Unittests for fmaf ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FmaTest.h" #include "FmaTest.h"
#include "src/math/fmaf.h" #include "src/math/fmaf.h"
using LlvmLibcFmaTest = FmaTestTemplate<float>; using LlvmLibcFmaTest = FmaTestTemplate<float>;
TEST_F(LlvmLibcFmaTest, SpecialNumbers) { TEST_F(LlvmLibcFmaTest, SpecialNumbers) {
testSpecialNumbers(&__llvm_libc::fmaf); test_special_numbers(&__llvm_libc::fmaf);
} }
TEST_F(LlvmLibcFmaTest, SubnormalRange) { 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); }

libc/test/src/math/hypot_test.cpp

//===-- Unittests for hypot -----------------------------------------------===// //===-- Unittests for hypot -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "HypotTest.h" #include "HypotTest.h"
#include "src/math/hypot.h" #include "src/math/hypot.h"
using LlvmLibcHypotTest = HypotTestTemplate<double>; using LlvmLibcHypotTest = HypotTestTemplate<double>;
TEST_F(LlvmLibcHypotTest, SpecialNumbers) { TEST_F(LlvmLibcHypotTest, SpecialNumbers) {
testSpecialNumbers(&__llvm_libc::hypot); test_special_numbers(&__llvm_libc::hypot);
} }
TEST_F(LlvmLibcHypotTest, SubnormalRange) { 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);
}

libc/test/src/math/hypotf_test.cpp

//===-- Unittests for hypotf ----------------------------------------------===// //===-- Unittests for hypotf ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "HypotTest.h" #include "HypotTest.h"
#include "src/math/hypotf.h" #include "src/math/hypotf.h"
using LlvmLibcHypotfTest = HypotTestTemplate<float>; using LlvmLibcHypotfTest = HypotTestTemplate<float>;
TEST_F(LlvmLibcHypotfTest, SpecialNumbers) { TEST_F(LlvmLibcHypotfTest, SpecialNumbers) {
testSpecialNumbers(&__llvm_libc::hypotf); test_special_numbers(&__llvm_libc::hypotf);
} }
TEST_F(LlvmLibcHypotfTest, SubnormalRange) { TEST_F(LlvmLibcHypotfTest, SubnormalRange) {
testSubnormalRange(&__llvm_libc::hypotf); test_subnormal_range(&__llvm_libc::hypotf);
} }
TEST_F(LlvmLibcHypotfTest, NormalRange) { TEST_F(LlvmLibcHypotfTest, NormalRange) {
testNormalRange(&__llvm_libc::hypotf); test_normal_range(&__llvm_libc::hypotf);
} }

libc/test/src/math/ilogb_test.cpp

Show All 10 Lines
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/math/ilogb.h" #include "src/math/ilogb.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogb) { TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogb) {
testSpecialNumbers<double>(&__llvm_libc::ilogb); test_special_numbers<double>(&__llvm_libc::ilogb);
} }
TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogb) { TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogb) {
testPowersOfTwo<double>(&__llvm_libc::ilogb); test_powers_of_two<double>(&__llvm_libc::ilogb);
} }
TEST_F(LlvmLibcILogbTest, SomeIntegers_ilogb) { TEST_F(LlvmLibcILogbTest, SomeIntegers_ilogb) {
testSomeIntegers<double>(&__llvm_libc::ilogb); test_some_integers<double>(&__llvm_libc::ilogb);
} }
TEST_F(LlvmLibcILogbTest, SubnormalRange_ilogb) { TEST_F(LlvmLibcILogbTest, SubnormalRange_ilogb) {
testSubnormalRange<double>(&__llvm_libc::ilogb); test_subnormal_range<double>(&__llvm_libc::ilogb);
} }
TEST_F(LlvmLibcILogbTest, NormalRange_ilogb) { TEST_F(LlvmLibcILogbTest, NormalRange_ilogb) {
testNormalRange<double>(&__llvm_libc::ilogb); test_normal_range<double>(&__llvm_libc::ilogb);
} }

libc/test/src/math/ilogbf_test.cpp

Show All 10 Lines
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/math/ilogbf.h" #include "src/math/ilogbf.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbf) { TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbf) {
testSpecialNumbers<float>(&__llvm_libc::ilogbf); test_special_numbers<float>(&__llvm_libc::ilogbf);
} }
TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogbf) { TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogbf) {
testPowersOfTwo<float>(&__llvm_libc::ilogbf); test_powers_of_two<float>(&__llvm_libc::ilogbf);
} }
TEST_F(LlvmLibcILogbTest, SomeIntegers_ilogbf) { TEST_F(LlvmLibcILogbTest, SomeIntegers_ilogbf) {
testSomeIntegers<float>(&__llvm_libc::ilogbf); test_some_integers<float>(&__llvm_libc::ilogbf);
} }
TEST_F(LlvmLibcILogbTest, SubnormalRange_ilogbf) { TEST_F(LlvmLibcILogbTest, SubnormalRange_ilogbf) {
testSubnormalRange<float>(&__llvm_libc::ilogbf); test_subnormal_range<float>(&__llvm_libc::ilogbf);
} }
TEST_F(LlvmLibcILogbTest, NormalRange_ilogbf) { TEST_F(LlvmLibcILogbTest, NormalRange_ilogbf) {
testNormalRange<float>(&__llvm_libc::ilogbf); test_normal_range<float>(&__llvm_libc::ilogbf);
} }

libc/test/src/math/ilogbl_test.cpp

Show All 12 Lines
#include "src/math/ilogbl.h" #include "src/math/ilogbl.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
using RunContext = __llvm_libc::testing::RunContext; using RunContext = __llvm_libc::testing::RunContext;
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbl) { TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbl) {
testSpecialNumbers<long double>(&__llvm_libc::ilogbl); test_special_numbers<long double>(&__llvm_libc::ilogbl);
} }
TEST_F(LlvmLibcILogbTest, PowersOfTwo_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) { TEST_F(LlvmLibcILogbTest, SomeIntegers_ilogbl) {
testSomeIntegers<long double>(&__llvm_libc::ilogbl); test_some_integers<long double>(&__llvm_libc::ilogbl);
} }
TEST_F(LlvmLibcILogbTest, SubnormalRange_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) { TEST_F(LlvmLibcILogbTest, NormalRange_ilogbl) {
testNormalRange<long double>(&__llvm_libc::ilogbl); test_normal_range<long double>(&__llvm_libc::ilogbl);
} }

libc/test/src/math/logf_test.cpp

Show All 39 Lines constexpr uint32_t INPUTS[N] = {
0x4c5d65a5U, 0x4e85f412U, 0x65d890d3U, 0x6f31a8ecU}; 0x4c5d65a5U, 0x4e85f412U, 0x65d890d3U, 0x6f31a8ecU};
for (int i = 0; i < N; ++i) { for (int i = 0; i < N; ++i) {
float x = float(FPBits(INPUTS[i])); float x = float(FPBits(INPUTS[i]));
EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), 0.5); EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), 0.5);
} }
} }
TEST(LlvmLibcLogfTest, InFloatRange) { TEST(LlvmLibcLogfTest, InFloatRange) {
constexpr uint32_t count = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t step = UINT32_MAX / count; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
errno = 0; errno = 0;
float result = __llvm_libc::logf(x); float result = __llvm_libc::logf(x);
// If the computation resulted in an error or did not produce valid result // If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with // in the single-precision floating point range, then ignore comparing with
// MPFR result as MPFR can still produce valid results because of its // MPFR result as MPFR can still produce valid results because of its
// wider precision. // wider precision.
if (isnan(result) || isinf(result) || errno != 0) if (isnan(result) || isinf(result) || errno != 0)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), 0.5);
} }
} }

libc/test/src/math/sdcomp26094.h

Show All 10 Lines
#include "src/__support/CPP/Array.h" #include "src/__support/CPP/Array.h"
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
namespace testing { 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, 0x46427f1b, 0x4647e568, 0x46428bac, 0x4647f1f9, 0x4647fe8a,
0x45d8d7f1, 0x45d371a4, 0x45ce0b57, 0x45d35882, 0x45cdf235, 0x45d8d7f1, 0x45d371a4, 0x45ce0b57, 0x45d35882, 0x45cdf235,
}; };
} // namespace testing } // namespace testing
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_TEST_SRC_MATH_SDCOMP26094_H #endif // LLVM_LIBC_TEST_SRC_MATH_SDCOMP26094_H

libc/test/src/math/sin_test.cpp

Show All 14 Lines
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibcSinTest, Range) { TEST(LlvmLibcSinTest, Range) {
static constexpr double _2pi = 6.283185307179586; static constexpr double _2pi = 6.283185307179586;
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
double x = double(FPBits(v)); double x = double(FPBits(v));
// TODO: Expand the range of testing after range reduction is implemented. // TODO: Expand the range of testing after range reduction is implemented.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi) if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sin(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sin(x), 1.0);
} }
} }

libc/test/src/math/sincosf_test.cpp

Show All 12 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::sdcomp26094Values; using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcSinCosfTest, SpecialNumbers) { TEST(LlvmLibcSinCosfTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 23 LinesTEST(LlvmLibcSinCosfTest, SpecialNumbers) {
errno = 0; errno = 0;
__llvm_libc::sincosf(neg_inf, &sin, &cos); __llvm_libc::sincosf(neg_inf, &sin, &cos);
EXPECT_FP_EQ(aNaN, cos); EXPECT_FP_EQ(aNaN, cos);
EXPECT_FP_EQ(aNaN, sin); EXPECT_FP_EQ(aNaN, sin);
EXPECT_EQ(errno, EDOM); EXPECT_EQ(errno, EDOM);
} }
TEST(LlvmLibcSinCosfTest, InFloatRange) { TEST(LlvmLibcSinCosfTest, InFloatRange) {
constexpr uint32_t count = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t step = UINT32_MAX / count; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits((v))); float x = float(FPBits((v)));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
float sin, cos; float sin, cos;
__llvm_libc::sincosf(x, &sin, &cos); __llvm_libc::sincosf(x, &sin, &cos);
ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, cos, 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, cos, 1.0);
ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, sin, 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, sin, 1.0);
Show All 18 LinesTEST(LlvmLibcSinCosfTest, SmallValues) {
EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, result_sin, 1.0); EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, result_sin, 1.0);
EXPECT_FP_EQ(1.0f, result_cos); EXPECT_FP_EQ(1.0f, result_cos);
EXPECT_FP_EQ(x, result_sin); EXPECT_FP_EQ(x, result_sin);
} }
// SDCOMP-26094: check sinf in the cases for which the range reducer // SDCOMP-26094: check sinf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4. // returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcSinCosfTest, SDCOMP_26094) { TEST(LlvmLibcSinCosfTest, SDCOMP_26094) {
for (uint32_t v : sdcomp26094Values) { for (uint32_t v : SDCOMP26094_VALUES) {
float x = float(FPBits((v))); float x = float(FPBits((v)));
float sin, cos; float sin, cos;
__llvm_libc::sincosf(x, &sin, &cos); __llvm_libc::sincosf(x, &sin, &cos);
EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, cos, 1.0); EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, cos, 1.0);
EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, sin, 1.0); EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, sin, 1.0);
} }
} }

libc/test/src/math/sinf_test.cpp

Show All 12 Lines
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/FPMatcher.h" #include "utils/UnitTest/FPMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::sdcomp26094Values; using __llvm_libc::testing::SDCOMP26094_VALUES;
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float) DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcSinfTest, SpecialNumbers) { TEST(LlvmLibcSinfTest, SpecialNumbers) {
errno = 0; errno = 0;
Show All 12 LinesTEST(LlvmLibcSinfTest, SpecialNumbers) {
EXPECT_EQ(errno, EDOM); EXPECT_EQ(errno, EDOM);
errno = 0; errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(neg_inf)); EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(neg_inf));
EXPECT_EQ(errno, EDOM); EXPECT_EQ(errno, EDOM);
} }
TEST(LlvmLibcSinfTest, InFloatRange) { TEST(LlvmLibcSinfTest, InFloatRange) {
constexpr uint32_t count = 1000000; constexpr uint32_t COUNT = 1000000;
constexpr uint32_t step = UINT32_MAX / count; constexpr uint32_t STEP = UINT32_MAX / COUNT;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) { for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
float x = float(FPBits(v)); float x = float(FPBits(v));
if (isnan(x) || isinf(x)) if (isnan(x) || isinf(x))
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), 1.0);
} }
} }
TEST(LlvmLibcSinfTest, SpecificBitPatterns) { TEST(LlvmLibcSinfTest, SpecificBitPatterns) {
Show All 12 LinesTEST(LlvmLibcSinfTest, SmallValues) {
result = __llvm_libc::sinf(x); result = __llvm_libc::sinf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, result, 1.0); EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, result, 1.0);
EXPECT_FP_EQ(x, result); EXPECT_FP_EQ(x, result);
} }
// SDCOMP-26094: check sinf in the cases for which the range reducer // SDCOMP-26094: check sinf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4. // returns values furthest beyond its nominal upper bound of pi/4.
TEST(LlvmLibcSinfTest, SDCOMP_26094) { TEST(LlvmLibcSinfTest, SDCOMP_26094) {
for (uint32_t v : sdcomp26094Values) { for (uint32_t v : SDCOMP26094_VALUES) {
float x = float(FPBits((v))); float x = float(FPBits((v)));
EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), 1.0); EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), 1.0);
} }
} }

libc/test/src/math/tan_test.cpp

Show All 13 Lines
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibctanTest, Range) { TEST(LlvmLibctanTest, Range) {
static constexpr double _2pi = 6.283185307179586; static constexpr double _2pi = 6.283185307179586;
constexpr UIntType count = 10000000; constexpr UIntType COUNT = 10000000;
constexpr UIntType step = UIntType(-1) / count; constexpr UIntType STEP = UIntType(-1) / COUNT;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) { for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
double x = double(FPBits(v)); double x = double(FPBits(v));
// TODO: Expand the range of testing after range reduction is implemented. // TODO: Expand the range of testing after range reduction is implemented.
if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi) if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
continue; continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tan(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tan(x), 1.0);
} }
} }

libc/test/src/signal/sigprocmask_test.cpp

Show All 15 Lines
#include "test/ErrnoSetterMatcher.h" #include "test/ErrnoSetterMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
class LlvmLibcSignalTest : public __llvm_libc::testing::Test { class LlvmLibcSignalTest : public __llvm_libc::testing::Test {
sigset_t oldSet; sigset_t oldSet;
public: 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); __llvm_libc::sigprocmask(SIG_SETMASK, &oldSet, nullptr);
} }
}; };
using __llvm_libc::testing::ErrnoSetterMatcher::Fails; using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds; using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
// This tests for invalid input. // This tests for invalid input.
Show All 26 Lines

libc/test/src/stdlib/atof_test.cpp

Show All 12 Lines
#include <errno.h> #include <errno.h>
#include <limits.h> #include <limits.h>
#include <stddef.h> #include <stddef.h>
// This is just a simple test to make sure that this function works at all. It's // 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. // functionally identical to strtod so the bulk of the testing is there.
TEST(LlvmLibcAToFTest, SimpleTest) { TEST(LlvmLibcAToFTest, SimpleTest) {
__llvm_libc::fputil::FPBits<double> expectedFP = __llvm_libc::fputil::FPBits<double> expected_fp =
__llvm_libc::fputil::FPBits<double>(uint64_t(0x405ec00000000000)); __llvm_libc::fputil::FPBits<double>(uint64_t(0x405ec00000000000));
errno = 0; errno = 0;
double result = __llvm_libc::atof("123"); 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); __llvm_libc::fputil::FPBits<double>(result);
EXPECT_EQ(actualFP.bits, expectedFP.bits); EXPECT_EQ(actual_fp.bits, expected_fp.bits);
EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign()); EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent()); EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa()); EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
EXPECT_EQ(errno, 0); EXPECT_EQ(errno, 0);
} }
TEST(LlvmLibcAToFTest, FailedParsingTest) { TEST(LlvmLibcAToFTest, FailedParsingTest) {
__llvm_libc::fputil::FPBits<double> expectedFP = __llvm_libc::fputil::FPBits<double> expected_fp =
__llvm_libc::fputil::FPBits<double>(uint64_t(0)); __llvm_libc::fputil::FPBits<double>(uint64_t(0));
errno = 0; errno = 0;
double result = __llvm_libc::atof("???"); double result = __llvm_libc::atof("???");
__llvm_libc::fputil::FPBits<double> actualFP = __llvm_libc::fputil::FPBits<double> actual_fp =
__llvm_libc::fputil::FPBits<double>(result); __llvm_libc::fputil::FPBits<double>(result);
EXPECT_EQ(actualFP.bits, expectedFP.bits); EXPECT_EQ(actual_fp.bits, expected_fp.bits);
EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign()); EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent()); EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa()); EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
EXPECT_EQ(errno, 0); EXPECT_EQ(errno, 0);
} }

libc/test/src/stdlib/bsearch_test.cpp

Show All 29 LinesTEST(LlvmLibcBsearchTest, ErrorInputs) {
EXPECT_TRUE(__llvm_libc::bsearch(&val, nullptr, 1, sizeof(int), EXPECT_TRUE(__llvm_libc::bsearch(&val, nullptr, 1, sizeof(int),
int_compare) == nullptr); int_compare) == nullptr);
EXPECT_TRUE(__llvm_libc::bsearch(&val, &val, 0, sizeof(int), int_compare) == EXPECT_TRUE(__llvm_libc::bsearch(&val, &val, 0, sizeof(int), int_compare) ==
nullptr); nullptr);
EXPECT_TRUE(__llvm_libc::bsearch(&val, &val, 1, 0, int_compare) == nullptr); EXPECT_TRUE(__llvm_libc::bsearch(&val, &val, 1, 0, int_compare) == nullptr);
} }
TEST(LlvmLibcBsearchTest, IntegerArray) { 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, 100, 110, 123, 133, 135, 155, 170,
171, 1100, 1110, 1123, 1133, 1135, 1155, 171, 1100, 1110, 1123, 1133, 1135, 1155,
1170, 1171, 11100, 12310}; 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) { for (size_t i = 0; i < s; ++i) {
int key = array[i]; int key = ARRAY[i];
void *elem = 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); ASSERT_EQ(*reinterpret_cast<int *>(elem), key);
} }
} }
// Non existent keys // Non existent keys
for (size_t s = 1; s <= array_size; ++s) { for (size_t s = 1; s <= ARRAY_SIZE; ++s) {
int key = 5; 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); int_compare) == nullptr);
key = 125; 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); int_compare) == nullptr);
key = 136; 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); int_compare) == nullptr);
key = 12345; 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); int_compare) == nullptr);
} }
} }
TEST(LlvmLibcBsearchTest, SameKeyAndArray) { TEST(LlvmLibcBsearchTest, SameKeyAndArray) {
constexpr int array[5] = {1, 2, 3, 4, 5}; constexpr int ARRAY[5] = {1, 2, 3, 4, 5};
constexpr size_t array_size = sizeof(array) / sizeof(int); constexpr size_t ARRAY_SIZE = sizeof(ARRAY) / sizeof(int);
void *elem = void *elem =
__llvm_libc::bsearch(array, array, array_size, sizeof(int), int_compare); __llvm_libc::bsearch(ARRAY, ARRAY, ARRAY_SIZE, sizeof(int), int_compare);
EXPECT_EQ(*reinterpret_cast<int *>(elem), array[0]); EXPECT_EQ(*reinterpret_cast<int *>(elem), ARRAY[0]);
} }

libc/test/src/stdlib/qsort_test.cpp

Show All 21 Linesstatic int int_compare(const void *l, const void *r) {
else else
return -1; return -1;
} }
TEST(LlvmLibcQsortTest, SortedArray) { TEST(LlvmLibcQsortTest, SortedArray) {
int array[25] = {10, 23, 33, 35, 55, 70, 71, 100, 110, int array[25] = {10, 23, 33, 35, 55, 70, 71, 100, 110,
123, 133, 135, 155, 170, 171, 1100, 1110, 1123, 123, 133, 135, 155, 170, 171, 1100, 1110, 1123,
1133, 1135, 1155, 1170, 1171, 11100, 12310}; 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[0], 10);
ASSERT_LE(array[1], 23); ASSERT_LE(array[1], 23);
ASSERT_LE(array[2], 33); ASSERT_LE(array[2], 33);
ASSERT_LE(array[3], 35); ASSERT_LE(array[3], 35);
ASSERT_LE(array[4], 55); ASSERT_LE(array[4], 55);
ASSERT_LE(array[5], 70); ASSERT_LE(array[5], 70);
ASSERT_LE(array[6], 71); ASSERT_LE(array[6], 71);
Show All 15 LinesTEST(LlvmLibcQsortTest, SortedArray) {
ASSERT_LE(array[22], 1171); ASSERT_LE(array[22], 1171);
ASSERT_LE(array[23], 11100); ASSERT_LE(array[23], 11100);
ASSERT_LE(array[24], 12310); ASSERT_LE(array[24], 12310);
} }
TEST(LlvmLibcQsortTest, ReverseSortedArray) { TEST(LlvmLibcQsortTest, ReverseSortedArray) {
int array[25] = {25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 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}; 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); ASSERT_LE(array[i], i + 1);
} }
TEST(LlvmLibcQsortTest, AllEqualElements) { TEST(LlvmLibcQsortTest, AllEqualElements) {
int array[25] = {100, 100, 100, 100, 100, 100, 100, 100, 100, 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, 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); ASSERT_LE(array[i], 100);
} }
TEST(LlvmLibcQsortTest, UnsortedArray1) { TEST(LlvmLibcQsortTest, UnsortedArray1) {
int array[25] = {10, 23, 8, 35, 55, 45, 40, 100, 110, 123, 90, 80, 70, 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}; 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[0], -100);
ASSERT_LE(array[1], -10); ASSERT_LE(array[1], -10);
ASSERT_LE(array[2], -5); ASSERT_LE(array[2], -5);
ASSERT_LE(array[3], -1); ASSERT_LE(array[3], -1);
ASSERT_LE(array[4], 1); ASSERT_LE(array[4], 1);
ASSERT_LE(array[5], 8); ASSERT_LE(array[5], 8);
ASSERT_LE(array[6], 10); ASSERT_LE(array[6], 10);
Show All 14 LinesTEST(LlvmLibcQsortTest, UnsortedArray1) {
ASSERT_LE(array[21], 171); ASSERT_LE(array[21], 171);
ASSERT_LE(array[22], 1155); ASSERT_LE(array[22], 1155);
ASSERT_LE(array[23], 1170); ASSERT_LE(array[23], 1170);
ASSERT_LE(array[24], 1171); ASSERT_LE(array[24], 1171);
} }
TEST(LlvmLibcQsortTest, UnsortedArray2) { TEST(LlvmLibcQsortTest, UnsortedArray2) {
int array[7] = {10, 40, 45, 55, 35, 23, 60}; 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[0], 10);
ASSERT_LE(array[1], 23); ASSERT_LE(array[1], 23);
ASSERT_LE(array[2], 35); ASSERT_LE(array[2], 35);
ASSERT_LE(array[3], 40); ASSERT_LE(array[3], 40);
ASSERT_LE(array[4], 45); ASSERT_LE(array[4], 45);
ASSERT_LE(array[5], 55); ASSERT_LE(array[5], 55);
ASSERT_LE(array[6], 60); ASSERT_LE(array[6], 60);
} }
TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements1) { TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements1) {
int array[6] = {10, 10, 20, 20, 5, 5}; 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[0], 5);
ASSERT_LE(array[1], 5); ASSERT_LE(array[1], 5);
ASSERT_LE(array[2], 10); ASSERT_LE(array[2], 10);
ASSERT_LE(array[3], 10); ASSERT_LE(array[3], 10);
ASSERT_LE(array[4], 20); ASSERT_LE(array[4], 20);
ASSERT_LE(array[5], 20); ASSERT_LE(array[5], 20);
} }
TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements2) { TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements2) {
int array[10] = {20, 10, 10, 10, 10, 20, 21, 21, 21, 21}; 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[0], 10);
ASSERT_LE(array[1], 10); ASSERT_LE(array[1], 10);
ASSERT_LE(array[2], 10); ASSERT_LE(array[2], 10);
ASSERT_LE(array[3], 10); ASSERT_LE(array[3], 10);
ASSERT_LE(array[4], 20); ASSERT_LE(array[4], 20);
ASSERT_LE(array[5], 20); ASSERT_LE(array[5], 20);
ASSERT_LE(array[6], 21); ASSERT_LE(array[6], 21);
ASSERT_LE(array[7], 21); ASSERT_LE(array[7], 21);
ASSERT_LE(array[8], 21); ASSERT_LE(array[8], 21);
ASSERT_LE(array[9], 21); ASSERT_LE(array[9], 21);
} }
TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements3) { TEST(LlvmLibcQsortTest, UnsortedArrayDuplicateElements3) {
int array[10] = {20, 30, 30, 30, 30, 20, 21, 21, 21, 21}; 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[0], 20);
ASSERT_LE(array[1], 20); ASSERT_LE(array[1], 20);
ASSERT_LE(array[2], 21); ASSERT_LE(array[2], 21);
ASSERT_LE(array[3], 21); ASSERT_LE(array[3], 21);
ASSERT_LE(array[4], 21); ASSERT_LE(array[4], 21);
ASSERT_LE(array[5], 21); ASSERT_LE(array[5], 21);
ASSERT_LE(array[6], 30); ASSERT_LE(array[6], 30);
ASSERT_LE(array[7], 30); ASSERT_LE(array[7], 30);
ASSERT_LE(array[8], 30); ASSERT_LE(array[8], 30);
ASSERT_LE(array[9], 30); ASSERT_LE(array[9], 30);
} }
TEST(LlvmLibcQsortTest, UnsortedThreeElementArray1) { TEST(LlvmLibcQsortTest, UnsortedThreeElementArray1) {
int array[3] = {14999024, 0, 3}; 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[0], 0);
ASSERT_LE(array[1], 3); ASSERT_LE(array[1], 3);
ASSERT_LE(array[2], 14999024); ASSERT_LE(array[2], 14999024);
} }
TEST(LlvmLibcQsortTest, UnsortedThreeElementArray2) { TEST(LlvmLibcQsortTest, UnsortedThreeElementArray2) {
int array[3] = {3, 14999024, 0}; 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[0], 0);
ASSERT_LE(array[1], 3); ASSERT_LE(array[1], 3);
ASSERT_LE(array[2], 14999024); ASSERT_LE(array[2], 14999024);
} }
TEST(LlvmLibcQsortTest, UnsortedThreeElementArray3) { TEST(LlvmLibcQsortTest, UnsortedThreeElementArray3) {
int array[3] = {3, 0, 14999024}; 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[0], 0);
ASSERT_LE(array[1], 3); ASSERT_LE(array[1], 3);
ASSERT_LE(array[2], 14999024); ASSERT_LE(array[2], 14999024);
} }
TEST(LlvmLibcQsortTest, SameElementThreeElementArray) { TEST(LlvmLibcQsortTest, SameElementThreeElementArray) {
int array[3] = {12345, 12345, 12345}; 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[0], 12345);
ASSERT_LE(array[1], 12345); ASSERT_LE(array[1], 12345);
ASSERT_LE(array[2], 12345); ASSERT_LE(array[2], 12345);
} }
TEST(LlvmLibcQsortTest, UnsortedTwoElementArray1) { TEST(LlvmLibcQsortTest, UnsortedTwoElementArray1) {
int array[2] = {14999024, 0}; 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[0], 0);
ASSERT_LE(array[1], 14999024); ASSERT_LE(array[1], 14999024);
} }
TEST(LlvmLibcQsortTest, UnsortedTwoElementArray2) { TEST(LlvmLibcQsortTest, UnsortedTwoElementArray2) {
int array[2] = {0, 14999024}; 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[0], 0);
ASSERT_LE(array[1], 14999024); ASSERT_LE(array[1], 14999024);
} }
TEST(LlvmLibcQsortTest, SameElementTwoElementArray) { TEST(LlvmLibcQsortTest, SameElementTwoElementArray) {
int array[2] = {12345, 12345}; 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[0], 12345);
ASSERT_LE(array[1], 12345); ASSERT_LE(array[1], 12345);
} }
TEST(LlvmLibcQSortTest, SingleElementArray) { TEST(LlvmLibcQSortTest, SingleElementArray) {
constexpr int elem = 12345; constexpr int ELEM = 12345;
int array[1] = {elem}; int array[1] = {ELEM};
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], elem); ASSERT_LE(array[0], ELEM);
} }

libc/test/src/stdlib/strtod_test.cpp

Show All 11 Lines
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <errno.h> #include <errno.h>
#include <limits.h> #include <limits.h>
#include <stddef.h> #include <stddef.h>
class LlvmLibcStrToDTest : public __llvm_libc::testing::Test { class LlvmLibcStrToDTest : public __llvm_libc::testing::Test {
public: public:
void runTest(const char *inputString, const ptrdiff_t expectedStrLen, void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
const uint64_t expectedRawData, const int expectedErrno = 0) { const uint64_t expectedRawData, const int expectedErrno = 0) {
// expectedRawData is the expected double result as a uint64_t, organized // expectedRawData is the expected double result as a uint64_t, organized
// according to IEEE754: // according to IEEE754:
// //
// +-- 1 Sign Bit +-- 52 Mantissa bits // +-- 1 Sign Bit +-- 52 Mantissa bits
// | | // | |
// | +-------------------------+------------------------+ // | +-------------------------+------------------------+
// | | | // | | |
// SEEEEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM // SEEEEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
// | | // | |
// +----+----+ // +----+----+
// | // |
// +-- 11 Exponent Bits // +-- 11 Exponent Bits
// //
// This is so that the result can be compared in parts. // 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); __llvm_libc::fputil::FPBits<double>(expectedRawData);
errno = 0; 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); __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(actual_fp.bits, expected_fp.bits);
EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign()); EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent()); EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa()); EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
EXPECT_EQ(errno, expectedErrno); EXPECT_EQ(errno, expectedErrno);
} }
}; };
TEST_F(LlvmLibcStrToDTest, SimpleTest) { 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 // This should fail on Eisel-Lemire, forcing a fallback to simple decimal
// conversion. // conversion.
runTest("12345678901234549760", 20, uint64_t(0x43e56a95319d63d8)); run_test("12345678901234549760", 20, uint64_t(0x43e56a95319d63d8));
// Found while looking for difficult test cases here: // Found while looking for difficult test cases here:
// https://github.com/nigeltao/parse-number-fxx-test-data/blob/main/more-test-cases/golang-org-issue-36657.txt // 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. // These are tests that have caused problems in the past.
TEST_F(LlvmLibcStrToDTest, SpecificFailures) { TEST_F(LlvmLibcStrToDTest, SpecificFailures) {
runTest("3E70000000000000", 16, uint64_t(0x7FF0000000000000), ERANGE); run_test("3E70000000000000", 16, uint64_t(0x7FF0000000000000), ERANGE);
runTest("358416272e-33", 13, uint64_t(0x3adbbb2a68c9d0b9)); run_test("358416272e-33", 13, uint64_t(0x3adbbb2a68c9d0b9));
runTest("2.16656806400000023841857910156251e9", 36, run_test("2.16656806400000023841857910156251e9", 36,
uint64_t(0x41e0246690000001)); uint64_t(0x41e0246690000001));
runTest("27949676547093071875", 20, uint64_t(0x43f83e132bc608c9)); run_test("27949676547093071875", 20, uint64_t(0x43f83e132bc608c9));
} }
TEST_F(LlvmLibcStrToDTest, FuzzFailures) { TEST_F(LlvmLibcStrToDTest, FuzzFailures) {
runTest("-\xff\xff\xff\xff\xff\xff\xff\x01", 0, uint64_t(0)); run_test("-\xff\xff\xff\xff\xff\xff\xff\x01", 0, uint64_t(0));
runTest("-.????", 0, uint64_t(0)); run_test("-.????", 0, uint64_t(0));
runTest("44444444444444444444444444444444444444444444444444A44444444444444444" run_test(
"44444444444444444444444444444444444444444444444444A44444444444444444"
"44444444444*\x99\xff\xff\xff\xff", "44444444444*\x99\xff\xff\xff\xff",
50, uint64_t(0x4a3e68fdd0e0b2d8)); 50, uint64_t(0x4a3e68fdd0e0b2d8));
runTest("-NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKNNNNNNNNNNNNNNNNNN?" run_test("-NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKNNNNNNNNNNNNNNNNNN?"
"NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN?", "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN?",
0, uint64_t(0)); 0, uint64_t(0));
runTest("0x.666E40", 9, uint64_t(0x3fd99b9000000000)); run_test("0x.666E40", 9, uint64_t(0x3fd99b9000000000));
} }

libc/test/src/stdlib/strtof_test.cpp

Show All 11 Lines
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <errno.h> #include <errno.h>
#include <limits.h> #include <limits.h>
#include <stddef.h> #include <stddef.h>
class LlvmLibcStrToFTest : public __llvm_libc::testing::Test { class LlvmLibcStrToFTest : public __llvm_libc::testing::Test {
public: public:
void runTest(const char *inputString, const ptrdiff_t expectedStrLen, void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
const uint32_t expectedRawData, const int expectedErrno = 0) { const uint32_t expectedRawData, const int expectedErrno = 0) {
// expectedRawData is the expected float result as a uint32_t, organized // expectedRawData is the expected float result as a uint32_t, organized
// according to IEEE754: // according to IEEE754:
// //
// +-- 1 Sign Bit +-- 23 Mantissa bits // +-- 1 Sign Bit +-- 23 Mantissa bits
// | | // | |
// | +----------+----------+ // | +----------+----------+
// | | | // | | |
// SEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMM // SEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMM
// | | // | |
// +--+---+ // +--+---+
// | // |
// +-- 8 Exponent Bits // +-- 8 Exponent Bits
// //
// This is so that the result can be compared in parts. // 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); __llvm_libc::fputil::FPBits<float>(expectedRawData);
errno = 0; 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); __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(actual_fp.bits, expected_fp.bits);
EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign()); EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent()); EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa()); EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
EXPECT_EQ(errno, expectedErrno); EXPECT_EQ(errno, expectedErrno);
} }
}; };
// This is the set of tests that I have working (verified correct when compared // This is the set of tests that I have working (verified correct when compared
// to system libc). This is here so I don't break more things when I try to fix // to system libc). This is here so I don't break more things when I try to fix
// them. // them.
TEST_F(LlvmLibcStrToFTest, BasicDecimalTests) { TEST_F(LlvmLibcStrToFTest, BasicDecimalTests) {
runTest("1", 1, 0x3f800000); run_test("1", 1, 0x3f800000);
runTest("123", 3, 0x42f60000); run_test("123", 3, 0x42f60000);
runTest("1234567890", 10, 0x4e932c06u); run_test("1234567890", 10, 0x4e932c06u);
runTest("123456789012345678901", 21, 0x60d629d4); run_test("123456789012345678901", 21, 0x60d629d4);
runTest("0.1", 3, 0x3dcccccdu); run_test("0.1", 3, 0x3dcccccdu);
runTest(".1", 2, 0x3dcccccdu); run_test(".1", 2, 0x3dcccccdu);
runTest("-0.123456789", 12, 0xbdfcd6eau); run_test("-0.123456789", 12, 0xbdfcd6eau);
runTest("0.11111111111111111111", 22, 0x3de38e39u); run_test("0.11111111111111111111", 22, 0x3de38e39u);
runTest("0.0000000000000000000000001", 27, 0x15f79688u); run_test("0.0000000000000000000000001", 27, 0x15f79688u);
} }
TEST_F(LlvmLibcStrToFTest, DecimalOutOfRangeTests) { TEST_F(LlvmLibcStrToFTest, DecimalOutOfRangeTests) {
runTest("555E36", 6, 0x7f800000, ERANGE); run_test("555E36", 6, 0x7f800000, ERANGE);
runTest("1e-10000", 8, 0x0, ERANGE); run_test("1e-10000", 8, 0x0, ERANGE);
} }
TEST_F(LlvmLibcStrToFTest, DecimalsWithRoundingProblems) { TEST_F(LlvmLibcStrToFTest, DecimalsWithRoundingProblems) {
runTest("20040229", 8, 0x4b98e512); run_test("20040229", 8, 0x4b98e512);
runTest("20040401", 8, 0x4b98e568); run_test("20040401", 8, 0x4b98e568);
runTest("9E9", 3, 0x50061c46); run_test("9E9", 3, 0x50061c46);
} }
TEST_F(LlvmLibcStrToFTest, DecimalSubnormals) { TEST_F(LlvmLibcStrToFTest, DecimalSubnormals) {
runTest("1.4012984643248170709237295832899161312802619418765e-45", 55, 0x1, run_test("1.4012984643248170709237295832899161312802619418765e-45", 55, 0x1,
ERANGE); ERANGE);
} }
TEST_F(LlvmLibcStrToFTest, DecimalWithLongExponent) { TEST_F(LlvmLibcStrToFTest, DecimalWithLongExponent) {
runTest("1e2147483648", 12, 0x7f800000, ERANGE); run_test("1e2147483648", 12, 0x7f800000, ERANGE);
runTest("1e2147483646", 12, 0x7f800000, ERANGE); run_test("1e2147483646", 12, 0x7f800000, ERANGE);
runTest("100e2147483646", 14, 0x7f800000, ERANGE); run_test("100e2147483646", 14, 0x7f800000, ERANGE);
runTest("1e-2147483647", 13, 0x0, ERANGE); run_test("1e-2147483647", 13, 0x0, ERANGE);
runTest("1e-2147483649", 13, 0x0, ERANGE); run_test("1e-2147483649", 13, 0x0, ERANGE);
} }
TEST_F(LlvmLibcStrToFTest, BasicHexadecimalTests) { TEST_F(LlvmLibcStrToFTest, BasicHexadecimalTests) {
runTest("0x1", 3, 0x3f800000); run_test("0x1", 3, 0x3f800000);
runTest("0x10", 4, 0x41800000); run_test("0x10", 4, 0x41800000);
runTest("0x11", 4, 0x41880000); run_test("0x11", 4, 0x41880000);
runTest("0x0.1234", 8, 0x3d91a000); run_test("0x0.1234", 8, 0x3d91a000);
} }
TEST_F(LlvmLibcStrToFTest, HexadecimalSubnormalTests) { 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 // 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) { TEST_F(LlvmLibcStrToFTest, HexadecimalSubnormalRoundingTests) {
// This is the largest subnormal number that gets rounded down to 0 (as a // This is the largest subnormal number that gets rounded down to 0 (as a
// float) // float)
runTest("0x0.00000000000000000000000000000000000004", 42, 0x0, ERANGE); run_test("0x0.00000000000000000000000000000000000004", 42, 0x0, ERANGE);
// This is slightly larger, and thus rounded up // This is slightly larger, and thus rounded up
runTest("0x0.000000000000000000000000000000000000041", 43, 0x00000001, run_test("0x0.000000000000000000000000000000000000041", 43, 0x00000001,
ERANGE); ERANGE);
// These check that we're rounding to even properly // These check that we're rounding to even properly
runTest("0x0.0000000000000000000000000000000000000b", 42, 0x00000001, ERANGE); run_test("0x0.0000000000000000000000000000000000000b", 42, 0x00000001,
runTest("0x0.0000000000000000000000000000000000000c", 42, 0x00000002, ERANGE); ERANGE);
run_test("0x0.0000000000000000000000000000000000000c", 42, 0x00000002,
ERANGE);
// These check that we're rounding to even properly even when the input bits // These check that we're rounding to even properly even when the input bits
// are longer than the bit fields can contain. // are longer than the bit fields can contain.
runTest("0x1.000000000000000000000p-150", 30, 0x00000000, ERANGE); run_test("0x1.000000000000000000000p-150", 30, 0x00000000, ERANGE);
runTest("0x1.000010000000000001000p-150", 30, 0x00000001, ERANGE); run_test("0x1.000010000000000001000p-150", 30, 0x00000001, ERANGE);
runTest("0x1.000100000000000001000p-134", 30, 0x00008001, ERANGE); run_test("0x1.000100000000000001000p-134", 30, 0x00008001, ERANGE);
runTest("0x1.FFFFFC000000000001000p-127", 30, 0x007FFFFF, ERANGE); run_test("0x1.FFFFFC000000000001000p-127", 30, 0x007FFFFF, ERANGE);
runTest("0x1.FFFFFE000000000000000p-127", 30, 0x00800000); run_test("0x1.FFFFFE000000000000000p-127", 30, 0x00800000);
} }
TEST_F(LlvmLibcStrToFTest, HexadecimalNormalRoundingTests) { TEST_F(LlvmLibcStrToFTest, HexadecimalNormalRoundingTests) {
// This also checks the round to even behavior by checking three adjacent // This also checks the round to even behavior by checking three adjacent
// numbers. // numbers.
// This gets rounded down to even // This gets rounded down to even
runTest("0x123456500", 11, 0x4f91a2b2); run_test("0x123456500", 11, 0x4f91a2b2);
// This doesn't get rounded at all // This doesn't get rounded at all
runTest("0x123456600", 11, 0x4f91a2b3); run_test("0x123456600", 11, 0x4f91a2b3);
// This gets rounded up to even // This gets rounded up to even
runTest("0x123456700", 11, 0x4f91a2b4); run_test("0x123456700", 11, 0x4f91a2b4);
// Correct rounding for long input // Correct rounding for long input
runTest("0x1.000001000000000000000", 25, 0x3f800000); run_test("0x1.000001000000000000000", 25, 0x3f800000);
runTest("0x1.000001000000000000100", 25, 0x3f800001); run_test("0x1.000001000000000000100", 25, 0x3f800001);
} }
TEST_F(LlvmLibcStrToFTest, HexadecimalsWithRoundingProblems) { TEST_F(LlvmLibcStrToFTest, HexadecimalsWithRoundingProblems) {
runTest("0xFFFFFFFF", 10, 0x4f800000); run_test("0xFFFFFFFF", 10, 0x4f800000);
} }
TEST_F(LlvmLibcStrToFTest, HexadecimalOutOfRangeTests) { TEST_F(LlvmLibcStrToFTest, HexadecimalOutOfRangeTests) {
runTest("0x123456789123456789123456789123456789", 38, 0x7f800000, ERANGE); run_test("0x123456789123456789123456789123456789", 38, 0x7f800000, ERANGE);
runTest("-0x123456789123456789123456789123456789", 39, 0xff800000, ERANGE); run_test("-0x123456789123456789123456789123456789", 39, 0xff800000, ERANGE);
runTest("0x0.00000000000000000000000000000000000001", 42, 0x0, ERANGE); run_test("0x0.00000000000000000000000000000000000001", 42, 0x0, ERANGE);
} }
TEST_F(LlvmLibcStrToFTest, InfTests) { TEST_F(LlvmLibcStrToFTest, InfTests) {
runTest("INF", 3, 0x7f800000); run_test("INF", 3, 0x7f800000);
runTest("INFinity", 8, 0x7f800000); run_test("INFinity", 8, 0x7f800000);
runTest("infnity", 3, 0x7f800000); run_test("infnity", 3, 0x7f800000);
runTest("infinit", 3, 0x7f800000); run_test("infinit", 3, 0x7f800000);
runTest("infinfinit", 3, 0x7f800000); run_test("infinfinit", 3, 0x7f800000);
runTest("innf", 0, 0x0); run_test("innf", 0, 0x0);
runTest("-inf", 4, 0xff800000); run_test("-inf", 4, 0xff800000);
runTest("-iNfInItY", 9, 0xff800000); run_test("-iNfInItY", 9, 0xff800000);
} }
TEST_F(LlvmLibcStrToFTest, SimpleNaNTests) { TEST_F(LlvmLibcStrToFTest, SimpleNaNTests) {
runTest("NaN", 3, 0x7fc00000); run_test("NaN", 3, 0x7fc00000);
runTest("-nAn", 4, 0xffc00000); run_test("-nAn", 4, 0xffc00000);
} }
// These NaNs are of the form `NaN(n-character-sequence)` where the // These NaNs are of the form `NaN(n-character-sequence)` where the
// n-character-sequence is 0 or more letters or numbers. If there is anything // n-character-sequence is 0 or more letters or numbers. If there is anything
// other than a letter or a number, then the valid number is just `NaN`. If // other than a letter or a number, then the valid number is just `NaN`. If
// the sequence is valid, then the interpretation of them is implementation // the sequence is valid, then the interpretation of them is implementation
// defined, in this case it's passed to strtoll with an automatic base, and // defined, in this case it's passed to strtoll with an automatic base, and
// the result is put into the mantissa if it takes up the whole width of the // the result is put into the mantissa if it takes up the whole width of the
// parentheses. // parentheses.
TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesEmptyTest) { TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesEmptyTest) {
runTest("NaN()", 5, 0x7fc00000); run_test("NaN()", 5, 0x7fc00000);
} }
TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesValidNumberTests) { TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesValidNumberTests) {
runTest("NaN(1234)", 9, 0x7fc004d2); run_test("NaN(1234)", 9, 0x7fc004d2);
runTest("NaN(0x1234)", 11, 0x7fc01234); run_test("NaN(0x1234)", 11, 0x7fc01234);
runTest("NaN(01234)", 10, 0x7fc0029c); run_test("NaN(01234)", 10, 0x7fc0029c);
} }
TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesInvalidSequenceTests) { TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesInvalidSequenceTests) {
runTest("NaN( 1234)", 3, 0x7fc00000); run_test("NaN( 1234)", 3, 0x7fc00000);
runTest("NaN(-1234)", 3, 0x7fc00000); run_test("NaN(-1234)", 3, 0x7fc00000);
runTest("NaN(asd&f)", 3, 0x7fc00000); run_test("NaN(asd&f)", 3, 0x7fc00000);
runTest("NaN(123 )", 3, 0x7fc00000); run_test("NaN(123 )", 3, 0x7fc00000);
runTest("NaN(123+asdf)", 3, 0x7fc00000); run_test("NaN(123+asdf)", 3, 0x7fc00000);
runTest("NaN(123", 3, 0x7fc00000); run_test("NaN(123", 3, 0x7fc00000);
} }
TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesValidSequenceInvalidNumberTests) { TEST_F(LlvmLibcStrToFTest, NaNWithParenthesesValidSequenceInvalidNumberTests) {
runTest("NaN(1a)", 7, 0x7fc00000); run_test("NaN(1a)", 7, 0x7fc00000);
runTest("NaN(asdf)", 9, 0x7fc00000); run_test("NaN(asdf)", 9, 0x7fc00000);
runTest("NaN(1A1)", 8, 0x7fc00000); run_test("NaN(1A1)", 8, 0x7fc00000);
} }

libc/test/src/stdlib/strtold_test.cpp

Show All 11 Lines
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <errno.h> #include <errno.h>
#include <limits.h> #include <limits.h>
#include <stddef.h> #include <stddef.h>
class LlvmLibcStrToLDTest : public __llvm_libc::testing::Test { class LlvmLibcStrToLDTest : public __llvm_libc::testing::Test {
public: public:
void runTest(const char *inputString, const ptrdiff_t expectedStrLen, void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
const uint64_t expectedRawData64, const uint64_t expectedRawData64,
const __uint128_t expectedRawData80, const __uint128_t expectedRawData80,
const __uint128_t expectedRawData128, const __uint128_t expectedRawData128,
const int expectedErrno64 = 0, const int expectedErrno80 = 0, const int expectedErrno64 = 0, const int expectedErrno80 = 0,
const int expectedErrno128 = 0) { const int expectedErrno128 = 0) {
// expectedRawData64 is the expected long double result as a uint64_t, // expectedRawData64 is the expected long double result as a uint64_t,
// organized according to the IEEE754 double precision format: // organized according to the IEEE754 double precision format:
// //
// +-- 1 Sign Bit +-- 52 Mantissa bits // +-- 1 Sign Bit +-- 52 Mantissa bits
// | | // | |
// | +-------------------------+------------------------+ // | +-------------------------+------------------------+
// | | | // | | |
// SEEEEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM // SEEEEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
Show All 22 Lines void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
// | | // | |
// | +----------------------------+--------------------------+ // | +----------------------------+--------------------------+
// | | | // | | |
// SEEEEEEEEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM...M // SEEEEEEEEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM...M
// | | // | |
// +------+------+ // +------+------+
// | // |
// +-- 15 Exponent Bits // +-- 15 Exponent Bits
char *strEnd = nullptr; char *str_end = nullptr;
#if defined(LONG_DOUBLE_IS_DOUBLE) #if defined(LONG_DOUBLE_IS_DOUBLE)
__llvm_libc::fputil::FPBits<long double> expectedFP = __llvm_libc::fputil::FPBits<long double> expectedFP =
__llvm_libc::fputil::FPBits<long double>(expectedRawData64); __llvm_libc::fputil::FPBits<long double>(expectedRawData64);
const int expectedErrno = expectedErrno64; const int expectedErrno = expectedErrno64;
#elif defined(SPECIAL_X86_LONG_DOUBLE) #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); __llvm_libc::fputil::FPBits<long double>(expectedRawData80);
const int expectedErrno = expectedErrno80; const int expected_errno = expectedErrno80;
#else #else
__llvm_libc::fputil::FPBits<long double> expectedFP = __llvm_libc::fputil::FPBits<long double> expectedFP =
__llvm_libc::fputil::FPBits<long double>(expectedRawData128); __llvm_libc::fputil::FPBits<long double>(expectedRawData128);
const int expectedErrno = expectedErrno128; const int expectedErrno = expectedErrno128;
#endif #endif
errno = 0; 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>(); __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(actual_fp.bits, expected_fp.bits);
EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign()); EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent()); EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa()); EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
EXPECT_EQ(errno, expectedErrno); EXPECT_EQ(errno, expected_errno);
} }
}; };
TEST_F(LlvmLibcStrToLDTest, SimpleTest) { TEST_F(LlvmLibcStrToLDTest, SimpleTest) {
runTest("123", 3, uint64_t(0x405ec00000000000), run_test("123", 3, uint64_t(0x405ec00000000000),
__uint128_t(0x4005f60000) << 40, __uint128_t(0x4005f60000) << 40,
__uint128_t(0x4005ec0000000000) << 64); __uint128_t(0x4005ec0000000000) << 64);
// This should fail on Eisel-Lemire, forcing a fallback to simple decimal // This should fail on Eisel-Lemire, forcing a fallback to simple decimal
// conversion. // conversion.
runTest("12345678901234549760", 20, uint64_t(0x43e56a95319d63d8), run_test("12345678901234549760", 20, uint64_t(0x43e56a95319d63d8),
(__uint128_t(0x403eab54a9) << 40) + __uint128_t(0x8ceb1ec400), (__uint128_t(0x403eab54a9) << 40) + __uint128_t(0x8ceb1ec400),
(__uint128_t(0x403e56a95319d63d) << 64) + (__uint128_t(0x403e56a95319d63d) << 64) +
__uint128_t(0x8800000000000000)); __uint128_t(0x8800000000000000));
// Found while looking for difficult test cases here: // Found while looking for difficult test cases here:
// https://github.com/nigeltao/parse-number-fxx-test-data/blob/main/more-test-cases/golang-org-issue-36657.txt // 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),
(__uint128_t(0x4062dc3bcf) << 40) + __uint128_t(0x923a6fd402), (__uint128_t(0x4062dc3bcf) << 40) + __uint128_t(0x923a6fd402),
(__uint128_t(0x4062b8779f2474df) << 64) + (__uint128_t(0x4062b8779f2474df) << 64) +
__uint128_t(0xa804bfd8c6d5c000)); __uint128_t(0xa804bfd8c6d5c000));
runTest("0x123", 5, uint64_t(0x4072300000000000), run_test("0x123", 5, uint64_t(0x4072300000000000),
(__uint128_t(0x4007918000) << 40), (__uint128_t(0x4007918000) << 40),
(__uint128_t(0x4007230000000000) << 64)); (__uint128_t(0x4007230000000000) << 64));
} }
// These are tests that have caused problems for doubles in the past. // These are tests that have caused problems for doubles in the past.
TEST_F(LlvmLibcStrToLDTest, Float64SpecificFailures) { TEST_F(LlvmLibcStrToLDTest, Float64SpecificFailures) {
runTest("3E70000000000000", 16, uint64_t(0x7FF0000000000000), run_test("3E70000000000000", 16, uint64_t(0x7FF0000000000000),
(__uint128_t(0x7fff800000) << 40), (__uint128_t(0x7fff800000) << 40),
(__uint128_t(0x7fff000000000000) << 64), ERANGE, ERANGE, ERANGE); (__uint128_t(0x7fff000000000000) << 64), ERANGE, ERANGE, ERANGE);
runTest("358416272e-33", 13, uint64_t(0x3adbbb2a68c9d0b9), run_test("358416272e-33", 13, uint64_t(0x3adbbb2a68c9d0b9),
(__uint128_t(0x3fadddd953) << 40) + __uint128_t(0x464e85c400), (__uint128_t(0x3fadddd953) << 40) + __uint128_t(0x464e85c400),
(__uint128_t(0x3fadbbb2a68c9d0b) << 64) + (__uint128_t(0x3fadbbb2a68c9d0b) << 64) +
__uint128_t(0x8800e7969e1c5fc8)); __uint128_t(0x8800e7969e1c5fc8));
runTest( run_test(
"2.16656806400000023841857910156251e9", 36, uint64_t(0x41e0246690000001), "2.16656806400000023841857910156251e9", 36, uint64_t(0x41e0246690000001),
(__uint128_t(0x401e812334) << 40) + __uint128_t(0x8000000400), (__uint128_t(0x401e812334) << 40) + __uint128_t(0x8000000400),
(__uint128_t(0x401e024669000000) << 64) + __uint128_t(0x800000000000018)); (__uint128_t(0x401e024669000000) << 64) + __uint128_t(0x800000000000018));
runTest("27949676547093071875", 20, uint64_t(0x43f83e132bc608c9), run_test("27949676547093071875", 20, uint64_t(0x43f83e132bc608c9),
(__uint128_t(0x403fc1f099) << 40) + __uint128_t(0x5e30464402), (__uint128_t(0x403fc1f099) << 40) + __uint128_t(0x5e30464402),
(__uint128_t(0x403f83e132bc608c) << 64) + (__uint128_t(0x403f83e132bc608c) << 64) +
__uint128_t(0x8803000000000000)); __uint128_t(0x8803000000000000));
} }
TEST_F(LlvmLibcStrToLDTest, MaxSizeNumbers) { TEST_F(LlvmLibcStrToLDTest, MaxSizeNumbers) {
runTest("1.1897314953572317650e4932", 26, uint64_t(0x7FF0000000000000), run_test("1.1897314953572317650e4932", 26, uint64_t(0x7FF0000000000000),
(__uint128_t(0x7ffeffffff) << 40) + __uint128_t(0xffffffffff), (__uint128_t(0x7ffeffffff) << 40) + __uint128_t(0xffffffffff),
(__uint128_t(0x7ffeffffffffffff) << 64) + (__uint128_t(0x7ffeffffffffffff) << 64) +
__uint128_t(0xfffd57322e3f8675), __uint128_t(0xfffd57322e3f8675),
ERANGE, 0, 0); ERANGE, 0, 0);
runTest("1.18973149535723176508e4932", 27, uint64_t(0x7FF0000000000000), run_test("1.18973149535723176508e4932", 27, uint64_t(0x7FF0000000000000),
(__uint128_t(0x7fff800000) << 40), (__uint128_t(0x7fff800000) << 40),
(__uint128_t(0x7ffeffffffffffff) << 64) + (__uint128_t(0x7ffeffffffffffff) << 64) +
__uint128_t(0xffffd2478338036c), __uint128_t(0xffffd2478338036c),
ERANGE, ERANGE, 0); ERANGE, ERANGE, 0);
} }
// These tests check subnormal behavior for 80 bit and 128 bit floats. They will // These tests check subnormal behavior for 80 bit and 128 bit floats. They will
// be too small for 64 bit floats. // be too small for 64 bit floats.
TEST_F(LlvmLibcStrToLDTest, SubnormalTests) { TEST_F(LlvmLibcStrToLDTest, SubnormalTests) {
runTest("1e-4950", 7, uint64_t(0), (__uint128_t(0x00000000000000000003)), run_test("1e-4950", 7, uint64_t(0), (__uint128_t(0x00000000000000000003)),
(__uint128_t(0x000000000000000000057c9647e1a018)), ERANGE, ERANGE, (__uint128_t(0x000000000000000000057c9647e1a018)), ERANGE, ERANGE,
ERANGE); ERANGE);
runTest("1.89e-4951", 10, uint64_t(0), (__uint128_t(0x00000000000000000001)), run_test("1.89e-4951", 10, uint64_t(0), (__uint128_t(0x00000000000000000001)),
(__uint128_t(0x0000000000000000000109778a006738)), ERANGE, ERANGE, (__uint128_t(0x0000000000000000000109778a006738)), ERANGE, ERANGE,
ERANGE); ERANGE);
runTest("4e-4966", 7, uint64_t(0), (__uint128_t(0)), run_test("4e-4966", 7, uint64_t(0), (__uint128_t(0)),
(__uint128_t(0x00000000000000000000000000000001)), ERANGE, ERANGE, (__uint128_t(0x00000000000000000000000000000001)), ERANGE, ERANGE,
ERANGE); ERANGE);
} }
TEST_F(LlvmLibcStrToLDTest, SmallNormalTests) { TEST_F(LlvmLibcStrToLDTest, SmallNormalTests) {
runTest("3.37e-4932", 10, uint64_t(0), run_test("3.37e-4932", 10, uint64_t(0),
(__uint128_t(0x1804cf7) << 40) + __uint128_t(0x908850712), (__uint128_t(0x1804cf7) << 40) + __uint128_t(0x908850712),
(__uint128_t(0x10099ee12110a) << 64) + __uint128_t(0xe24b75c0f50dc0c), (__uint128_t(0x10099ee12110a) << 64) +
__uint128_t(0xe24b75c0f50dc0c),
ERANGE, 0, 0); ERANGE, 0, 0);
} }
TEST_F(LlvmLibcStrToLDTest, ComplexHexadecimalTests) { TEST_F(LlvmLibcStrToLDTest, ComplexHexadecimalTests) {
runTest("0x1p16383", 9, 0x7ff0000000000000, (__uint128_t(0x7ffe800000) << 40), run_test("0x1p16383", 9, 0x7ff0000000000000,
(__uint128_t(0x7ffe800000) << 40),
(__uint128_t(0x7ffe000000000000) << 64)); (__uint128_t(0x7ffe000000000000) << 64));
runTest("0x123456789abcdef", 17, 0x43723456789abcdf, run_test("0x123456789abcdef", 17, 0x43723456789abcdf,
(__uint128_t(0x403791a2b3) << 40) + __uint128_t(0xc4d5e6f780), (__uint128_t(0x403791a2b3) << 40) + __uint128_t(0xc4d5e6f780),
(__uint128_t(0x403723456789abcd) << 64) + (__uint128_t(0x403723456789abcd) << 64) +
__uint128_t(0xef00000000000000)); __uint128_t(0xef00000000000000));
runTest("0x123456789abcdef0123456789ABCDEF", 33, 0x7ff0000000000000, run_test("0x123456789abcdef0123456789ABCDEF", 33, 0x7ff0000000000000,
(__uint128_t(0x407791a2b3) << 40) + __uint128_t(0xc4d5e6f781), (__uint128_t(0x407791a2b3) << 40) + __uint128_t(0xc4d5e6f781),
(__uint128_t(0x407723456789abcd) << 64) + (__uint128_t(0x407723456789abcd) << 64) +
__uint128_t(0xef0123456789abce)); __uint128_t(0xef0123456789abce));
} }
TEST_F(LlvmLibcStrToLDTest, InfTests) { TEST_F(LlvmLibcStrToLDTest, InfTests) {
runTest("INF", 3, 0x7ff0000000000000, (__uint128_t(0x7fff800000) << 40), run_test("INF", 3, 0x7ff0000000000000, (__uint128_t(0x7fff800000) << 40),
(__uint128_t(0x7fff000000000000) << 64)); (__uint128_t(0x7fff000000000000) << 64));
runTest("INFinity", 8, 0x7ff0000000000000, (__uint128_t(0x7fff800000) << 40), run_test("INFinity", 8, 0x7ff0000000000000, (__uint128_t(0x7fff800000) << 40),
(__uint128_t(0x7fff000000000000) << 64)); (__uint128_t(0x7fff000000000000) << 64));
runTest("-inf", 4, 0xfff0000000000000, (__uint128_t(0xffff800000) << 40), run_test("-inf", 4, 0xfff0000000000000, (__uint128_t(0xffff800000) << 40),
(__uint128_t(0xffff000000000000) << 64)); (__uint128_t(0xffff000000000000) << 64));
} }
TEST_F(LlvmLibcStrToLDTest, NaNTests) { TEST_F(LlvmLibcStrToLDTest, NaNTests) {
runTest("NaN", 3, 0x7ff8000000000000, (__uint128_t(0x7fffc00000) << 40), run_test("NaN", 3, 0x7ff8000000000000, (__uint128_t(0x7fffc00000) << 40),
(__uint128_t(0x7fff800000000000) << 64)); (__uint128_t(0x7fff800000000000) << 64));
runTest("-nAn", 4, 0xfff8000000000000, (__uint128_t(0xffffc00000) << 40), run_test("-nAn", 4, 0xfff8000000000000, (__uint128_t(0xffffc00000) << 40),
(__uint128_t(0xffff800000000000) << 64)); (__uint128_t(0xffff800000000000) << 64));
runTest("NaN()", 5, 0x7ff8000000000000, (__uint128_t(0x7fffc00000) << 40), run_test("NaN()", 5, 0x7ff8000000000000, (__uint128_t(0x7fffc00000) << 40),
(__uint128_t(0x7fff800000000000) << 64)); (__uint128_t(0x7fff800000000000) << 64));
runTest("NaN(1234)", 9, 0x7ff80000000004d2, run_test("NaN(1234)", 9, 0x7ff80000000004d2,
(__uint128_t(0x7fffc00000) << 40) + __uint128_t(0x4d2), (__uint128_t(0x7fffc00000) << 40) + __uint128_t(0x4d2),
(__uint128_t(0x7fff800000000000) << 64) + __uint128_t(0x4d2)); (__uint128_t(0x7fff800000000000) << 64) + __uint128_t(0x4d2));
runTest("NaN(0xffffffffffff)", 19, 0x7ff8ffffffffffff, run_test("NaN(0xffffffffffff)", 19, 0x7ff8ffffffffffff,
(__uint128_t(0x7fffc000ff) << 40) + __uint128_t(0xffffffffff), (__uint128_t(0x7fffc000ff) << 40) + __uint128_t(0xffffffffff),
(__uint128_t(0x7fff800000000000) << 64) + (__uint128_t(0x7fff800000000000) << 64) +
__uint128_t(0xffffffffffff)); __uint128_t(0xffffffffffff));
runTest("NaN(0xfffffffffffff)", 20, 0x7fffffffffffffff, run_test("NaN(0xfffffffffffff)", 20, 0x7fffffffffffffff,
(__uint128_t(0x7fffc00fff) << 40) + __uint128_t(0xffffffffff), (__uint128_t(0x7fffc00fff) << 40) + __uint128_t(0xffffffffff),
(__uint128_t(0x7fff800000000000) << 64) + (__uint128_t(0x7fff800000000000) << 64) +
__uint128_t(0xfffffffffffff)); __uint128_t(0xfffffffffffff));
runTest("NaN(0xffffffffffffffff)", 23, 0x7fffffffffffffff, run_test("NaN(0xffffffffffffffff)", 23, 0x7fffffffffffffff,
(__uint128_t(0x7fffffffff) << 40) + __uint128_t(0xffffffffff), (__uint128_t(0x7fffffffff) << 40) + __uint128_t(0xffffffffff),
(__uint128_t(0x7fff800000000000) << 64) + (__uint128_t(0x7fff800000000000) << 64) +
__uint128_t(0xffffffffffffffff)); __uint128_t(0xffffffffffffffff));
runTest("NaN( 1234)", 3, 0x7ff8000000000000, run_test("NaN( 1234)", 3, 0x7ff8000000000000,
(__uint128_t(0x7fffc00000) << 40), (__uint128_t(0x7fffc00000) << 40),
(__uint128_t(0x7fff800000000000) << 64)); (__uint128_t(0x7fff800000000000) << 64));
} }

libc/test/src/string/bcmp_test.cpp

Show All 28 Lines
TEST(LlvmLibcBcmpTest, LhsAfterRhsLexically) { TEST(LlvmLibcBcmpTest, LhsAfterRhsLexically) {
const char *lhs = "ac"; const char *lhs = "ac";
const char *rhs = "ab"; const char *rhs = "ab";
EXPECT_NE(__llvm_libc::bcmp(lhs, rhs, 2), 0); EXPECT_NE(__llvm_libc::bcmp(lhs, rhs, 2), 0);
} }
TEST(LlvmLibcBcmpTest, Sweep) { TEST(LlvmLibcBcmpTest, Sweep) {
static constexpr size_t kMaxSize = 1024; static constexpr size_t K_MAX_SIZE = 1024;
char lhs[kMaxSize]; char lhs[K_MAX_SIZE];
char rhs[kMaxSize]; char rhs[K_MAX_SIZE];
const auto reset = [](char *const ptr) { 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'; ptr[i] = 'a';
}; };
reset(lhs); reset(lhs);
reset(rhs); 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); EXPECT_EQ(__llvm_libc::bcmp(lhs, rhs, i), 0);
reset(lhs); reset(lhs);
reset(rhs); reset(rhs);
for (size_t i = 0; i < kMaxSize; ++i) { for (size_t i = 0; i < K_MAX_SIZE; ++i) {
rhs[i] = 'b'; 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'; rhs[i] = 'a';
} }
} }

libc/test/src/string/bzero_test.cpp

//===-- Unittests for bzero -----------------------------------------------===// //===-- Unittests for bzero -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/CPP/ArrayRef.h" #include "src/__support/CPP/ArrayRef.h"
#include "src/string/bzero.h" #include "src/string/bzero.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
using __llvm_libc::cpp::Array; using __llvm_libc::cpp::Array;
using __llvm_libc::cpp::ArrayRef; using __llvm_libc::cpp::ArrayRef;
using Data = Array<char, 2048>; 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`. // Returns a Data object filled with a repetition of `filler`.
Data getData(ArrayRef<char> filler) { Data get_data(ArrayRef<char> filler) {
Data out; Data out;
for (size_t i = 0; i < out.size(); ++i) for (size_t i = 0; i < out.size(); ++i)
out[i] = filler[i % filler.size()]; out[i] = filler[i % filler.size()];
return out; return out;
} }
TEST(LlvmLibcBzeroTest, Thorough) { 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 count = 0; count < 1024; ++count) {
for (size_t align = 0; align < 64; ++align) { for (size_t align = 0; align < 64; ++align) {
auto buffer = dirty; auto buffer = dirty;
char *const dst = &buffer[align]; char *const dst = &buffer[align];
__llvm_libc::bzero(dst, count); __llvm_libc::bzero(dst, count);
// Everything before copy is untouched. // Everything before copy is untouched.
for (size_t i = 0; i < align; ++i) for (size_t i = 0; i < align; ++i)
ASSERT_EQ(buffer[i], dirty[i]); ASSERT_EQ(buffer[i], dirty[i]);
Show All 13 Lines

libc/test/src/string/memcmp_test.cpp

Show All 28 Lines
TEST(LlvmLibcMemcmpTest, LhsAfterRhsLexically) { TEST(LlvmLibcMemcmpTest, LhsAfterRhsLexically) {
const char *lhs = "az"; const char *lhs = "az";
const char *rhs = "ab"; const char *rhs = "ab";
EXPECT_GT(__llvm_libc::memcmp(lhs, rhs, 2), 0); EXPECT_GT(__llvm_libc::memcmp(lhs, rhs, 2), 0);
} }
TEST(LlvmLibcMemcmpTest, Sweep) { TEST(LlvmLibcMemcmpTest, Sweep) {
static constexpr size_t kMaxSize = 1024; static constexpr size_t K_MAX_SIZE = 1024;
char lhs[kMaxSize]; char lhs[K_MAX_SIZE];
char rhs[kMaxSize]; char rhs[K_MAX_SIZE];
const auto reset = [](char *const ptr) { 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'; ptr[i] = 'a';
}; };
reset(lhs); reset(lhs);
reset(rhs); 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); EXPECT_EQ(__llvm_libc::memcmp(lhs, rhs, i), 0);
reset(lhs); reset(lhs);
reset(rhs); reset(rhs);
for (size_t i = 0; i < kMaxSize; ++i) { for (size_t i = 0; i < K_MAX_SIZE; ++i) {
rhs[i] = 'z'; 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'; rhs[i] = 'a';
} }
} }

libc/test/src/string/memcpy_test.cpp

//===-- Unittests for memcpy ----------------------------------------------===// //===-- Unittests for memcpy ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/CPP/ArrayRef.h" #include "src/__support/CPP/ArrayRef.h"
#include "src/string/memcpy.h" #include "src/string/memcpy.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
using __llvm_libc::cpp::Array; using __llvm_libc::cpp::Array;
using __llvm_libc::cpp::ArrayRef; using __llvm_libc::cpp::ArrayRef;
using Data = Array<char, 2048>; using Data = Array<char, 2048>;
static const ArrayRef<char> kNumbers("0123456789", 10); static const ArrayRef<char> k_numbers("0123456789", 10);
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`. // Returns a Data object filled with a repetition of `filler`.
Data getData(ArrayRef<char> filler) { Data get_data(ArrayRef<char> filler) {
Data out; Data out;
for (size_t i = 0; i < out.size(); ++i) for (size_t i = 0; i < out.size(); ++i)
out[i] = filler[i % filler.size()]; out[i] = filler[i % filler.size()];
return out; return out;
} }
TEST(LlvmLibcMemcpyTest, Thorough) { TEST(LlvmLibcMemcpyTest, Thorough) {
const Data groundtruth = getData(kNumbers); const Data groundtruth = get_data(k_numbers);
const Data dirty = getData(kDeadcode); const Data dirty = get_data(k_deadcode);
for (size_t count = 0; count < 1024; ++count) { for (size_t count = 0; count < 1024; ++count) {
for (size_t align = 0; align < 64; ++align) { for (size_t align = 0; align < 64; ++align) {
auto buffer = dirty; auto buffer = dirty;
const char *const src = groundtruth.data(); const char *const src = groundtruth.data();
void *const dst = &buffer[align]; void *const dst = &buffer[align];
void *const ret = __llvm_libc::memcpy(dst, src, count); void *const ret = __llvm_libc::memcpy(dst, src, count);
// Return value is `dst`. // Return value is `dst`.
ASSERT_EQ(ret, dst); ASSERT_EQ(ret, dst);
Show All 16 Lines

libc/test/src/string/memset_test.cpp

//===-- Unittests for memset ----------------------------------------------===// //===-- Unittests for memset ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/CPP/ArrayRef.h" #include "src/__support/CPP/ArrayRef.h"
#include "src/string/memset.h" #include "src/string/memset.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
using __llvm_libc::cpp::Array; using __llvm_libc::cpp::Array;
using __llvm_libc::cpp::ArrayRef; using __llvm_libc::cpp::ArrayRef;
using Data = Array<char, 2048>; 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`. // Returns a Data object filled with a repetition of `filler`.
Data getData(ArrayRef<char> filler) { Data get_data(ArrayRef<char> filler) {
Data out; Data out;
for (size_t i = 0; i < out.size(); ++i) for (size_t i = 0; i < out.size(); ++i)
out[i] = filler[i % filler.size()]; out[i] = filler[i % filler.size()];
return out; return out;
} }
TEST(LlvmLibcMemsetTest, Thorough) { TEST(LlvmLibcMemsetTest, Thorough) {
const Data dirty = getData(kDeadcode); const Data dirty = get_data(k_deadcode);
for (int value = -1; value <= 1; ++value) { for (int value = -1; value <= 1; ++value) {
for (size_t count = 0; count < 1024; ++count) { for (size_t count = 0; count < 1024; ++count) {
for (size_t align = 0; align < 64; ++align) { for (size_t align = 0; align < 64; ++align) {
auto buffer = dirty; auto buffer = dirty;
void *const dst = &buffer[align]; void *const dst = &buffer[align];
void *const ret = __llvm_libc::memset(dst, value, count); void *const ret = __llvm_libc::memset(dst, value, count);
// Return value is `dst`. // Return value is `dst`.
ASSERT_EQ(ret, dst); ASSERT_EQ(ret, dst);
Show All 17 Lines

libc/test/src/string/stpcpy_test.cpp

//===-- Unittests for stpcpy ----------------------------------------------===// //===-- Unittests for stpcpy ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/string/stpcpy.h" #include "src/string/stpcpy.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include "src/string/string_utils.h" #include "src/string/string_utils.h"
TEST(LlvmLibcStpCpyTest, EmptySrc) { TEST(LlvmLibcStpCpyTest, EmptySrc) {
const char *empty = ""; 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 dest[4] = {'a', 'b', 'c', '\0'};
char *result = __llvm_libc::stpcpy(dest, empty); char *result = __llvm_libc::stpcpy(dest, empty);
ASSERT_EQ(dest + srcSize, result); ASSERT_EQ(dest + src_size, result);
ASSERT_EQ(result[0], '\0'); ASSERT_EQ(result[0], '\0');
ASSERT_STREQ(dest, empty); ASSERT_STREQ(dest, empty);
} }
TEST(LlvmLibcStpCpyTest, EmptyDest) { TEST(LlvmLibcStpCpyTest, EmptyDest) {
const char *abc = "abc"; 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 dest[4];
char *result = __llvm_libc::stpcpy(dest, abc); char *result = __llvm_libc::stpcpy(dest, abc);
ASSERT_EQ(dest + srcSize, result); ASSERT_EQ(dest + src_size, result);
ASSERT_EQ(result[0], '\0'); ASSERT_EQ(result[0], '\0');
ASSERT_STREQ(dest, abc); ASSERT_STREQ(dest, abc);
} }
TEST(LlvmLibcStpCpyTest, OffsetDest) { TEST(LlvmLibcStpCpyTest, OffsetDest) {
const char *abc = "abc"; 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 dest[7] = {'x', 'y', 'z'};
char *result = __llvm_libc::stpcpy(dest + 3, abc); 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_EQ(result[0], '\0');
ASSERT_STREQ(dest, "xyzabc"); ASSERT_STREQ(dest, "xyzabc");
} }

libc/test/src/threads/call_once_test.cpp

Show All 12 Lines
#include "src/threads/mtx_lock.h" #include "src/threads/mtx_lock.h"
#include "src/threads/mtx_unlock.h" #include "src/threads/mtx_unlock.h"
#include "src/threads/thrd_create.h" #include "src/threads/thrd_create.h"
#include "src/threads/thrd_join.h" #include "src/threads/thrd_join.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <stdatomic.h> #include <stdatomic.h>
static constexpr unsigned int num_threads = 5; static constexpr unsigned int NUM_THREADS = 5;
static atomic_uint thread_count; static atomic_uint thread_count;
static unsigned int call_count; static unsigned int call_count;
static void call_once_func() { ++call_count; } static void call_once_func() { ++call_count; }
static int func(void *) { static int func(void *) {
static once_flag flag = ONCE_FLAG_INIT; static once_flag flag = ONCE_FLAG_INIT;
__llvm_libc::call_once(&flag, call_once_func); __llvm_libc::call_once(&flag, call_once_func);
++thread_count; // This is a an atomic update. ++thread_count; // This is a an atomic update.
return 0; return 0;
} }
TEST(LlvmLibcCallOnceTest, CallFrom5Threads) { TEST(LlvmLibcCallOnceTest, CallFrom5Threads) {
// Ensure the call count and thread count are 0 to begin with. // Ensure the call count and thread count are 0 to begin with.
call_count = 0; call_count = 0;
thread_count = 0; thread_count = 0;
thrd_t threads[num_threads]; thrd_t threads[NUM_THREADS];
for (unsigned int i = 0; i < num_threads; ++i) { for (unsigned int i = 0; i < NUM_THREADS; ++i) {
ASSERT_EQ(__llvm_libc::thrd_create(threads + i, func, nullptr), ASSERT_EQ(__llvm_libc::thrd_create(threads + i, func, nullptr),
static_cast<int>(thrd_success)); 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; int retval;
ASSERT_EQ(__llvm_libc::thrd_join(threads + i, &retval), ASSERT_EQ(__llvm_libc::thrd_join(threads + i, &retval),
static_cast<int>(thrd_success)); static_cast<int>(thrd_success));
ASSERT_EQ(retval, 0); ASSERT_EQ(retval, 0);
} }
EXPECT_EQ(static_cast<unsigned int>(thread_count), 5U); EXPECT_EQ(static_cast<unsigned int>(thread_count), 5U);
EXPECT_EQ(call_count, 1U); EXPECT_EQ(call_count, 1U);
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libc/test/src/threads/mtx_test.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 LinesTEST(LlvmLibcMutexTest, RelayCounter) {
int retval = 123; int retval = 123;
__llvm_libc::thrd_join(&thread, &retval); __llvm_libc::thrd_join(&thread, &retval);
ASSERT_EQ(retval, 0); ASSERT_EQ(retval, 0);
__llvm_libc::mtx_destroy(&mutex); __llvm_libc::mtx_destroy(&mutex);
} }
mtx_t start_lock, step_lock; mtx_t start_lock, step_lock;
bool start, step; bool started, step;
int stepper(void *arg) { int stepper(void *arg) {
__llvm_libc::mtx_lock(&start_lock); __llvm_libc::mtx_lock(&start_lock);
start = true; started = true;
__llvm_libc::mtx_unlock(&start_lock); __llvm_libc::mtx_unlock(&start_lock);
__llvm_libc::mtx_lock(&step_lock); __llvm_libc::mtx_lock(&step_lock);
step = true; step = true;
__llvm_libc::mtx_unlock(&step_lock); __llvm_libc::mtx_unlock(&step_lock);
return 0; return 0;
} }
TEST(LlvmLibcMutexTest, WaitAndStep) { TEST(LlvmLibcMutexTest, WaitAndStep) {
ASSERT_EQ(__llvm_libc::mtx_init(&start_lock, mtx_plain), ASSERT_EQ(__llvm_libc::mtx_init(&start_lock, mtx_plain),
static_cast<int>(thrd_success)); static_cast<int>(thrd_success));
ASSERT_EQ(__llvm_libc::mtx_init(&step_lock, mtx_plain), ASSERT_EQ(__llvm_libc::mtx_init(&step_lock, mtx_plain),
static_cast<int>(thrd_success)); static_cast<int>(thrd_success));
// In this test, we start a new thread but block it before it can make a // In this test, we start a new thread but block it before it can make a
// step. Once we ensure that the thread is blocked, we unblock it. // step. Once we ensure that the thread is blocked, we unblock it.
// After unblocking, we then verify that the thread was indeed unblocked. // After unblocking, we then verify that the thread was indeed unblocked.
step = false; step = false;
start = false; started = false;
ASSERT_EQ(__llvm_libc::mtx_lock(&step_lock), static_cast<int>(thrd_success)); ASSERT_EQ(__llvm_libc::mtx_lock(&step_lock), static_cast<int>(thrd_success));
thrd_t thread; thrd_t thread;
__llvm_libc::thrd_create(&thread, stepper, nullptr); __llvm_libc::thrd_create(&thread, stepper, nullptr);
while (true) { while (true) {
// Make sure the thread actually started. // Make sure the thread actually started.
ASSERT_EQ(__llvm_libc::mtx_lock(&start_lock), ASSERT_EQ(__llvm_libc::mtx_lock(&start_lock),
static_cast<int>(thrd_success)); static_cast<int>(thrd_success));
bool s = start; bool s = started;
ASSERT_EQ(__llvm_libc::mtx_unlock(&start_lock), ASSERT_EQ(__llvm_libc::mtx_unlock(&start_lock),
static_cast<int>(thrd_success)); static_cast<int>(thrd_success));
if (s) if (s)
break; break;
} }
// Since |step_lock| is still locked, |step| should be false. // Since |step_lock| is still locked, |step| should be false.
ASSERT_FALSE(step); ASSERT_FALSE(step);
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

libc/test/src/time/TmHelper.h

Show All 14 Lines
using __llvm_libc::time_utils::TimeConstants; using __llvm_libc::time_utils::TimeConstants;
namespace __llvm_libc { namespace __llvm_libc {
namespace tmhelper { namespace tmhelper {
namespace testing { namespace testing {
// A helper function to initialize tm data structure. // A helper function to initialize tm data structure.
static inline void InitializeTmData(struct tm *tm_data, int year, int month, static inline void initialize_tm_data(struct tm *tm_data, int year, int month,
int mday, int hour, int min, int sec, int mday, int hour, int min, int sec,
int wday, int yday) { int wday, int yday) {
struct tm temp = {.tm_sec = sec, struct tm temp = {.tm_sec = sec,
.tm_min = min, .tm_min = min,
.tm_hour = hour, .tm_hour = hour,
.tm_mday = mday, .tm_mday = mday,
.tm_mon = month - 1, // tm_mon starts with 0 for Jan .tm_mon = month - 1, // tm_mon starts with 0 for Jan
// years since 1900 // years since 1900
.tm_year = year - TimeConstants::TIME_YEAR_BASE, .tm_year = year - TimeConstants::TIME_YEAR_BASE,
.tm_wday = wday, .tm_wday = wday,
Show All 9 Lines

libc/test/src/time/asctime_r_test.cpp

Show All 11 Lines
#include "test/src/time/TmHelper.h" #include "test/src/time/TmHelper.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
using __llvm_libc::time_utils::TimeConstants; using __llvm_libc::time_utils::TimeConstants;
static inline char *call_asctime_r(struct tm *tm_data, int year, int month, static inline char *call_asctime_r(struct tm *tm_data, int year, int month,
int mday, int hour, int min, int sec, int mday, int hour, int min, int sec,
int wday, int yday, char *buffer) { int wday, int yday, char *buffer) {
__llvm_libc::tmhelper::testing::InitializeTmData(tm_data, year, month, mday, __llvm_libc::tmhelper::testing::initialize_tm_data(
hour, min, sec, wday, yday); tm_data, year, month, mday, hour, min, sec, wday, yday);
return __llvm_libc::asctime_r(tm_data, buffer); return __llvm_libc::asctime_r(tm_data, buffer);
} }
// asctime and asctime_r share the same code and thus didn't repeat all the // asctime and asctime_r share the same code and thus didn't repeat all the
// tests from asctime. Added couple of validation tests. // tests from asctime. Added couple of validation tests.
TEST(LlvmLibcAsctimeR, Nullptr) { TEST(LlvmLibcAsctimeR, Nullptr) {
char *result; char *result;
result = __llvm_libc::asctime_r(nullptr, nullptr); result = __llvm_libc::asctime_r(nullptr, nullptr);
Show All 31 Lines

libc/test/src/time/asctime_test.cpp

//===-- Unittests for asctime ---------------------------------------------===// //===-- Unittests for asctime ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/time/asctime.h" #include "src/time/asctime.h"
#include "test/src/time/TmHelper.h" #include "test/src/time/TmHelper.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
static inline char *call_asctime(struct tm *tm_data, int year, int month, static inline char *call_asctime(struct tm *tm_data, int year, int month,
int mday, int hour, int min, int sec, int wday, int mday, int hour, int min, int sec, int wday,
int yday) { int yday) {
__llvm_libc::tmhelper::testing::InitializeTmData(tm_data, year, month, mday, __llvm_libc::tmhelper::testing::initialize_tm_data(
hour, min, sec, wday, yday); tm_data, year, month, mday, hour, min, sec, wday, yday);
return __llvm_libc::asctime(tm_data); return __llvm_libc::asctime(tm_data);
} }
TEST(LlvmLibcAsctime, Nullptr) { TEST(LlvmLibcAsctime, Nullptr) {
char *result; char *result;
result = __llvm_libc::asctime(nullptr); result = __llvm_libc::asctime(nullptr);
ASSERT_EQ(EINVAL, llvmlibc_errno); ASSERT_EQ(EINVAL, llvmlibc_errno);
ASSERT_STREQ(nullptr, result); ASSERT_STREQ(nullptr, result);
▲ Show 20 Lines • Show All 190 Lines • Show Last 20 Lines

libc/test/src/time/mktime_test.cpp

Show All 18 Lines
using __llvm_libc::testing::ErrnoSetterMatcher::Fails; using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds; using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
using __llvm_libc::time_utils::TimeConstants; using __llvm_libc::time_utils::TimeConstants;
static inline time_t call_mktime(struct tm *tm_data, int year, int month, 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 mday, int hour, int min, int sec, int wday,
int yday) { int yday) {
__llvm_libc::tmhelper::testing::InitializeTmData(tm_data, year, month, mday, __llvm_libc::tmhelper::testing::initialize_tm_data(
hour, min, sec, wday, yday); tm_data, year, month, mday, hour, min, sec, wday, yday);
return __llvm_libc::mktime(tm_data); return __llvm_libc::mktime(tm_data);
} }
TEST(LlvmLibcMkTime, FailureSetsErrno) { TEST(LlvmLibcMkTime, FailureSetsErrno) {
struct tm tm_data; 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); &tm_data, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, -1, 0, 0);
EXPECT_THAT(__llvm_libc::mktime(&tm_data), Fails(EOVERFLOW)); EXPECT_THAT(__llvm_libc::mktime(&tm_data), Fails(EOVERFLOW));
} }
TEST(LlvmLibcMkTime, InvalidSeconds) { TEST(LlvmLibcMkTime, InvalidSeconds) {
struct tm tm_data; struct tm tm_data;
// -1 second from 1970-01-01 00:00:00 returns 1969-12-31 23:59:59. // -1 second from 1970-01-01 00:00:00 returns 1969-12-31 23:59:59.
EXPECT_THAT(call_mktime(&tm_data, EXPECT_THAT(call_mktime(&tm_data,
▲ Show 20 Lines • Show All 389 Lines • Show Last 20 Lines

libc/test/src/unistd/write_test.cpp

//===-- Unittests for write -----------------------------------------------===// //===-- Unittests for write -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "include/errno.h" #include "include/errno.h"
#include "src/unistd/write.h" #include "src/unistd/write.h"
#include "test/ErrnoSetterMatcher.h" #include "test/ErrnoSetterMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include "utils/testutils/FDReader.h" #include "utils/testutils/FDReader.h"
TEST(LlvmLibcUniStd, WriteBasic) { TEST(LlvmLibcUniStd, WriteBasic) {
using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds; using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
constexpr const char *hello = "hello"; constexpr const char *HELLO = "hello";
__llvm_libc::testutils::FDReader reader; __llvm_libc::testutils::FDReader reader;
EXPECT_THAT(__llvm_libc::write(reader.getWriteFD(), hello, 5), Succeeds(5)); EXPECT_THAT(__llvm_libc::write(reader.get_write_fd(), HELLO, 5), Succeeds(5));
EXPECT_TRUE(reader.matchWritten(hello)); EXPECT_TRUE(reader.match_written(HELLO));
} }
TEST(LlvmLibcUniStd, WriteFails) { TEST(LlvmLibcUniStd, WriteFails) {
using __llvm_libc::testing::ErrnoSetterMatcher::Fails; using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
EXPECT_THAT(__llvm_libc::write(-1, "", 1), Fails(EBADF)); EXPECT_THAT(__llvm_libc::write(-1, "", 1), Fails(EBADF));
EXPECT_THAT(__llvm_libc::write(1, reinterpret_cast<const void *>(-1), 1), EXPECT_THAT(__llvm_libc::write(1, reinterpret_cast<const void *>(-1), 1),
Fails(EFAULT)); Fails(EFAULT));
} }

libc/utils/UnitTest/LibcTest.cpp

Show First 20 Lines • Show All 285 Lines • ▼ Show 20 Linesbool Test::testMatch(bool MatchResult, MatcherBase &Matcher, const char *LHSStr,
return false; return false;
} }
#ifdef ENABLE_SUBPROCESS_TESTS #ifdef ENABLE_SUBPROCESS_TESTS
bool Test::testProcessKilled(testutils::FunctionCaller *Func, int Signal, bool Test::testProcessKilled(testutils::FunctionCaller *Func, int Signal,
const char *LHSStr, const char *RHSStr, const char *LHSStr, const char *RHSStr,
const char *File, unsigned long Line) { 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(); Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n" << error << '\n'; std::cout << File << ":" << Line << ": FAILURE\n" << error << '\n';
return false; return false;
} }
if (Result.timedOut()) { if (Result.timed_out()) {
Ctx->markFail(); Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n" std::cout << File << ":" << Line << ": FAILURE\n"
<< "Process timed out after " << 500 << " milliseconds.\n"; << "Process timed out after " << 500 << " milliseconds.\n";
return false; return false;
} }
if (Result.exitedNormally()) { if (Result.exited_normally()) {
Ctx->markFail(); Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n" std::cout << File << ":" << Line << ": FAILURE\n"
<< "Expected " << LHSStr << "Expected " << LHSStr
<< " to be killed by a signal\nBut it exited normally!\n"; << " to be killed by a signal\nBut it exited normally!\n";
return false; return false;
} }
int KilledBy = Result.getFatalSignal(); int KilledBy = Result.get_fatal_signal();
assert(KilledBy != 0 && "Not killed by any signal"); assert(KilledBy != 0 && "Not killed by any signal");
if (Signal == -1 || KilledBy == Signal) if (Signal == -1 || KilledBy == Signal)
return true; return true;
using testutils::signalAsString; using testutils::signal_as_string;
Ctx->markFail(); Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n" std::cout << File << ":" << Line << ": FAILURE\n"
<< " Expected: " << LHSStr << '\n' << " Expected: " << LHSStr << '\n'
<< "To be killed by signal: " << Signal << '\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' << " But it was killed by: " << KilledBy << '\n'
<< " Which is: " << signalAsString(KilledBy) << '\n'; << " Which is: " << signal_as_string(KilledBy) << '\n';
return false; return false;
} }
bool Test::testProcessExits(testutils::FunctionCaller *Func, int ExitCode, bool Test::testProcessExits(testutils::FunctionCaller *Func, int ExitCode,
const char *LHSStr, const char *RHSStr, const char *LHSStr, const char *RHSStr,
const char *File, unsigned long Line) { 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(); Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n" << error << '\n'; std::cout << File << ":" << Line << ": FAILURE\n" << error << '\n';
return false; return false;
} }
if (Result.timedOut()) { if (Result.timed_out()) {
Ctx->markFail(); Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n" std::cout << File << ":" << Line << ": FAILURE\n"
<< "Process timed out after " << 500 << " milliseconds.\n"; << "Process timed out after " << 500 << " milliseconds.\n";
return false; return false;
} }
if (!Result.exitedNormally()) { if (!Result.exited_normally()) {
Ctx->markFail(); Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n" std::cout << File << ":" << Line << ": FAILURE\n"
<< "Expected " << LHSStr << '\n' << "Expected " << LHSStr << '\n'
<< "to exit with exit code " << ExitCode << '\n' << "to exit with exit code " << ExitCode << '\n'
<< "But it exited abnormally!\n"; << "But it exited abnormally!\n";
return false; return false;
} }
int ActualExit = Result.getExitCode(); int ActualExit = Result.get_exit_code();
if (ActualExit == ExitCode) if (ActualExit == ExitCode)
return true; return true;
Ctx->markFail(); Ctx->markFail();
std::cout << File << ":" << Line << ": FAILURE\n" std::cout << File << ":" << Line << ": FAILURE\n"
<< "Expected exit code of: " << LHSStr << '\n' << "Expected exit code of: " << LHSStr << '\n'
<< " Which is: " << ActualExit << '\n' << " Which is: " << ActualExit << '\n'
<< " To be equal to: " << RHSStr << '\n' << " To be equal to: " << RHSStr << '\n'
<< " Which is: " << ExitCode << '\n'; << " Which is: " << ExitCode << '\n';
return false; return false;
} }
#endif // ENABLE_SUBPROCESS_TESTS #endif // ENABLE_SUBPROCESS_TESTS
} // namespace testing } // namespace testing
} // namespace __llvm_libc } // namespace __llvm_libc

libc/utils/testutils/ExecuteFunction.h

Show All 15 Lines
class FunctionCaller { class FunctionCaller {
public: public:
virtual ~FunctionCaller() {} virtual ~FunctionCaller() {}
virtual void operator()() = 0; virtual void operator()() = 0;
}; };
struct ProcessStatus { struct ProcessStatus {
int PlatformDefined; int platform_defined;
const char *failure = nullptr; 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 error(const char *error) { return {0, error}; }
static ProcessStatus TimedOut() { static ProcessStatus timed_out_ps() {
return {0, reinterpret_cast<const char *>(timeout)}; return {0, reinterpret_cast<const char *>(TIMEOUT)};
} }
bool timedOut() const { bool timed_out() const {
return failure == reinterpret_cast<const char *>(timeout); return failure == reinterpret_cast<const char *>(TIMEOUT);
} }
const char *getError() const { return timedOut() ? nullptr : failure; } const char *get_error() const { return timed_out() ? nullptr : failure; }
bool exitedNormally() const; bool exited_normally() const;
int getExitCode() const; int get_exit_code() const;
int getFatalSignal() 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 testutils
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_TESTUTILS_EXECUTEFUNCTION_H #endif // LLVM_LIBC_UTILS_TESTUTILS_EXECUTEFUNCTION_H

libc/utils/testutils/ExecuteFunctionUnix.cpp

Show All 14 Lines
#include <poll.h> #include <poll.h>
#include <signal.h> #include <signal.h>
#include <sys/wait.h> #include <sys/wait.h>
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
namespace testutils { namespace testutils {
bool ProcessStatus::exitedNormally() const { bool ProcessStatus::exited_normally() const {
return WIFEXITED(PlatformDefined); return WIFEXITED(platform_defined);
} }
int ProcessStatus::getExitCode() const { int ProcessStatus::get_exit_code() const {
assert(exitedNormally() && "Abnormal termination, no exit code"); assert(exited_normally() && "Abnormal termination, no exit code");
return WEXITSTATUS(PlatformDefined); return WEXITSTATUS(platform_defined);
} }
int ProcessStatus::getFatalSignal() const { int ProcessStatus::get_fatal_signal() const {
if (exitedNormally()) if (exited_normally())
return 0; 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); std::unique_ptr<FunctionCaller> X(Func);
int pipeFDs[2]; int pipeFDs[2];
if (::pipe(pipeFDs) == -1) 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. // Don't copy the buffers into the child process and print twice.
std::cout.flush(); std::cout.flush();
std::cerr.flush(); std::cerr.flush();
pid_t Pid = ::fork(); pid_t Pid = ::fork();
if (Pid == -1) if (Pid == -1)
return ProcessStatus::Error("fork(2) failed"); return ProcessStatus::error("fork(2) failed");
if (!Pid) { if (!Pid) {
(*Func)(); (*Func)();
std::exit(0); std::exit(0);
} }
::close(pipeFDs[1]); ::close(pipeFDs[1]);
struct pollfd pollFD { struct pollfd pollFD {
pipeFDs[0], 0, 0 pipeFDs[0], 0, 0
}; };
// No events requested so this call will only return after the timeout or if // No events requested so this call will only return after the timeout or if
// the pipes peer was closed, signaling the process exited. // the pipes peer was closed, signaling the process exited.
if (::poll(&pollFD, 1, timeoutMS) == -1) 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 the pipe wasn't closed by the child yet then timeout has expired.
if (!(pollFD.revents & POLLHUP)) { if (!(pollFD.revents & POLLHUP)) {
::kill(Pid, SIGKILL); ::kill(Pid, SIGKILL);
return ProcessStatus::TimedOut(); return ProcessStatus::timed_out_ps();
} }
int WStatus = 0; int WStatus = 0;
// Wait on the pid of the subprocess here so it gets collected by the system // Wait on the pid of the subprocess here so it gets collected by the system
// and doesn't turn into a zombie. // and doesn't turn into a zombie.
pid_t status = ::waitpid(Pid, &WStatus, 0); pid_t status = ::waitpid(Pid, &WStatus, 0);
if (status == -1) if (status == -1)
return ProcessStatus::Error("waitpid(2) failed"); return ProcessStatus::error("waitpid(2) failed");
assert(status == Pid); assert(status == Pid);
(void)status; (void)status;
return {WStatus}; return {WStatus};
} }
const char *signalAsString(int Signum) { return ::strsignal(Signum); } const char *signal_as_string(int Signum) { return ::strsignal(Signum); }
} // namespace testutils } // namespace testutils
} // namespace __llvm_libc } // namespace __llvm_libc

libc/utils/testutils/FDReader.h

Show All 13 Lines
class FDReader { class FDReader {
int pipefd[2]; int pipefd[2];
public: public:
FDReader(); FDReader();
~FDReader(); ~FDReader();
int getWriteFD() { return pipefd[1]; } int get_write_fd() { return pipefd[1]; }
bool matchWritten(const char *); bool match_written(const char *);
}; };
} // namespace testutils } // namespace testutils
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_TESTUTILS_FDREADER_H #endif // LLVM_LIBC_UTILS_TESTUTILS_FDREADER_H

libc/utils/testutils/FDReaderUnix.cpp

Show All 21 LinesFDReader::FDReader() {
} }
} }
FDReader::~FDReader() { FDReader::~FDReader() {
::close(pipefd[0]); ::close(pipefd[0]);
::close(pipefd[1]); ::close(pipefd[1]);
} }
bool FDReader::matchWritten(const char *str) { bool FDReader::match_written(const char *str) {
::close(pipefd[1]); ::close(pipefd[1]);
constexpr ssize_t ChunkSize = 4096 * 4; constexpr ssize_t ChunkSize = 4096 * 4;
char Buffer[ChunkSize]; char Buffer[ChunkSize];
std::string PipeStr; std::string PipeStr;
std::string InputStr(str); std::string InputStr(str);
Show All 15 Lines

libc/utils/testutils/StreamWrapper.h

Show All 11 Lines
namespace __llvm_libc { namespace __llvm_libc {
namespace testutils { namespace testutils {
// StreamWrapper is necessary because llvm/Support/raw_ostream.h includes // StreamWrapper is necessary because llvm/Support/raw_ostream.h includes
// standard headers so we must provide streams through indirection to not // standard headers so we must provide streams through indirection to not
// expose the system libc headers. // expose the system libc headers.
class StreamWrapper { class StreamWrapper {
protected: protected:
void *OS; void *os;
public: public:
StreamWrapper(void *OS) : OS(OS) {} StreamWrapper(void *OS) : os(OS) {}
template <typename T> StreamWrapper &operator<<(T t); template <typename T> StreamWrapper &operator<<(T t);
}; };
StreamWrapper outs(); StreamWrapper outs();
class OutputFileStream : public StreamWrapper { class OutputFileStream : public StreamWrapper {
public: public:
explicit OutputFileStream(const char *FN); explicit OutputFileStream(const char *FN);
~OutputFileStream(); ~OutputFileStream();
}; };
} // namespace testutils } // namespace testutils
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_TESTUTILS_STREAMWRAPPER_H #endif // LLVM_LIBC_UTILS_TESTUTILS_STREAMWRAPPER_H

libc/utils/testutils/StreamWrapper.cpp

Show All 13 Lines
#include <string> #include <string>
namespace __llvm_libc { namespace __llvm_libc {
namespace testutils { namespace testutils {
StreamWrapper outs() { return {std::addressof(std::cout)}; } StreamWrapper outs() { return {std::addressof(std::cout)}; }
template <typename T> StreamWrapper &StreamWrapper::operator<<(T t) { template <typename T> StreamWrapper &StreamWrapper::operator<<(T t) {
assert(OS); assert(os);
std::ostream &Stream = *reinterpret_cast<std::ostream *>(OS); std::ostream &Stream = *reinterpret_cast<std::ostream *>(os);
Stream << t; Stream << t;
Stream.flush(); Stream.flush();
return *this; return *this;
} }
template StreamWrapper &StreamWrapper::operator<<<void *>(void *t); template StreamWrapper &StreamWrapper::operator<<<void *>(void *t);
template StreamWrapper &StreamWrapper::operator<<<const char *>(const char *t); template StreamWrapper &StreamWrapper::operator<<<const char *>(const char *t);
template StreamWrapper &StreamWrapper::operator<<<char *>(char *t); template StreamWrapper &StreamWrapper::operator<<<char *>(char *t);
Show All 15 Lines
template StreamWrapper &StreamWrapper::operator<<<std::string>(std::string t); template StreamWrapper &StreamWrapper::operator<<<std::string>(std::string t);
template StreamWrapper &StreamWrapper::operator<<<float>(float t); template StreamWrapper &StreamWrapper::operator<<<float>(float t);
template StreamWrapper &StreamWrapper::operator<<<double>(double t); template StreamWrapper &StreamWrapper::operator<<<double>(double t);
OutputFileStream::OutputFileStream(const char *FN) OutputFileStream::OutputFileStream(const char *FN)
: StreamWrapper(new std::ofstream(FN)) {} : StreamWrapper(new std::ofstream(FN)) {}
OutputFileStream::~OutputFileStream() { OutputFileStream::~OutputFileStream() {
delete reinterpret_cast<std::ofstream *>(OS); delete reinterpret_cast<std::ofstream *>(os);
} }
} // namespace testutils } // namespace testutils
} // namespace __llvm_libc } // namespace __llvm_libc