maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[libc][NFC] add "LlvmLibc" as a prefix to all test names 

Summary:
Having a consistent prefix makes selecting all of the llvm libc tests
easier on any platform that is also using the gtest framework.
This also modifies the TEST and TEST_F macros to enforce this change
moving forward.

Reviewers: sivachandra

Subscribers:
This commit is contained in:
Michael Jones 2021-01-15 21:54:23 +00:00
parent bb3f169b59
commit 1df0dbfcb5
121 changed files with 487 additions and 443 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libc/test/config/linux/x86_64/syscall_test.cpp
View File

@ -11,7 +11,7 @@
#include "utils/CPP/Functional.h"
TEST(X86_64_SyscallTest, APITest) {
TEST(LlvmLibcX86_64_SyscallTest, APITest) {
// We only do a signature test here. Actual functionality tests are
// done by the unit tests of the syscall wrappers like mmap.

4
libc/test/src/assert/assert_test.cpp
View File

@ -12,7 +12,7 @@
extern "C" int close(int);
TEST(Assert, Enabled) {
TEST(LlvmLibcAssert, Enabled) {
// -1 matches against any signal, which is necessary for now until
// __llvm_libc::abort() unblocks SIGABRT. Close standard error for the
// child process so we don't print the assertion failure message.
@ -27,6 +27,6 @@ TEST(Assert, Enabled) {
#define NDEBUG
#include "src/assert/assert.h"
TEST(Assert, Disabled) {
TEST(LlvmLibcAssert, Disabled) {
EXPECT_EXITS([] { assert(0); }, 0);
}

2
libc/test/src/ctype/isalnum_test.cpp
View File

@ -10,7 +10,7 @@
#include "utils/UnitTest/Test.h"
TEST(IsAlNum, DefaultLocale) {
TEST(LlvmLibcIsAlNum, DefaultLocale) {
// Loops through all characters, verifying that numbers and letters
// return non-zero integer and everything else returns a zero.
for (int c = 0; c < 255; ++c) {

2
libc/test/src/ctype/isalpha_test.cpp
View File

@ -10,7 +10,7 @@
#include "utils/UnitTest/Test.h"
TEST(IsAlpha, DefaultLocale) {
TEST(LlvmLibcIsAlpha, DefaultLocale) {
// Loops through all characters, verifying that letters return a
// non-zero integer and everything else returns zero.
for (int ch = 0; ch < 255; ++ch) {

2
libc/test/src/ctype/isascii_test.cpp
View File

@ -10,7 +10,7 @@
#include "src/ctype/isascii.h"
TEST(IsAscii, DefaultLocale) {
TEST(LlvmLibcIsAscii, DefaultLocale) {
// Loops through all characters, verifying that ascii characters
// (which are all 7 bit unsigned integers)
// return a non-zero integer and everything else returns zero.

2
libc/test/src/ctype/isblank_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/ctype/isblank.h"
#include "utils/UnitTest/Test.h"
TEST(IsBlank, DefaultLocale) {
TEST(LlvmLibcIsBlank, DefaultLocale) {
// Loops through all characters, verifying that space and horizontal tab
// return a non-zero integer and everything else returns zero.
for (int ch = 0; ch < 255; ++ch) {

2
libc/test/src/ctype/iscntrl_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/ctype/iscntrl.h"
#include "utils/UnitTest/Test.h"
TEST(IsCntrl, DefaultLocale) {
TEST(LlvmLibcIsCntrl, DefaultLocale) {
// Loops through all characters, verifying that control characters
// return a non-zero integer, all others return zero.
for (int ch = 0; ch < 255; ++ch) {

2
libc/test/src/ctype/isdigit_test.cpp
View File

@ -10,7 +10,7 @@
#include "utils/UnitTest/Test.h"
TEST(IsDigit, DefaultLocale) {
TEST(LlvmLibcIsDigit, DefaultLocale) {
// Loops through all characters, verifying that numbers return a
// non-zero integer and everything else returns zero.
for (int ch = 0; ch < 255; ++ch) {

2
libc/test/src/ctype/isgraph_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/ctype/isgraph.h"
#include "utils/UnitTest/Test.h"
TEST(IsGraph, DefaultLocale) {
TEST(LlvmLibcIsGraph, DefaultLocale) {
// Loops through all characters, verifying that graphical characters
// return a non-zero integer, everything else returns zero.
for (int ch = 0; ch < 255; ++ch) {

2
libc/test/src/ctype/islower_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/ctype/islower.h"
#include "utils/UnitTest/Test.h"
TEST(IsLower, DefaultLocale) {
TEST(LlvmLibcIsLower, DefaultLocale) {
// Loops through all characters, verifying that lowercase letters
// return a non-zero integer and everything else returns zero.
for (int ch = 0; ch < 255; ++ch) {

2
libc/test/src/ctype/isprint_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/ctype/isprint.h"
#include "utils/UnitTest/Test.h"
TEST(IsPrint, DefaultLocale) {
TEST(LlvmLibcIsPrint, DefaultLocale) {
for (int ch = 0; ch < 255; ++ch) {
if (' ' <= ch && ch <= '~') // A-Z, a-z, 0-9, punctuation, space.
EXPECT_NE(__llvm_libc::isprint(ch), 0);

2
libc/test/src/ctype/ispunct_test.cpp
View File

@ -22,7 +22,7 @@ static inline int is_punctuation_character(int c) {
('[' <= c && c <= '`') || ('{' <= c && c <= '~');
}
TEST(IsPunct, DefaultLocale) {
TEST(LlvmLibcIsPunct, DefaultLocale) {
// Loops through all characters, verifying that punctuation characters
// return a non-zero integer, and everything else returns zero.
for (int ch = 0; ch < 255; ++ch) {

2
libc/test/src/ctype/isspace_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/ctype/isspace.h"
#include "utils/UnitTest/Test.h"
TEST(IsSpace, DefaultLocale) {
TEST(LlvmLibcIsSpace, DefaultLocale) {
// Loops through all characters, verifying that space characters
// return true and everything else returns false.
// Hexadecimal | Symbol

2
libc/test/src/ctype/isupper_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/ctype/isupper.h"
#include "utils/UnitTest/Test.h"
TEST(IsUpper, DefaultLocale) {
TEST(LlvmLibcIsUpper, DefaultLocale) {
// Loops through all characters, verifying that uppercase letters
// return a non-zero integer and everything else returns zero.
for (int ch = 0; ch < 255; ++ch) {

2
libc/test/src/ctype/isxdigit_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/ctype/isxdigit.h"
#include "utils/UnitTest/Test.h"
TEST(IsXDigit, DefaultLocale) {
TEST(LlvmLibcIsXDigit, DefaultLocale) {
for (int ch = 0; ch < 255; ++ch) {
if (('0' <= ch && ch <= '9') || ('a' <= ch && ch <= 'f') ||
('A' <= ch && ch <= 'F'))

2
libc/test/src/ctype/toascii_test.cpp
View File

@ -10,7 +10,7 @@
#include "utils/UnitTest/Test.h"
TEST(ToAscii, DefaultLocale) {
TEST(LlvmLibcToAscii, DefaultLocale) {
// Loops through all characters, verifying that ascii characters
// (which are all 7 bit unsigned integers)
// return themself, and that all other characters return themself

2
libc/test/src/ctype/tolower_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/ctype/tolower.h"
#include "utils/UnitTest/Test.h"
TEST(ToLower, DefaultLocale) {
TEST(LlvmLibcToLower, DefaultLocale) {
for (int ch = 0; ch < 255; ++ch) {
// This follows pattern 'A' + 32 = 'a'.
if ('A' <= ch && ch <= 'Z')

2
libc/test/src/ctype/toupper_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/ctype/toupper.h"
#include "utils/UnitTest/Test.h"
TEST(ToUpper, DefaultLocale) {
TEST(LlvmLibcToUpper, DefaultLocale) {
for (int ch = 0; ch < 255; ++ch) {
// This follows pattern 'a' - 32 = 'A'.
if ('a' <= ch && ch <= 'z')

2
libc/test/src/errno/errno_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/errno/llvmlibc_errno.h"
#include "utils/UnitTest/Test.h"
TEST(ErrnoTest, Basic) {
TEST(LlvmLibcErrnoTest, Basic) {
int test_val = 123;
llvmlibc_errno = test_val;
ASSERT_EQ(test_val, llvmlibc_errno);

2
libc/test/src/fenv/enabled_exceptions_test.cpp
View File

@ -18,7 +18,7 @@
// This test enables an exception and verifies that raising that exception
// triggers SIGFPE.
TEST(ExceptionStatusTest, RaiseAndCrash) {
TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
// TODO: Install a floating point exception handler and verify that the
// the expected exception was raised. One will have to longjmp back from
// that exception handler, so such a testing can be done after we have

2
libc/test/src/fenv/exception_status_test.cpp
View File

@ -15,7 +15,7 @@
#include <fenv.h>
TEST(ExceptionStatusTest, RaiseAndTest) {
TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
// This test raises a set of exceptions and checks that the exception
// status flags are updated. The intention is really not to invoke the
// exception handler. Hence, we will disable all exceptions at the

2
libc/test/src/fenv/rounding_mode_test.cpp
View File

@ -13,7 +13,7 @@
#include <fenv.h>
TEST(RoundingModeTest, SetAndGet) {
TEST(LlvmLibcRoundingModeTest, SetAndGet) {
int s = __llvm_libc::fesetround(FE_TONEAREST);
EXPECT_EQ(s, 0);
int rm = __llvm_libc::fegetround();

2
libc/test/src/math/FDimTest.h
View File

@ -79,4 +79,4 @@ private:
const T negInf = __llvm_libc::fputil::FPBits<T>::negInf();
const T zero = __llvm_libc::fputil::FPBits<T>::zero();
const T negZero = __llvm_libc::fputil::FPBits<T>::negZero();
};
};

2
libc/test/src/math/ILogbTest.h
View File

@ -16,7 +16,7 @@
#include <limits.h>
class ILogbTest : public __llvm_libc::testing::Test {
class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
public:
template <typename T> struct ILogbFunc { typedef int (*Func)(T); };

14
libc/test/src/math/LdExpTest.h
View File

@ -140,16 +140,16 @@ public:
};
#define LIST_LDEXP_TESTS(T, func) \
using LdExpTest = LdExpTestTemplate<T>; \
TEST_F(LdExpTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LdExpTest, PowersOfTwo) { testPowersOfTwo(&func); } \
TEST_F(LdExpTest, OverFlow) { testOverflow(&func); } \
TEST_F(LdExpTest, UnderflowToZeroOnNormal) { \
using LlvmLibcLdExpTest = LdExpTestTemplate<T>; \
TEST_F(LlvmLibcLdExpTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcLdExpTest, PowersOfTwo) { testPowersOfTwo(&func); } \
TEST_F(LlvmLibcLdExpTest, OverFlow) { testOverflow(&func); } \
TEST_F(LlvmLibcLdExpTest, UnderflowToZeroOnNormal) { \
testUnderflowToZeroOnNormal(&func); \
} \
TEST_F(LdExpTest, UnderflowToZeroOnSubnormal) { \
TEST_F(LlvmLibcLdExpTest, UnderflowToZeroOnSubnormal) { \
testUnderflowToZeroOnSubnormal(&func); \
} \
TEST_F(LdExpTest, NormalOperation) { testNormalOperation(&func); }
TEST_F(LlvmLibcLdExpTest, NormalOperation) { testNormalOperation(&func); }
#endif // LLVM_LIBC_TEST_SRC_MATH_LDEXPTEST_H

6
libc/test/src/math/NextAfterTest.h
View File

@ -186,8 +186,8 @@ public:
};
#define LIST_NEXTAFTER_TESTS(T, func) \
using NextAfterTest = NextAfterTestTemplate<T>; \
TEST_F(NextAfterTest, TestNaN) { testNaN(&func); } \
TEST_F(NextAfterTest, TestBoundaries) { testBoundaries(&func); }
using LlvmLibcNextAfterTest = NextAfterTestTemplate<T>; \
TEST_F(LlvmLibcNextAfterTest, TestNaN) { testNaN(&func); } \
TEST_F(LlvmLibcNextAfterTest, TestBoundaries) { testBoundaries(&func); }
#endif // LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H

8
libc/test/src/math/ceil_test.cpp
View File

@ -19,7 +19,7 @@ namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double)
TEST(CeilTest, SpecialNumbers) {
TEST(LlvmLibcCeilTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::ceil(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::ceil(negZero));
@ -29,7 +29,7 @@ TEST(CeilTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::ceil(aNaN));
}
TEST(CeilTest, RoundedNumbers) {
TEST(LlvmLibcCeilTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0, __llvm_libc::ceil(1.0));
EXPECT_FP_EQ(-1.0, __llvm_libc::ceil(-1.0));
EXPECT_FP_EQ(10.0, __llvm_libc::ceil(10.0));
@ -38,7 +38,7 @@ TEST(CeilTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0, __llvm_libc::ceil(-1234.0));
}
TEST(CeilTest, Fractions) {
TEST(LlvmLibcCeilTest, Fractions) {
EXPECT_FP_EQ(1.0, __llvm_libc::ceil(0.5));
EXPECT_FP_EQ(-0.0, __llvm_libc::ceil(-0.5));
EXPECT_FP_EQ(1.0, __llvm_libc::ceil(0.115));
@ -61,7 +61,7 @@ TEST(CeilTest, Fractions) {
EXPECT_FP_EQ(-1234.0, __llvm_libc::ceil(-1234.96));
}
TEST(CeilTest, InDoubleRange) {
TEST(LlvmLibcCeilTest, InDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/ceilf_test.cpp
View File

@ -19,7 +19,7 @@ namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float)
TEST(CeilfTest, SpecialNumbers) {
TEST(LlvmLibcCeilfTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::ceilf(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::ceilf(negZero));
@ -29,7 +29,7 @@ TEST(CeilfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::ceilf(aNaN));
}
TEST(CeilfTest, RoundedNumbers) {
TEST(LlvmLibcCeilfTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0f, __llvm_libc::ceilf(1.0f));
EXPECT_FP_EQ(-1.0f, __llvm_libc::ceilf(-1.0f));
EXPECT_FP_EQ(10.0f, __llvm_libc::ceilf(10.0f));
@ -38,7 +38,7 @@ TEST(CeilfTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0f, __llvm_libc::ceilf(-1234.0f));
}
TEST(CeilfTest, Fractions) {
TEST(LlvmLibcCeilfTest, Fractions) {
EXPECT_FP_EQ(1.0f, __llvm_libc::ceilf(0.5f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::ceilf(-0.5f));
EXPECT_FP_EQ(1.0f, __llvm_libc::ceilf(0.115f));
@ -61,7 +61,7 @@ TEST(CeilfTest, Fractions) {
EXPECT_FP_EQ(-1234.0f, __llvm_libc::ceilf(-1234.96f));
}
TEST(CeilfTest, InFloatRange) {
TEST(LlvmLibcCeilfTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 1000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/ceill_test.cpp
View File

@ -19,7 +19,7 @@ namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(long double)
TEST(CeillTest, SpecialNumbers) {
TEST(LlvmLibcCeillTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::ceill(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::ceill(negZero));
@ -29,7 +29,7 @@ TEST(CeillTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::ceill(aNaN));
}
TEST(CeillTest, RoundedNumbers) {
TEST(LlvmLibcCeillTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(1.0l));
EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.0l));
EXPECT_FP_EQ(10.0l, __llvm_libc::ceill(10.0l));
@ -38,7 +38,7 @@ TEST(CeillTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0l, __llvm_libc::ceill(-1234.0l));
}
TEST(CeillTest, Fractions) {
TEST(LlvmLibcCeillTest, Fractions) {
EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(0.5l));
EXPECT_FP_EQ(-0.0l, __llvm_libc::ceill(-0.5l));
EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(0.115l));
@ -61,7 +61,7 @@ TEST(CeillTest, Fractions) {
EXPECT_FP_EQ(-1234.0l, __llvm_libc::ceill(-1234.96l));
}
TEST(CeillTest, InLongDoubleRange) {
TEST(LlvmLibcCeillTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

4
libc/test/src/math/copysign_test.cpp
View File

@ -16,7 +16,7 @@ using FPBits = __llvm_libc::fputil::FPBits<double>;
DECLARE_SPECIAL_CONSTANTS(double)
TEST(CopySignTest, SpecialNumbers) {
TEST(LlvmLibcCopySignTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::copysign(aNaN, -1.0));
EXPECT_FP_EQ(aNaN, __llvm_libc::copysign(aNaN, 1.0));
@ -27,7 +27,7 @@ TEST(CopySignTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::copysign(negZero, 1.0));
}
TEST(CopySignTest, InDoubleRange) {
TEST(LlvmLibcCopySignTest, InDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

4
libc/test/src/math/copysignf_test.cpp
View File

@ -16,7 +16,7 @@ using FPBits = __llvm_libc::fputil::FPBits<float>;
DECLARE_SPECIAL_CONSTANTS(float)
TEST(CopySinfTest, SpecialNumbers) {
TEST(LlvmLibcCopySinfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::copysignf(aNaN, -1.0));
EXPECT_FP_EQ(aNaN, __llvm_libc::copysignf(aNaN, 1.0));
@ -27,7 +27,7 @@ TEST(CopySinfTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::copysignf(negZero, 1.0));
}
TEST(CopySinfTest, InFloatRange) {
TEST(LlvmLibcCopySinfTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 1000000;
constexpr UIntType step = UIntType(-1) / count;

4
libc/test/src/math/copysignl_test.cpp
View File

@ -16,7 +16,7 @@ using FPBits = __llvm_libc::fputil::FPBits<long double>;
DECLARE_SPECIAL_CONSTANTS(long double)
TEST(CopySinlTest, SpecialNumbers) {
TEST(LlvmLibcCopySinlTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::copysignl(aNaN, -1.0));
EXPECT_FP_EQ(aNaN, __llvm_libc::copysignl(aNaN, 1.0));
@ -27,7 +27,7 @@ TEST(CopySinlTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::copysignl(negZero, 1.0));
}
TEST(CopySinlTest, InLongDoubleRange) {
TEST(LlvmLibcCopySinlTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/cosf_test.cpp
View File

@ -32,7 +32,7 @@ using __llvm_libc::testing::sdcomp26094Values;
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(CosfTest, SpecialNumbers) {
TEST(LlvmLibcCosfTest, SpecialNumbers) {
llvmlibc_errno = 0;
EXPECT_TRUE(
@ -69,7 +69,7 @@ TEST(CosfTest, SpecialNumbers) {
EXPECT_EQ(llvmlibc_errno, EDOM);
}
TEST(CosfTest, InFloatRange) {
TEST(LlvmLibcCosfTest, InFloatRange) {
constexpr uint32_t count = 1000000;
constexpr uint32_t step = UINT32_MAX / count;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
@ -81,7 +81,7 @@ TEST(CosfTest, InFloatRange) {
}
// For small values, cos(x) is 1.
TEST(CosfTest, SmallValues) {
TEST(LlvmLibcCosfTest, SmallValues) {
float x = valueFromBits(0x17800000U);
float result = __llvm_libc::cosf(x);
EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, result, 1.0);
@ -95,7 +95,7 @@ TEST(CosfTest, SmallValues) {
// SDCOMP-26094: check cosf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4.
TEST(CosfTest, SDCOMP_26094) {
TEST(LlvmLibcCosfTest, SDCOMP_26094) {
for (uint32_t v : sdcomp26094Values) {
float x = valueFromBits(v);
ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), 1.0);

10
libc/test/src/math/exp2f_test.cpp
View File

@ -28,7 +28,7 @@ using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(exp2fTest, SpecialNumbers) {
TEST(LlvmLibcexp2fTest, SpecialNumbers) {
llvmlibc_errno = 0;
EXPECT_TRUE(
@ -64,7 +64,7 @@ TEST(exp2fTest, SpecialNumbers) {
EXPECT_EQ(llvmlibc_errno, 0);
}
TEST(ExpfTest, Overflow) {
TEST(LlvmLibcExpfTest, Overflow) {
llvmlibc_errno = 0;
EXPECT_EQ(BitPatterns::inf,
valueAsBits(__llvm_libc::exp2f(valueFromBits(0x7f7fffffU))));
@ -83,7 +83,7 @@ TEST(ExpfTest, Overflow) {
// Test with inputs which are the borders of underflow/overflow but still
// produce valid results without setting errno.
TEST(ExpfTest, Borderline) {
TEST(LlvmLibcExpfTest, Borderline) {
float x;
llvmlibc_errno = 0;
@ -112,7 +112,7 @@ TEST(ExpfTest, Borderline) {
EXPECT_EQ(llvmlibc_errno, 0);
}
TEST(ExpfTest, Underflow) {
TEST(LlvmLibcExpfTest, Underflow) {
llvmlibc_errno = 0;
EXPECT_EQ(BitPatterns::zero,
valueAsBits(__llvm_libc::exp2f(valueFromBits(0xff7fffffU))));
@ -129,7 +129,7 @@ TEST(ExpfTest, Underflow) {
EXPECT_EQ(llvmlibc_errno, ERANGE);
}
TEST(exp2fTest, InFloatRange) {
TEST(LlvmLibcexp2fTest, InFloatRange) {
constexpr uint32_t count = 1000000;
constexpr uint32_t step = UINT32_MAX / count;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {

10
libc/test/src/math/expf_test.cpp
View File

@ -28,7 +28,7 @@ using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(ExpfTest, SpecialNumbers) {
TEST(LlvmLibcExpfTest, SpecialNumbers) {
llvmlibc_errno = 0;
EXPECT_TRUE(
@ -64,7 +64,7 @@ TEST(ExpfTest, SpecialNumbers) {
EXPECT_EQ(llvmlibc_errno, 0);
}
TEST(ExpfTest, Overflow) {
TEST(LlvmLibcExpfTest, Overflow) {
llvmlibc_errno = 0;
EXPECT_EQ(BitPatterns::inf,
valueAsBits(__llvm_libc::expf(valueFromBits(0x7f7fffffU))));
@ -81,7 +81,7 @@ TEST(ExpfTest, Overflow) {
EXPECT_EQ(llvmlibc_errno, ERANGE);
}
TEST(ExpfTest, Underflow) {
TEST(LlvmLibcExpfTest, Underflow) {
llvmlibc_errno = 0;
EXPECT_EQ(BitPatterns::zero,
valueAsBits(__llvm_libc::expf(valueFromBits(0xff7fffffU))));
@ -100,7 +100,7 @@ TEST(ExpfTest, Underflow) {
// Test with inputs which are the borders of underflow/overflow but still
// produce valid results without setting errno.
TEST(ExpfTest, Borderline) {
TEST(LlvmLibcExpfTest, Borderline) {
float x;
llvmlibc_errno = 0;
@ -121,7 +121,7 @@ TEST(ExpfTest, Borderline) {
EXPECT_EQ(llvmlibc_errno, 0);
}
TEST(ExpfTest, InFloatRange) {
TEST(LlvmLibcExpfTest, InFloatRange) {
constexpr uint32_t count = 1000000;
constexpr uint32_t step = UINT32_MAX / count;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {

4
libc/test/src/math/fabs_test.cpp
View File

@ -19,7 +19,7 @@ DECLARE_SPECIAL_CONSTANTS(double)
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(FabsTest, SpecialNumbers) {
TEST(LlvmLibcFabsTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fabs(aNaN));
EXPECT_FP_EQ(inf, __llvm_libc::fabs(inf));
@ -29,7 +29,7 @@ TEST(FabsTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::fabs(negZero));
}
TEST(FabsTest, InDoubleRange) {
TEST(LlvmLibcFabsTest, InDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

4
libc/test/src/math/fabsf_test.cpp
View File

@ -19,7 +19,7 @@ DECLARE_SPECIAL_CONSTANTS(float)
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(FabsfTest, SpecialNumbers) {
TEST(LlvmLibcFabsfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fabsf(aNaN));
EXPECT_FP_EQ(inf, __llvm_libc::fabsf(inf));
@ -29,7 +29,7 @@ TEST(FabsfTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::fabsf(negZero));
}
TEST(FabsfTest, InFloatRange) {
TEST(LlvmLibcFabsfTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 1000000;
constexpr UIntType step = UIntType(-1) / count;

4
libc/test/src/math/fabsl_test.cpp
View File

@ -19,7 +19,7 @@ DECLARE_SPECIAL_CONSTANTS(long double)
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(FabslTest, SpecialNumbers) {
TEST(LlvmLibcFabslTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fabsl(aNaN));
EXPECT_FP_EQ(inf, __llvm_libc::fabsl(inf));
@ -29,7 +29,7 @@ TEST(FabslTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::fabsl(negZero));
}
TEST(FabslTest, InLongDoubleRange) {
TEST(LlvmLibcFabslTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

14
libc/test/src/math/fdim_test.cpp
View File

@ -14,14 +14,16 @@
#include "utils/UnitTest/Test.h"
#include <math.h>
using FDimTest = FDimTestTemplate<double>;
using LlvmLibcFDimTest = FDimTestTemplate<double>;
TEST_F(FDimTest, NaNArg_fdim) { testNaNArg(&__llvm_libc::fdim); }
TEST_F(LlvmLibcFDimTest, NaNArg_fdim) { testNaNArg(&__llvm_libc::fdim); }
TEST_F(FDimTest, InfArg_fdim) { testInfArg(&__llvm_libc::fdim); }
TEST_F(LlvmLibcFDimTest, InfArg_fdim) { testInfArg(&__llvm_libc::fdim); }
TEST_F(FDimTest, NegInfArg_fdim) { testNegInfArg(&__llvm_libc::fdim); }
TEST_F(LlvmLibcFDimTest, NegInfArg_fdim) { testNegInfArg(&__llvm_libc::fdim); }
TEST_F(FDimTest, BothZero_fdim) { testBothZero(&__llvm_libc::fdim); }
TEST_F(LlvmLibcFDimTest, BothZero_fdim) { testBothZero(&__llvm_libc::fdim); }
TEST_F(FDimTest, InDoubleRange_fdim) { testInRange(&__llvm_libc::fdim); }
TEST_F(LlvmLibcFDimTest, InDoubleRange_fdim) {
testInRange(&__llvm_libc::fdim);
}

16
libc/test/src/math/fdimf_test.cpp
View File

@ -14,14 +14,18 @@
#include "utils/UnitTest/Test.h"
#include <math.h>
using FDimTest = FDimTestTemplate<float>;
using LlvmLibcFDimTest = FDimTestTemplate<float>;
TEST_F(FDimTest, NaNArg_fdimf) { testNaNArg(&__llvm_libc::fdimf); }
TEST_F(LlvmLibcFDimTest, NaNArg_fdimf) { testNaNArg(&__llvm_libc::fdimf); }
TEST_F(FDimTest, InfArg_fdimf) { testInfArg(&__llvm_libc::fdimf); }
TEST_F(LlvmLibcFDimTest, InfArg_fdimf) { testInfArg(&__llvm_libc::fdimf); }
TEST_F(FDimTest, NegInfArg_fdimf) { testNegInfArg(&__llvm_libc::fdimf); }
TEST_F(LlvmLibcFDimTest, NegInfArg_fdimf) {
testNegInfArg(&__llvm_libc::fdimf);
}
TEST_F(FDimTest, BothZero_fdimf) { testBothZero(&__llvm_libc::fdimf); }
TEST_F(LlvmLibcFDimTest, BothZero_fdimf) { testBothZero(&__llvm_libc::fdimf); }
TEST_F(FDimTest, InFloatRange_fdimf) { testInRange(&__llvm_libc::fdimf); }
TEST_F(LlvmLibcFDimTest, InFloatRange_fdimf) {
testInRange(&__llvm_libc::fdimf);
}

16
libc/test/src/math/fdiml_test.cpp
View File

@ -14,14 +14,18 @@
#include "utils/UnitTest/Test.h"
#include <math.h>
using FDimTest = FDimTestTemplate<long double>;
using LlvmLibcFDimTest = FDimTestTemplate<long double>;
TEST_F(FDimTest, NaNArg_fdiml) { testNaNArg(&__llvm_libc::fdiml); }
TEST_F(LlvmLibcFDimTest, NaNArg_fdiml) { testNaNArg(&__llvm_libc::fdiml); }
TEST_F(FDimTest, InfArg_fdiml) { testInfArg(&__llvm_libc::fdiml); }
TEST_F(LlvmLibcFDimTest, InfArg_fdiml) { testInfArg(&__llvm_libc::fdiml); }
TEST_F(FDimTest, NegInfArg_fdiml) { testNegInfArg(&__llvm_libc::fdiml); }
TEST_F(LlvmLibcFDimTest, NegInfArg_fdiml) {
testNegInfArg(&__llvm_libc::fdiml);
}
TEST_F(FDimTest, BothZero_fdiml) { testBothZero(&__llvm_libc::fdiml); }
TEST_F(LlvmLibcFDimTest, BothZero_fdiml) { testBothZero(&__llvm_libc::fdiml); }
TEST_F(FDimTest, InLongDoubleRange_fdiml) { testInRange(&__llvm_libc::fdiml); }
TEST_F(LlvmLibcFDimTest, InLongDoubleRange_fdiml) {
testInRange(&__llvm_libc::fdiml);
}

8
libc/test/src/math/floor_test.cpp
View File

@ -19,7 +19,7 @@ DECLARE_SPECIAL_CONSTANTS(double)
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(FloorTest, SpecialNumbers) {
TEST(LlvmLibcFloorTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::floor(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::floor(negZero));
@ -29,7 +29,7 @@ TEST(FloorTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::floor(aNaN));
}
TEST(FloorTest, RoundedNumbers) {
TEST(LlvmLibcFloorTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0, __llvm_libc::floor(1.0));
EXPECT_FP_EQ(-1.0, __llvm_libc::floor(-1.0));
EXPECT_FP_EQ(10.0, __llvm_libc::floor(10.0));
@ -38,7 +38,7 @@ TEST(FloorTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0, __llvm_libc::floor(-1234.0));
}
TEST(FloorTest, Fractions) {
TEST(LlvmLibcFloorTest, Fractions) {
EXPECT_FP_EQ(0.0, __llvm_libc::floor(0.5));
EXPECT_FP_EQ(-1.0, __llvm_libc::floor(-0.5));
EXPECT_FP_EQ(0.0, __llvm_libc::floor(0.115));
@ -61,7 +61,7 @@ TEST(FloorTest, Fractions) {
EXPECT_FP_EQ(-1235.0, __llvm_libc::floor(-1234.96));
}
TEST(FloorTest, InDoubleRange) {
TEST(LlvmLibcFloorTest, InDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/floorf_test.cpp
View File

@ -19,7 +19,7 @@ DECLARE_SPECIAL_CONSTANTS(float)
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(FloorfTest, SpecialNumbers) {
TEST(LlvmLibcFloorfTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::floorf(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::floorf(negZero));
@ -29,7 +29,7 @@ TEST(FloorfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::floorf(aNaN));
}
TEST(FloorfTest, RoundedNumbers) {
TEST(LlvmLibcFloorfTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0f, __llvm_libc::floorf(1.0f));
EXPECT_FP_EQ(-1.0f, __llvm_libc::floorf(-1.0f));
EXPECT_FP_EQ(10.0f, __llvm_libc::floorf(10.0f));
@ -38,7 +38,7 @@ TEST(FloorfTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0f, __llvm_libc::floorf(-1234.0f));
}
TEST(FloorfTest, Fractions) {
TEST(LlvmLibcFloorfTest, Fractions) {
EXPECT_FP_EQ(0.0f, __llvm_libc::floorf(0.5f));
EXPECT_FP_EQ(-1.0f, __llvm_libc::floorf(-0.5f));
EXPECT_FP_EQ(0.0f, __llvm_libc::floorf(0.115f));
@ -61,7 +61,7 @@ TEST(FloorfTest, Fractions) {
EXPECT_FP_EQ(-1235.0f, __llvm_libc::floorf(-1234.96f));
}
TEST(FloorfTest, InFloatRange) {
TEST(LlvmLibcFloorfTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 1000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/floorl_test.cpp
View File

@ -19,7 +19,7 @@ DECLARE_SPECIAL_CONSTANTS(long double)
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(FloorlTest, SpecialNumbers) {
TEST(LlvmLibcFloorlTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::floorl(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::floorl(negZero));
@ -29,7 +29,7 @@ TEST(FloorlTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::floorl(aNaN));
}
TEST(FloorlTest, RoundedNumbers) {
TEST(LlvmLibcFloorlTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0l, __llvm_libc::floorl(1.0l));
EXPECT_FP_EQ(-1.0l, __llvm_libc::floorl(-1.0l));
EXPECT_FP_EQ(10.0l, __llvm_libc::floorl(10.0l));
@ -38,7 +38,7 @@ TEST(FloorlTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0l, __llvm_libc::floorl(-1234.0l));
}
TEST(FloorlTest, Fractions) {
TEST(LlvmLibcFloorlTest, Fractions) {
EXPECT_FP_EQ(0.0l, __llvm_libc::floorl(0.5l));
EXPECT_FP_EQ(-1.0l, __llvm_libc::floorl(-0.5l));
EXPECT_FP_EQ(0.0l, __llvm_libc::floorl(0.115l));
@ -61,7 +61,7 @@ TEST(FloorlTest, Fractions) {
EXPECT_FP_EQ(-1235.0l, __llvm_libc::floorl(-1234.96l));
}
TEST(FloorlTest, InLongDoubleRange) {
TEST(LlvmLibcFloorlTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

10
libc/test/src/math/fmaf_test.cpp
View File

@ -12,8 +12,12 @@
using FmaTest = FmaTestTemplate<float>;
TEST_F(FmaTest, SpecialNumbers) { testSpecialNumbers(&__llvm_libc::fmaf); }
TEST_F(LlvmLibcFmaTest, SpecialNumbers) {
testSpecialNumbers(&__llvm_libc::fmaf);
}
TEST_F(FmaTest, SubnormalRange) { testSubnormalRange(&__llvm_libc::fmaf); }
TEST_F(LlvmLibcFmaTest, SubnormalRange) {
testSubnormalRange(&__llvm_libc::fmaf);
}
TEST_F(FmaTest, NormalRange) { testNormalRange(&__llvm_libc::fmaf); }
TEST_F(LlvmLibcFmaTest, NormalRange) { testNormalRange(&__llvm_libc::fmaf); }

10
libc/test/src/math/fmax_test.cpp
View File

@ -16,7 +16,7 @@ using FPBits = __llvm_libc::fputil::FPBits<double>;
DECLARE_SPECIAL_CONSTANTS(double)
TEST(FmaxTest, NaNArg) {
TEST(LlvmLibcFmaxTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmax(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fmax(negInf, aNaN));
EXPECT_FP_EQ(0.0, __llvm_libc::fmax(aNaN, 0.0));
@ -26,7 +26,7 @@ TEST(FmaxTest, NaNArg) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fmax(aNaN, aNaN));
}
TEST(FmaxTest, InfArg) {
TEST(LlvmLibcFmaxTest, InfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmax(negInf, inf));
EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, 0.0));
EXPECT_FP_EQ(inf, __llvm_libc::fmax(-0.0, inf));
@ -34,7 +34,7 @@ TEST(FmaxTest, InfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmax(-1.2345, inf));
}
TEST(FmaxTest, NegInfArg) {
TEST(LlvmLibcFmaxTest, NegInfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, negInf));
EXPECT_FP_EQ(0.0, __llvm_libc::fmax(negInf, 0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, negInf));
@ -42,14 +42,14 @@ TEST(FmaxTest, NegInfArg) {
EXPECT_FP_EQ(1.2345, __llvm_libc::fmax(1.2345, negInf));
}
TEST(FmaxTest, BothZero) {
TEST(LlvmLibcFmaxTest, BothZero) {
EXPECT_FP_EQ(0.0, __llvm_libc::fmax(0.0, 0.0));
EXPECT_FP_EQ(0.0, __llvm_libc::fmax(-0.0, 0.0));
EXPECT_FP_EQ(0.0, __llvm_libc::fmax(0.0, -0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, -0.0));
}
TEST(FmaxTest, InDoubleRange) {
TEST(LlvmLibcFmaxTest, InDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000001;
constexpr UIntType step = UIntType(-1) / count;

10
libc/test/src/math/fmaxf_test.cpp
View File

@ -16,7 +16,7 @@ using FPBits = __llvm_libc::fputil::FPBits<float>;
DECLARE_SPECIAL_CONSTANTS(float)
TEST(FmaxfTest, NaNArg) {
TEST(LlvmLibcFmaxfTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fmaxf(negInf, aNaN));
EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(aNaN, 0.0f));
@ -26,7 +26,7 @@ TEST(FmaxfTest, NaNArg) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fmaxf(aNaN, aNaN));
}
TEST(FmaxfTest, InfArg) {
TEST(LlvmLibcFmaxfTest, InfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(negInf, inf));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, 0.0f));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(-0.0f, inf));
@ -34,7 +34,7 @@ TEST(FmaxfTest, InfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(-1.2345f, inf));
}
TEST(FmaxfTest, NegInfArg) {
TEST(LlvmLibcFmaxfTest, NegInfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, negInf));
EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(negInf, 0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, negInf));
@ -42,14 +42,14 @@ TEST(FmaxfTest, NegInfArg) {
EXPECT_FP_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, negInf));
}
TEST(FmaxfTest, BothZero) {
TEST(LlvmLibcFmaxfTest, BothZero) {
EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(0.0f, 0.0f));
EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(-0.0f, 0.0f));
EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(0.0f, -0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, -0.0f));
}
TEST(FmaxfTest, InFloatRange) {
TEST(LlvmLibcFmaxfTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000001;
constexpr UIntType step = UIntType(-1) / count;

10
libc/test/src/math/fmaxl_test.cpp
View File

@ -16,7 +16,7 @@ using FPBits = __llvm_libc::fputil::FPBits<long double>;
DECLARE_SPECIAL_CONSTANTS(long double)
TEST(FmaxlTest, NaNArg) {
TEST(LlvmLibcFmaxlTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fmaxl(negInf, aNaN));
EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(aNaN, 0.0L));
@ -26,7 +26,7 @@ TEST(FmaxlTest, NaNArg) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fmaxl(aNaN, aNaN));
}
TEST(FmaxlTest, InfArg) {
TEST(LlvmLibcFmaxlTest, InfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(negInf, inf));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, 0.0L));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(-0.0L, inf));
@ -34,7 +34,7 @@ TEST(FmaxlTest, InfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(-1.2345L, inf));
}
TEST(FmaxlTest, NegInfArg) {
TEST(LlvmLibcFmaxlTest, NegInfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, negInf));
EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(negInf, 0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, negInf));
@ -42,14 +42,14 @@ TEST(FmaxlTest, NegInfArg) {
EXPECT_FP_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, negInf));
}
TEST(FmaxlTest, BothZero) {
TEST(LlvmLibcFmaxlTest, BothZero) {
EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(0.0L, 0.0L));
EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(-0.0L, 0.0L));
EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(0.0L, -0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, -0.0L));
}
TEST(FmaxlTest, InLongDoubleRange) {
TEST(LlvmLibcFmaxlTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000001;
constexpr UIntType step = UIntType(-1) / count;

10
libc/test/src/math/fmin_test.cpp
View File

@ -16,7 +16,7 @@ using FPBits = __llvm_libc::fputil::FPBits<double>;
DECLARE_SPECIAL_CONSTANTS(double)
TEST(FminTest, NaNArg) {
TEST(LlvmLibcFminTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmin(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, aNaN));
EXPECT_FP_EQ(0.0, __llvm_libc::fmin(aNaN, 0.0));
@ -26,7 +26,7 @@ TEST(FminTest, NaNArg) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fmin(aNaN, aNaN));
}
TEST(FminTest, InfArg) {
TEST(LlvmLibcFminTest, InfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, inf));
EXPECT_FP_EQ(0.0, __llvm_libc::fmin(inf, 0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, inf));
@ -34,7 +34,7 @@ TEST(FminTest, InfArg) {
EXPECT_FP_EQ(-1.2345, __llvm_libc::fmin(-1.2345, inf));
}
TEST(FminTest, NegInfArg) {
TEST(LlvmLibcFminTest, NegInfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(inf, negInf));
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, 0.0));
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(-0.0, negInf));
@ -42,14 +42,14 @@ TEST(FminTest, NegInfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(1.2345, negInf));
}
TEST(FminTest, BothZero) {
TEST(LlvmLibcFminTest, BothZero) {
EXPECT_FP_EQ(0.0, __llvm_libc::fmin(0.0, 0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, 0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(0.0, -0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, -0.0));
}
TEST(FminTest, InFloatRange) {
TEST(LlvmLibcFminTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

10
libc/test/src/math/fminf_test.cpp
View File

@ -16,7 +16,7 @@ using FPBits = __llvm_libc::fputil::FPBits<float>;
DECLARE_SPECIAL_CONSTANTS(float)
TEST(FminfTest, NaNArg) {
TEST(LlvmLibcFminfTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fminf(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, aNaN));
EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(aNaN, 0.0f));
@ -26,7 +26,7 @@ TEST(FminfTest, NaNArg) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fminf(aNaN, aNaN));
}
TEST(FminfTest, InfArg) {
TEST(LlvmLibcFminfTest, InfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, inf));
EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(inf, 0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, inf));
@ -34,7 +34,7 @@ TEST(FminfTest, InfArg) {
EXPECT_FP_EQ(-1.2345f, __llvm_libc::fminf(-1.2345f, inf));
}
TEST(FminfTest, NegInfArg) {
TEST(LlvmLibcFminfTest, NegInfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(inf, negInf));
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, 0.0f));
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(-0.0f, negInf));
@ -42,14 +42,14 @@ TEST(FminfTest, NegInfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(1.2345f, negInf));
}
TEST(FminfTest, BothZero) {
TEST(LlvmLibcFminfTest, BothZero) {
EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(0.0f, 0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, 0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(0.0f, -0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, -0.0f));
}
TEST(FminfTest, InFloatRange) {
TEST(LlvmLibcFminfTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

10
libc/test/src/math/fminl_test.cpp
View File

@ -16,7 +16,7 @@ using FPBits = __llvm_libc::fputil::FPBits<long double>;
DECLARE_SPECIAL_CONSTANTS(long double)
TEST(FminlTest, NaNArg) {
TEST(LlvmLibcFminlTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fminl(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, aNaN));
EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(aNaN, 0.0L));
@ -26,7 +26,7 @@ TEST(FminlTest, NaNArg) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fminl(aNaN, aNaN));
}
TEST(FminlTest, InfArg) {
TEST(LlvmLibcFminlTest, InfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, inf));
EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(inf, 0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, inf));
@ -34,7 +34,7 @@ TEST(FminlTest, InfArg) {
EXPECT_FP_EQ(-1.2345L, __llvm_libc::fminl(-1.2345L, inf));
}
TEST(FminlTest, NegInfArg) {
TEST(LlvmLibcFminlTest, NegInfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(inf, negInf));
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, 0.0L));
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(-0.0L, negInf));
@ -42,14 +42,14 @@ TEST(FminlTest, NegInfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(1.2345L, negInf));
}
TEST(FminlTest, BothZero) {
TEST(LlvmLibcFminlTest, BothZero) {
EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(0.0L, 0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, 0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(0.0L, -0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, -0.0L));
}
TEST(FminlTest, InLongDoubleRange) {
TEST(LlvmLibcFminlTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/frexp_test.cpp
View File

@ -26,7 +26,7 @@ namespace mpfr = __llvm_libc::testing::mpfr;
using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
using Properties = __llvm_libc::fputil::FloatProperties<double>;
TEST(FrexpTest, SpecialNumbers) {
TEST(LlvmLibcFrexpTest, SpecialNumbers) {
int exponent;
EXPECT_EQ(BitPatterns::aQuietNaN,
@ -60,7 +60,7 @@ TEST(FrexpTest, SpecialNumbers) {
EXPECT_EQ(exponent, 0);
}
TEST(FrexpTest, PowersOfTwo) {
TEST(LlvmLibcFrexpTest, PowersOfTwo) {
int exponent;
EXPECT_EQ(valueAsBits(0.5), valueAsBits(__llvm_libc::frexp(1.0, &exponent)));
@ -106,7 +106,7 @@ TEST(FrexpTest, PowersOfTwo) {
EXPECT_EQ(exponent, 7);
}
TEST(FrexpTest, SomeIntegers) {
TEST(LlvmLibcFrexpTest, SomeIntegers) {
int exponent;
EXPECT_EQ(valueAsBits(0.75),
@ -131,7 +131,7 @@ TEST(FrexpTest, SomeIntegers) {
EXPECT_EQ(exponent, 10);
}
TEST(FrexpTest, InDoubleRange) {
TEST(LlvmLibcFrexpTest, InDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 1000001;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/frexpf_test.cpp
View File

@ -26,7 +26,7 @@ namespace mpfr = __llvm_libc::testing::mpfr;
using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
using Properties = __llvm_libc::fputil::FloatProperties<float>;
TEST(FrexpfTest, SpecialNumbers) {
TEST(LlvmLibcFrexpfTest, SpecialNumbers) {
int exponent;
EXPECT_EQ(BitPatterns::aQuietNaN,
@ -60,7 +60,7 @@ TEST(FrexpfTest, SpecialNumbers) {
EXPECT_EQ(exponent, 0);
}
TEST(FrexpfTest, PowersOfTwo) {
TEST(LlvmLibcFrexpfTest, PowersOfTwo) {
int exponent;
EXPECT_EQ(valueAsBits(0.5f),
@ -113,7 +113,7 @@ TEST(FrexpfTest, PowersOfTwo) {
EXPECT_EQ(exponent, 7);
}
TEST(FrexpfTest, SomeIntegers) {
TEST(LlvmLibcFrexpfTest, SomeIntegers) {
int exponent;
EXPECT_EQ(valueAsBits(0.75f),
@ -138,7 +138,7 @@ TEST(FrexpfTest, SomeIntegers) {
EXPECT_EQ(exponent, 10);
}
TEST(FrexpfTest, InFloatRange) {
TEST(LlvmLibcFrexpfTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 1000001;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/frexpl_test.cpp
View File

@ -17,7 +17,7 @@ using FPBits = __llvm_libc::fputil::FPBits<long double>;
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(FrexplTest, SpecialNumbers) {
TEST(LlvmLibcFrexplTest, SpecialNumbers) {
int exponent;
EXPECT_TRUE(FPBits::inf() == __llvm_libc::frexpl(FPBits::inf(), &exponent));
@ -35,7 +35,7 @@ TEST(FrexplTest, SpecialNumbers) {
FPBits(__llvm_libc::frexpl(FPBits::buildNaN(1), &exponent)).isNaN());
}
TEST(FrexplTest, PowersOfTwo) {
TEST(LlvmLibcFrexplTest, PowersOfTwo) {
int exponent;
EXPECT_TRUE(0.5l == __llvm_libc::frexpl(1.0l, &exponent));
@ -69,7 +69,7 @@ TEST(FrexplTest, PowersOfTwo) {
EXPECT_EQ(exponent, 6);
}
TEST(FrexplTest, SomeIntegers) {
TEST(LlvmLibcFrexplTest, SomeIntegers) {
int exponent;
EXPECT_TRUE(0.75l == __llvm_libc::frexpl(24.0l, &exponent));
@ -88,7 +88,7 @@ TEST(FrexplTest, SomeIntegers) {
EXPECT_EQ(exponent, 10);
}
TEST(FrexplTest, LongDoubleRange) {
TEST(LlvmLibcFrexplTest, LongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

10
libc/test/src/math/hypot_test.cpp
View File

@ -12,8 +12,12 @@
using HypotTest = HypotTestTemplate<double>;
TEST_F(HypotTest, SpecialNumbers) { testSpecialNumbers(&__llvm_libc::hypot); }
TEST_F(LlvmLibcHypotTest, SpecialNumbers) {
testSpecialNumbers(&__llvm_libc::hypot);
}
TEST_F(HypotTest, SubnormalRange) { testSubnormalRange(&__llvm_libc::hypot); }
TEST_F(LlvmLibcHypotTest, SubnormalRange) {
testSubnormalRange(&__llvm_libc::hypot);
}
TEST_F(HypotTest, NormalRange) { testNormalRange(&__llvm_libc::hypot); }
TEST_F(LlvmLibcHypotTest, NormalRange) { testNormalRange(&__llvm_libc::hypot); }

12
libc/test/src/math/hypotf_test.cpp
View File

@ -12,8 +12,14 @@
using HypotfTest = HypotTestTemplate<float>;
TEST_F(HypotfTest, SpecialNumbers) { testSpecialNumbers(&__llvm_libc::hypotf); }
TEST_F(LlvmLibcHypotfTest, SpecialNumbers) {
testSpecialNumbers(&__llvm_libc::hypotf);
}
TEST_F(HypotfTest, SubnormalRange) { testSubnormalRange(&__llvm_libc::hypotf); }
TEST_F(LlvmLibcHypotfTest, SubnormalRange) {
testSubnormalRange(&__llvm_libc::hypotf);
}
TEST_F(HypotfTest, NormalRange) { testNormalRange(&__llvm_libc::hypotf); }
TEST_F(LlvmLibcHypotfTest, NormalRange) {
testNormalRange(&__llvm_libc::hypotf);
}

10
libc/test/src/math/ilogb_test.cpp
View File

@ -15,22 +15,22 @@
#include "utils/UnitTest/Test.h"
#include <math.h>
TEST_F(ILogbTest, SpecialNumbers_ilogb) {
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogb) {
testSpecialNumbers<double>(&__llvm_libc::ilogb);
}
TEST_F(ILogbTest, PowersOfTwo_ilogb) {
TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogb) {
testPowersOfTwo<double>(&__llvm_libc::ilogb);
}
TEST_F(ILogbTest, SomeIntegers_ilogb) {
TEST_F(LlvmLibcILogbTest, SomeIntegers_ilogb) {
testSomeIntegers<double>(&__llvm_libc::ilogb);
}
TEST_F(ILogbTest, SubnormalRange_ilogb) {
TEST_F(LlvmLibcILogbTest, SubnormalRange_ilogb) {
testSubnormalRange<double>(&__llvm_libc::ilogb);
}
TEST_F(ILogbTest, NormalRange_ilogb) {
TEST_F(LlvmLibcILogbTest, NormalRange_ilogb) {
testNormalRange<double>(&__llvm_libc::ilogb);
}

10
libc/test/src/math/ilogbf_test.cpp
View File

@ -15,22 +15,22 @@
#include "utils/UnitTest/Test.h"
#include <math.h>
TEST_F(ILogbTest, SpecialNumbers_ilogbf) {
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbf) {
testSpecialNumbers<float>(&__llvm_libc::ilogbf);
}
TEST_F(ILogbTest, PowersOfTwo_ilogbf) {
TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogbf) {
testPowersOfTwo<float>(&__llvm_libc::ilogbf);
}
TEST_F(ILogbTest, SomeIntegers_ilogbf) {
TEST_F(LlvmLibcILogbTest, SomeIntegers_ilogbf) {
testSomeIntegers<float>(&__llvm_libc::ilogbf);
}
TEST_F(ILogbTest, SubnormalRange_ilogbf) {
TEST_F(LlvmLibcILogbTest, SubnormalRange_ilogbf) {
testSubnormalRange<float>(&__llvm_libc::ilogbf);
}
TEST_F(ILogbTest, NormalRange_ilogbf) {
TEST_F(LlvmLibcILogbTest, NormalRange_ilogbf) {
testNormalRange<float>(&__llvm_libc::ilogbf);
}

10
libc/test/src/math/ilogbl_test.cpp
View File

@ -17,22 +17,22 @@
using RunContext = __llvm_libc::testing::RunContext;
TEST_F(ILogbTest, SpecialNumbers_ilogbl) {
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbl) {
testSpecialNumbers<long double>(&__llvm_libc::ilogbl);
}
TEST_F(ILogbTest, PowersOfTwo_ilogbl) {
TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogbl) {
testPowersOfTwo<long double>(&__llvm_libc::ilogbl);
}
TEST_F(ILogbTest, SomeIntegers_ilogbl) {
TEST_F(LlvmLibcILogbTest, SomeIntegers_ilogbl) {
testSomeIntegers<long double>(&__llvm_libc::ilogbl);
}
TEST_F(ILogbTest, SubnormalRange_ilogbl) {
TEST_F(LlvmLibcILogbTest, SubnormalRange_ilogbl) {
testSubnormalRange<long double>(&__llvm_libc::ilogbl);
}
TEST_F(ILogbTest, NormalRange_ilogbl) {
TEST_F(LlvmLibcILogbTest, NormalRange_ilogbl) {
testNormalRange<long double>(&__llvm_libc::ilogbl);
}

8
libc/test/src/math/logb_test.cpp
View File

@ -20,7 +20,7 @@ using __llvm_libc::fputil::valueFromBits;
using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
using Properties = __llvm_libc::fputil::FloatProperties<double>;
TEST(LogbTest, SpecialNumbers) {
TEST(LlvmLibcLogbTest, SpecialNumbers) {
EXPECT_EQ(
BitPatterns::aQuietNaN,
valueAsBits(__llvm_libc::logb(valueFromBits(BitPatterns::aQuietNaN))));
@ -46,7 +46,7 @@ TEST(LogbTest, SpecialNumbers) {
valueFromBits(BitPatterns::negZero))));
}
TEST(LogbTest, PowersOfTwo) {
TEST(LlvmLibcLogbTest, PowersOfTwo) {
EXPECT_EQ(valueAsBits(0.0), valueAsBits(__llvm_libc::logb(1.0)));
EXPECT_EQ(valueAsBits(0.0), valueAsBits(__llvm_libc::logb(-1.0)));
@ -66,7 +66,7 @@ TEST(LogbTest, PowersOfTwo) {
EXPECT_EQ(valueAsBits(5.0), valueAsBits(__llvm_libc::logb(-32.0)));
}
TEST(LogbTest, SomeIntegers) {
TEST(LlvmLibcLogbTest, SomeIntegers) {
EXPECT_EQ(valueAsBits(1.0), valueAsBits(__llvm_libc::logb(3.0)));
EXPECT_EQ(valueAsBits(1.0), valueAsBits(__llvm_libc::logb(-3.0)));
@ -83,7 +83,7 @@ TEST(LogbTest, SomeIntegers) {
EXPECT_EQ(valueAsBits(5.0), valueAsBits(__llvm_libc::logb(-55.0)));
}
TEST(LogbTest, InDoubleRange) {
TEST(LlvmLibcLogbTest, InDoubleRange) {
using BitsType = Properties::BitsType;
constexpr BitsType count = 10000000;
constexpr BitsType step = UINT64_MAX / count;

8
libc/test/src/math/logbf_test.cpp
View File

@ -20,7 +20,7 @@ using __llvm_libc::fputil::valueFromBits;
using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
using Properties = __llvm_libc::fputil::FloatProperties<float>;
TEST(LogbfTest, SpecialNumbers) {
TEST(LlvmLibcLogbfTest, SpecialNumbers) {
EXPECT_EQ(
BitPatterns::aQuietNaN,
valueAsBits(__llvm_libc::logbf(valueFromBits(BitPatterns::aQuietNaN))));
@ -46,7 +46,7 @@ TEST(LogbfTest, SpecialNumbers) {
valueFromBits(BitPatterns::negZero))));
}
TEST(LogbfTest, PowersOfTwo) {
TEST(LlvmLibcLogbfTest, PowersOfTwo) {
EXPECT_EQ(valueAsBits(0.0f), valueAsBits(__llvm_libc::logbf(1.0f)));
EXPECT_EQ(valueAsBits(0.0f), valueAsBits(__llvm_libc::logbf(-1.0f)));
@ -66,7 +66,7 @@ TEST(LogbfTest, PowersOfTwo) {
EXPECT_EQ(valueAsBits(5.0f), valueAsBits(__llvm_libc::logbf(-32.0f)));
}
TEST(LogbTest, SomeIntegers) {
TEST(LlvmLibcLogbTest, SomeIntegers) {
EXPECT_EQ(valueAsBits(1.0f), valueAsBits(__llvm_libc::logbf(3.0f)));
EXPECT_EQ(valueAsBits(1.0f), valueAsBits(__llvm_libc::logbf(-3.0f)));
@ -83,7 +83,7 @@ TEST(LogbTest, SomeIntegers) {
EXPECT_EQ(valueAsBits(5.0f), valueAsBits(__llvm_libc::logbf(-55.0f)));
}
TEST(LogbfTest, InDoubleRange) {
TEST(LlvmLibcLogbfTest, InDoubleRange) {
using BitsType = Properties::BitsType;
constexpr BitsType count = 10000000;
constexpr BitsType step = UINT32_MAX / count;

8
libc/test/src/math/logbl_test.cpp
View File

@ -14,7 +14,7 @@
using FPBits = __llvm_libc::fputil::FPBits<long double>;
TEST(logblTest, SpecialNumbers) {
TEST(LlvmLibclogblTest, SpecialNumbers) {
EXPECT_TRUE(FPBits::inf() == __llvm_libc::logbl(FPBits::inf()));
EXPECT_TRUE(FPBits::inf() == __llvm_libc::logbl(FPBits::negInf()));
@ -24,7 +24,7 @@ TEST(logblTest, SpecialNumbers) {
EXPECT_TRUE(FPBits(__llvm_libc::logbl(FPBits::buildNaN(1))).isNaN());
}
TEST(logblTest, PowersOfTwo) {
TEST(LlvmLibclogblTest, PowersOfTwo) {
EXPECT_TRUE(0.0l == __llvm_libc::logbl(1.0l));
EXPECT_TRUE(0.0l == __llvm_libc::logbl(-1.0l));
@ -44,7 +44,7 @@ TEST(logblTest, PowersOfTwo) {
EXPECT_TRUE(5.0l == __llvm_libc::logbl(-32.0l));
}
TEST(LogbTest, SomeIntegers) {
TEST(LlvmLibcLogbTest, SomeIntegers) {
EXPECT_TRUE(1.0l == __llvm_libc::logbl(3.0l));
EXPECT_TRUE(1.0l == __llvm_libc::logbl(-3.0l));
@ -61,7 +61,7 @@ TEST(LogbTest, SomeIntegers) {
EXPECT_TRUE(5.0l == __llvm_libc::logbl(-55.0l));
}
TEST(LogblTest, LongDoubleRange) {
TEST(LlvmLibcLogblTest, LongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/modf_test.cpp
View File

@ -21,7 +21,7 @@ using __llvm_libc::fputil::valueFromBits;
using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
using Properties = __llvm_libc::fputil::FloatProperties<double>;
TEST(ModfTest, SpecialNumbers) {
TEST(LlvmLibcModfTest, SpecialNumbers) {
double integral;
EXPECT_EQ(BitPatterns::aQuietNaN,
@ -60,7 +60,7 @@ TEST(ModfTest, SpecialNumbers) {
EXPECT_EQ(valueAsBits(integral), BitPatterns::negZero);
}
TEST(ModfTest, Integers) {
TEST(LlvmLibcModfTest, Integers) {
double integral;
EXPECT_EQ(BitPatterns::zero, valueAsBits(__llvm_libc::modf(1.0, &integral)));
@ -86,7 +86,7 @@ TEST(ModfTest, Integers) {
EXPECT_EQ(valueAsBits(integral), valueAsBits(-12345.0));
}
TEST(ModfTest, Fractions) {
TEST(LlvmLibcModfTest, Fractions) {
double integral;
EXPECT_EQ(valueAsBits(0.5), valueAsBits(__llvm_libc::modf(1.5, &integral)));
@ -112,7 +112,7 @@ TEST(ModfTest, Fractions) {
EXPECT_EQ(valueAsBits(integral), valueAsBits(-100.0));
}
TEST(ModfTest, InDoubleRange) {
TEST(LlvmLibcModfTest, InDoubleRange) {
using BitsType = Properties::BitsType;
constexpr BitsType count = 10000000;
constexpr BitsType step = UINT64_MAX / count;

8
libc/test/src/math/modff_test.cpp
View File

@ -21,7 +21,7 @@ using __llvm_libc::fputil::valueFromBits;
using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
using Properties = __llvm_libc::fputil::FloatProperties<float>;
TEST(ModffTest, SpecialNumbers) {
TEST(LlvmLibcModffTest, SpecialNumbers) {
float integral;
EXPECT_EQ(BitPatterns::aQuietNaN,
@ -60,7 +60,7 @@ TEST(ModffTest, SpecialNumbers) {
EXPECT_EQ(valueAsBits(integral), BitPatterns::negZero);
}
TEST(ModffTest, Integers) {
TEST(LlvmLibcModffTest, Integers) {
float integral;
EXPECT_EQ(BitPatterns::zero,
@ -88,7 +88,7 @@ TEST(ModffTest, Integers) {
EXPECT_EQ(valueAsBits(integral), valueAsBits(-12345.0f));
}
TEST(ModffTest, Fractions) {
TEST(LlvmLibcModffTest, Fractions) {
float integral;
EXPECT_EQ(valueAsBits(0.5f),
@ -116,7 +116,7 @@ TEST(ModffTest, Fractions) {
EXPECT_EQ(valueAsBits(integral), valueAsBits(-100.0f));
}
TEST(ModffTest, InDoubleRange) {
TEST(LlvmLibcModffTest, InDoubleRange) {
using BitsType = Properties::BitsType;
constexpr BitsType count = 10000000;
constexpr BitsType step = UINT32_MAX / count;

8
libc/test/src/math/modfl_test.cpp
View File

@ -15,7 +15,7 @@
using FPBits = __llvm_libc::fputil::FPBits<long double>;
TEST(modflTest, SpecialNumbers) {
TEST(LlvmLibcmodflTest, SpecialNumbers) {
long double integral;
EXPECT_TRUE(FPBits::zero() == __llvm_libc::modfl(FPBits::inf(), &integral));
@ -36,7 +36,7 @@ TEST(modflTest, SpecialNumbers) {
FPBits(__llvm_libc::modfl(FPBits::buildNaN(1), &integral)).isNaN());
}
TEST(modflTest, Integers) {
TEST(LlvmLibcmodflTest, Integers) {
long double integral;
EXPECT_TRUE(FPBits::zero() == __llvm_libc::modfl(1.0l, &integral));
@ -58,7 +58,7 @@ TEST(modflTest, Integers) {
EXPECT_TRUE(integral == -12345.0l);
}
TEST(ModfTest, Fractions) {
TEST(LlvmLibcModfTest, Fractions) {
long double integral;
EXPECT_TRUE(0.5l == __llvm_libc::modfl(1.5l, &integral));
@ -80,7 +80,7 @@ TEST(ModfTest, Fractions) {
EXPECT_TRUE(integral == -100.0l);
}
TEST(ModflTest, LongDoubleRange) {
TEST(LlvmLibcModflTest, LongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/round_test.cpp
View File

@ -19,7 +19,7 @@ namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double)
TEST(RoundTest, SpecialNumbers) {
TEST(LlvmLibcRoundTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::round(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::round(negZero));
@ -29,7 +29,7 @@ TEST(RoundTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::round(aNaN));
}
TEST(RoundTest, RoundedNumbers) {
TEST(LlvmLibcRoundTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0, __llvm_libc::round(1.0));
EXPECT_FP_EQ(-1.0, __llvm_libc::round(-1.0));
EXPECT_FP_EQ(10.0, __llvm_libc::round(10.0));
@ -38,7 +38,7 @@ TEST(RoundTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0, __llvm_libc::round(-1234.0));
}
TEST(RoundTest, Fractions) {
TEST(LlvmLibcRoundTest, Fractions) {
EXPECT_FP_EQ(1.0, __llvm_libc::round(0.5));
EXPECT_FP_EQ(-1.0, __llvm_libc::round(-0.5));
EXPECT_FP_EQ(0.0, __llvm_libc::round(0.115));
@ -61,7 +61,7 @@ TEST(RoundTest, Fractions) {
EXPECT_FP_EQ(-1235.0, __llvm_libc::round(-1234.96));
}
TEST(RoundTest, InDoubleRange) {
TEST(LlvmLibcRoundTest, InDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/roundf_test.cpp
View File

@ -19,7 +19,7 @@ namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float)
TEST(RoundfTest, SpecialNumbers) {
TEST(LlvmLibcRoundfTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::roundf(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::roundf(negZero));
@ -29,7 +29,7 @@ TEST(RoundfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::roundf(aNaN));
}
TEST(RoundfTest, RoundedNumbers) {
TEST(LlvmLibcRoundfTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0f, __llvm_libc::roundf(1.0f));
EXPECT_FP_EQ(-1.0f, __llvm_libc::roundf(-1.0f));
EXPECT_FP_EQ(10.0f, __llvm_libc::roundf(10.0f));
@ -38,7 +38,7 @@ TEST(RoundfTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0f, __llvm_libc::roundf(-1234.0f));
}
TEST(RoundfTest, Fractions) {
TEST(LlvmLibcRoundfTest, Fractions) {
EXPECT_FP_EQ(1.0f, __llvm_libc::roundf(0.5f));
EXPECT_FP_EQ(-1.0f, __llvm_libc::roundf(-0.5f));
EXPECT_FP_EQ(0.0f, __llvm_libc::roundf(0.115f));
@ -61,7 +61,7 @@ TEST(RoundfTest, Fractions) {
EXPECT_FP_EQ(-1235.0f, __llvm_libc::roundf(-1234.96f));
}
TEST(RoundfTest, InFloatRange) {
TEST(LlvmLibcRoundfTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 1000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/roundl_test.cpp
View File

@ -19,7 +19,7 @@ namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(long double)
TEST(RoundlTest, SpecialNumbers) {
TEST(LlvmLibcRoundlTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::roundl(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::roundl(negZero));
@ -29,7 +29,7 @@ TEST(RoundlTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::roundl(aNaN));
}
TEST(RoundlTest, RoundedNumbers) {
TEST(LlvmLibcRoundlTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0l, __llvm_libc::roundl(1.0l));
EXPECT_FP_EQ(-1.0l, __llvm_libc::roundl(-1.0l));
EXPECT_FP_EQ(10.0l, __llvm_libc::roundl(10.0l));
@ -38,7 +38,7 @@ TEST(RoundlTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0l, __llvm_libc::roundl(-1234.0l));
}
TEST(RoundlTest, Fractions) {
TEST(LlvmLibcRoundlTest, Fractions) {
EXPECT_FP_EQ(1.0l, __llvm_libc::roundl(0.5l));
EXPECT_FP_EQ(-1.0l, __llvm_libc::roundl(-0.5l));
EXPECT_FP_EQ(0.0l, __llvm_libc::roundl(0.115l));
@ -61,7 +61,7 @@ TEST(RoundlTest, Fractions) {
EXPECT_FP_EQ(-1235.0l, __llvm_libc::roundl(-1234.96l));
}
TEST(RoundlTest, InLongDoubleRange) {
TEST(LlvmLibcRoundlTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/sincosf_test.cpp
View File

@ -32,7 +32,7 @@ using __llvm_libc::testing::sdcomp26094Values;
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(SinCosfTest, SpecialNumbers) {
TEST(LlvmLibcSinCosfTest, SpecialNumbers) {
llvmlibc_errno = 0;
float sin, cos;
@ -81,7 +81,7 @@ TEST(SinCosfTest, SpecialNumbers) {
EXPECT_EQ(llvmlibc_errno, EDOM);
}
TEST(SinCosfTest, InFloatRange) {
TEST(LlvmLibcSinCosfTest, InFloatRange) {
constexpr uint32_t count = 1000000;
constexpr uint32_t step = UINT32_MAX / count;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
@ -97,7 +97,7 @@ TEST(SinCosfTest, InFloatRange) {
}
// For small values, cos(x) is 1 and sin(x) is x.
TEST(SinCosfTest, SmallValues) {
TEST(LlvmLibcSinCosfTest, SmallValues) {
uint32_t bits = 0x17800000;
float x = valueFromBits(bits);
float result_cos, result_sin;
@ -118,7 +118,7 @@ TEST(SinCosfTest, SmallValues) {
// SDCOMP-26094: check sinf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4.
TEST(SinCosfTest, SDCOMP_26094) {
TEST(LlvmLibcSinCosfTest, SDCOMP_26094) {
for (uint32_t v : sdcomp26094Values) {
float x = valueFromBits(v);
float sin, cos;

10
libc/test/src/math/sinf_test.cpp
View File

@ -32,7 +32,7 @@ using __llvm_libc::testing::sdcomp26094Values;
namespace mpfr = __llvm_libc::testing::mpfr;
TEST(SinfTest, SpecialNumbers) {
TEST(LlvmLibcSinfTest, SpecialNumbers) {
llvmlibc_errno = 0;
EXPECT_TRUE(
@ -69,7 +69,7 @@ TEST(SinfTest, SpecialNumbers) {
EXPECT_EQ(llvmlibc_errno, EDOM);
}
TEST(SinfTest, InFloatRange) {
TEST(LlvmLibcSinfTest, InFloatRange) {
constexpr uint32_t count = 1000000;
constexpr uint32_t step = UINT32_MAX / count;
for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
@ -80,13 +80,13 @@ TEST(SinfTest, InFloatRange) {
}
}
TEST(SinfTest, SpecificBitPatterns) {
TEST(LlvmLibcSinfTest, SpecificBitPatterns) {
float x = valueFromBits(0xc70d39a1);
EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), 1.0);
}
// For small values, sin(x) is x.
TEST(SinfTest, SmallValues) {
TEST(LlvmLibcSinfTest, SmallValues) {
uint32_t bits = 0x17800000;
float x = valueFromBits(bits);
float result = __llvm_libc::sinf(x);
@ -102,7 +102,7 @@ TEST(SinfTest, SmallValues) {
// SDCOMP-26094: check sinf in the cases for which the range reducer
// returns values furthest beyond its nominal upper bound of pi/4.
TEST(SinfTest, SDCOMP_26094) {
TEST(LlvmLibcSinfTest, SDCOMP_26094) {
for (uint32_t v : sdcomp26094Values) {
float x = valueFromBits(v);
EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), 1.0);

6
libc/test/src/math/sqrt_test.cpp
View File

@ -22,7 +22,7 @@ constexpr UIntType HiddenBit =
DECLARE_SPECIAL_CONSTANTS(double)
TEST(SqrtTest, SpecialValues) {
TEST(LlvmLibcSqrtTest, SpecialValues) {
ASSERT_FP_EQ(aNaN, __llvm_libc::sqrt(aNaN));
ASSERT_FP_EQ(inf, __llvm_libc::sqrt(inf));
ASSERT_FP_EQ(aNaN, __llvm_libc::sqrt(negInf));
@ -34,7 +34,7 @@ TEST(SqrtTest, SpecialValues) {
ASSERT_FP_EQ(3.0, __llvm_libc::sqrt(9.0));
}
TEST(SqrtTest, DenormalValues) {
TEST(LlvmLibcSqrtTest, DenormalValues) {
for (UIntType mant = 1; mant < HiddenBit; mant <<= 1) {
FPBits denormal(0.0);
denormal.mantissa = mant;
@ -51,7 +51,7 @@ TEST(SqrtTest, DenormalValues) {
}
}
TEST(SqrtTest, InDoubleRange) {
TEST(LlvmLibcSqrtTest, InDoubleRange) {
constexpr UIntType count = 10'000'001;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {

6
libc/test/src/math/sqrtf_test.cpp
View File

@ -22,7 +22,7 @@ constexpr UIntType HiddenBit =
DECLARE_SPECIAL_CONSTANTS(float)
TEST(SqrtfTest, SpecialValues) {
TEST(LlvmLibcSqrtfTest, SpecialValues) {
ASSERT_FP_EQ(aNaN, __llvm_libc::sqrtf(aNaN));
ASSERT_FP_EQ(inf, __llvm_libc::sqrtf(inf));
ASSERT_FP_EQ(aNaN, __llvm_libc::sqrtf(negInf));
@ -34,7 +34,7 @@ TEST(SqrtfTest, SpecialValues) {
ASSERT_FP_EQ(3.0f, __llvm_libc::sqrtf(9.0f));
}
TEST(SqrtfTest, DenormalValues) {
TEST(LlvmLibcSqrtfTest, DenormalValues) {
for (UIntType mant = 1; mant < HiddenBit; mant <<= 1) {
FPBits denormal(0.0f);
denormal.mantissa = mant;
@ -51,7 +51,7 @@ TEST(SqrtfTest, DenormalValues) {
}
}
TEST(SqrtfTest, InFloatRange) {
TEST(LlvmLibcSqrtfTest, InFloatRange) {
constexpr UIntType count = 10'000'001;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {

6
libc/test/src/math/sqrtl_test.cpp
View File

@ -22,7 +22,7 @@ constexpr UIntType HiddenBit =
DECLARE_SPECIAL_CONSTANTS(long double)
TEST(SqrtlTest, SpecialValues) {
TEST(LlvmLibcSqrtlTest, SpecialValues) {
ASSERT_FP_EQ(aNaN, __llvm_libc::sqrtl(aNaN));
ASSERT_FP_EQ(inf, __llvm_libc::sqrtl(inf));
ASSERT_FP_EQ(aNaN, __llvm_libc::sqrtl(negInf));
@ -34,7 +34,7 @@ TEST(SqrtlTest, SpecialValues) {
ASSERT_FP_EQ(3.0L, __llvm_libc::sqrtl(9.0L));
}
TEST(SqrtlTest, DenormalValues) {
TEST(LlvmLibcSqrtlTest, DenormalValues) {
for (UIntType mant = 1; mant < HiddenBit; mant <<= 1) {
FPBits denormal(0.0L);
denormal.mantissa = mant;
@ -51,7 +51,7 @@ TEST(SqrtlTest, DenormalValues) {
}
}
TEST(SqrtlTest, InLongDoubleRange) {
TEST(LlvmLibcSqrtlTest, InLongDoubleRange) {
constexpr UIntType count = 10'000'001;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {

8
libc/test/src/math/trunc_test.cpp
View File

@ -19,7 +19,7 @@ namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double)
TEST(TruncTest, SpecialNumbers) {
TEST(LlvmLibcTruncTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::trunc(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::trunc(negZero));
@ -29,7 +29,7 @@ TEST(TruncTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::trunc(aNaN));
}
TEST(TruncTest, RoundedNumbers) {
TEST(LlvmLibcTruncTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0, __llvm_libc::trunc(1.0));
EXPECT_FP_EQ(-1.0, __llvm_libc::trunc(-1.0));
EXPECT_FP_EQ(10.0, __llvm_libc::trunc(10.0));
@ -38,7 +38,7 @@ TEST(TruncTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0, __llvm_libc::trunc(-1234.0));
}
TEST(TruncTest, Fractions) {
TEST(LlvmLibcTruncTest, Fractions) {
EXPECT_FP_EQ(0.0, __llvm_libc::trunc(0.5));
EXPECT_FP_EQ(-0.0, __llvm_libc::trunc(-0.5));
EXPECT_FP_EQ(0.0, __llvm_libc::trunc(0.115));
@ -61,7 +61,7 @@ TEST(TruncTest, Fractions) {
EXPECT_FP_EQ(-1234.0, __llvm_libc::trunc(-1234.96));
}
TEST(TruncTest, InDoubleRange) {
TEST(LlvmLibcTruncTest, InDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/truncf_test.cpp
View File

@ -19,7 +19,7 @@ namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float)
TEST(TruncfTest, SpecialNumbers) {
TEST(LlvmLibcTruncfTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::truncf(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::truncf(negZero));
@ -29,7 +29,7 @@ TEST(TruncfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::truncf(aNaN));
}
TEST(TruncfTest, RoundedNumbers) {
TEST(LlvmLibcTruncfTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0f, __llvm_libc::truncf(1.0f));
EXPECT_FP_EQ(-1.0f, __llvm_libc::truncf(-1.0f));
EXPECT_FP_EQ(10.0f, __llvm_libc::truncf(10.0f));
@ -38,7 +38,7 @@ TEST(TruncfTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0f, __llvm_libc::truncf(-1234.0f));
}
TEST(TruncfTest, Fractions) {
TEST(LlvmLibcTruncfTest, Fractions) {
EXPECT_FP_EQ(0.0f, __llvm_libc::truncf(0.5f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::truncf(-0.5f));
EXPECT_FP_EQ(0.0f, __llvm_libc::truncf(0.115f));
@ -61,7 +61,7 @@ TEST(TruncfTest, Fractions) {
EXPECT_FP_EQ(-1234.0f, __llvm_libc::truncf(-1234.96f));
}
TEST(TruncfTest, InFloatRange) {
TEST(LlvmLibcTruncfTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 1000000;
constexpr UIntType step = UIntType(-1) / count;

8
libc/test/src/math/truncl_test.cpp
View File

@ -19,7 +19,7 @@ namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(long double)
TEST(TrunclTest, SpecialNumbers) {
TEST(LlvmLibcTrunclTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::truncl(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::truncl(negZero));
@ -29,7 +29,7 @@ TEST(TrunclTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::truncl(aNaN));
}
TEST(TrunclTest, RoundedNumbers) {
TEST(LlvmLibcTrunclTest, RoundedNumbers) {
EXPECT_FP_EQ(1.0l, __llvm_libc::truncl(1.0l));
EXPECT_FP_EQ(-1.0l, __llvm_libc::truncl(-1.0l));
EXPECT_FP_EQ(10.0l, __llvm_libc::truncl(10.0l));
@ -38,7 +38,7 @@ TEST(TrunclTest, RoundedNumbers) {
EXPECT_FP_EQ(-1234.0l, __llvm_libc::truncl(-1234.0l));
}
TEST(TrunclTest, Fractions) {
TEST(LlvmLibcTrunclTest, Fractions) {
EXPECT_FP_EQ(0.0l, __llvm_libc::truncl(0.5l));
EXPECT_FP_EQ(-0.0l, __llvm_libc::truncl(-0.5l));
EXPECT_FP_EQ(0.0l, __llvm_libc::truncl(0.115l));
@ -61,7 +61,7 @@ TEST(TrunclTest, Fractions) {
EXPECT_FP_EQ(-1234.0l, __llvm_libc::truncl(-1234.96l));
}
TEST(TrunclTest, InLongDoubleRange) {
TEST(LlvmLibcTrunclTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;

2
libc/test/src/signal/raise_test.cpp
View File

@ -11,7 +11,7 @@
#include "utils/UnitTest/Test.h"
TEST(SignalTest, Raise) {
TEST(LlvmLibcSignalTest, Raise) {
// SIGCONT is ingored unless stopped, so we can use it to check the return
// value of raise without needing to block.
EXPECT_EQ(__llvm_libc::raise(SIGCONT), 0);

8
libc/test/src/signal/sigaction_test.cpp
View File

@ -18,13 +18,13 @@
using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
TEST(Sigaction, Invalid) {
TEST(LlvmLibcSigaction, Invalid) {
// -1 is a much larger signal that NSIG, so this should fail.
EXPECT_THAT(__llvm_libc::sigaction(-1, nullptr, nullptr), Fails(EINVAL));
}
// SIGKILL cannot have its action changed, but it can be examined.
TEST(Sigaction, Sigkill) {
TEST(LlvmLibcSigaction, Sigkill) {
struct __sigaction action;
EXPECT_THAT(__llvm_libc::sigaction(SIGKILL, nullptr, &action), Succeeds());
EXPECT_THAT(__llvm_libc::sigaction(SIGKILL, &action, nullptr), Fails(EINVAL));
@ -33,7 +33,7 @@ TEST(Sigaction, Sigkill) {
static int sigusr1Count;
static bool correctSignal;
TEST(Sigaction, CustomAction) {
TEST(LlvmLibcSigaction, CustomAction) {
// Zero this incase tests get run multiple times in the future.
sigusr1Count = 0;
@ -56,7 +56,7 @@ TEST(Sigaction, CustomAction) {
EXPECT_DEATH([] { __llvm_libc::raise(SIGUSR1); }, SIGUSR1);
}
TEST(Sigaction, Ignore) {
TEST(LlvmLibcSigaction, Ignore) {
struct __sigaction action;
EXPECT_THAT(__llvm_libc::sigaction(SIGUSR1, nullptr, &action), Succeeds());
action.sa_handler = SIG_IGN;

2
libc/test/src/signal/sigaddset_test.cpp
View File

@ -14,7 +14,7 @@
#include "utils/UnitTest/Test.h"
// This tests invalid inputs and ensures errno is properly set.
TEST(SignalTest, SigaddsetInvalid) {
TEST(LlvmLibcSignalTest, SigaddsetInvalid) {
using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
EXPECT_THAT(__llvm_libc::sigaddset(nullptr, SIGSEGV), Fails(EINVAL));

4
libc/test/src/signal/sigdelset_test.cpp
View File

@ -16,7 +16,7 @@
#include "test/ErrnoSetterMatcher.h"
#include "utils/UnitTest/Test.h"
TEST(Sigdelset, Invalid) {
TEST(LlvmLibcSigdelset, Invalid) {
using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
// Invalid set.
EXPECT_THAT(__llvm_libc::sigdelset(nullptr, SIGUSR1), Fails(EINVAL));
@ -26,7 +26,7 @@ TEST(Sigdelset, Invalid) {
EXPECT_THAT(__llvm_libc::sigdelset(&set, -1), Fails(EINVAL));
}
TEST(Sigdelset, UnblockOne) {
TEST(LlvmLibcSigdelset, UnblockOne) {
using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
sigset_t set;
EXPECT_THAT(__llvm_libc::sigfillset(&set), Succeeds());

4
libc/test/src/signal/sigfillset_test.cpp
View File

@ -15,12 +15,12 @@
#include "test/ErrnoSetterMatcher.h"
#include "utils/UnitTest/Test.h"
TEST(Sigfillset, Invalid) {
TEST(LlvmLibcSigfillset, Invalid) {
using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
EXPECT_THAT(__llvm_libc::sigfillset(nullptr), Fails(EINVAL));
}
TEST(Sigfillset, BlocksAll) {
TEST(LlvmLibcSigfillset, BlocksAll) {
using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
sigset_t set;
EXPECT_THAT(__llvm_libc::sigfillset(&set), Succeeds());

4
libc/test/src/signal/signal_test.cpp
View File

@ -18,7 +18,7 @@
using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
TEST(Signal, Invalid) {
TEST(LlvmLibcSignal, Invalid) {
llvmlibc_errno = 0;
__llvm_libc::sighandler_t valid = +[](int) {};
EXPECT_THAT((void *)__llvm_libc::signal(0, valid),
@ -28,7 +28,7 @@ TEST(Signal, Invalid) {
}
static int sum;
TEST(Signal, Basic) {
TEST(LlvmLibcSignal, Basic) {
// In case test get run multiple times.
sum = 0;
ASSERT_NE(__llvm_libc::signal(SIGUSR1, +[](int) { sum++; }),

6
libc/test/src/signal/sigprocmask_test.cpp
View File

@ -17,7 +17,7 @@
#include "test/ErrnoSetterMatcher.h"
#include "utils/UnitTest/Test.h"
class SignalTest : public __llvm_libc::testing::Test {
class LlvmLibcSignalTest : public __llvm_libc::testing::Test {
sigset_t oldSet;
public:
@ -32,7 +32,7 @@ using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
// This tests for invalid input.
TEST_F(SignalTest, SigprocmaskInvalid) {
TEST_F(LlvmLibcSignalTest, SigprocmaskInvalid) {
llvmlibc_errno = 0;
sigset_t valid;
@ -49,7 +49,7 @@ TEST_F(SignalTest, SigprocmaskInvalid) {
// This tests that when nothing is blocked, a process gets killed and alse tests
// that when signals are blocked they are not delivered to the process.
TEST_F(SignalTest, BlockUnblock) {
TEST_F(LlvmLibcSignalTest, BlockUnblock) {
sigset_t sigset;
EXPECT_EQ(__llvm_libc::sigemptyset(&sigset), 0);
EXPECT_EQ(__llvm_libc::sigprocmask(SIG_SETMASK, &sigset, nullptr), 0);

2
libc/test/src/stdio/fwrite_test.cpp
View File

@ -11,7 +11,7 @@
#include "utils/CPP/Array.h"
#include "utils/UnitTest/Test.h"
TEST(Stdio, FWriteBasic) {
TEST(LlvmLibcStdio, FWriteBasic) {
struct StrcpyFile : __llvm_libc::FILE {
char *buf;
} f;

2
libc/test/src/stdlib/_Exit_test.cpp
View File

@ -10,7 +10,7 @@
#include "src/stdlib/_Exit.h"
#include "utils/UnitTest/Test.h"
TEST(Stdlib, _Exit) {
TEST(LlvmLibcStdlib, _Exit) {
EXPECT_EXITS([] { __llvm_libc::_Exit(1); }, 1);
EXPECT_EXITS([] { __llvm_libc::_Exit(65); }, 65);
}

2
libc/test/src/stdlib/abort_test.cpp
View File

@ -11,7 +11,7 @@
#include "src/stdlib/abort.h"
#include "utils/UnitTest/Test.h"
TEST(Stdlib, abort) {
TEST(LlvmLibcStdlib, abort) {
// -1 matches against any signal, which is necessary for now until
// __llvm_libc::abort() unblocks SIGABRT.
EXPECT_DEATH([] { __llvm_libc::abort(); }, -1);

6
libc/test/src/stdlib/abs_test.cpp
View File

@ -9,8 +9,8 @@
#include "src/stdlib/abs.h"
#include "utils/UnitTest/Test.h"
TEST(AbsTest, Zero) { EXPECT_EQ(__llvm_libc::abs(0), 0); }
TEST(LlvmLibcAbsTest, Zero) { EXPECT_EQ(__llvm_libc::abs(0), 0); }
TEST(AbsTest, Positive) { EXPECT_EQ(__llvm_libc::abs(1), 1); }
TEST(LlvmLibcAbsTest, Positive) { EXPECT_EQ(__llvm_libc::abs(1), 1); }
TEST(AbsTest, Negative) { EXPECT_EQ(__llvm_libc::abs(-1), 1); }
TEST(LlvmLibcAbsTest, Negative) { EXPECT_EQ(__llvm_libc::abs(-1), 1); }

6
libc/test/src/stdlib/labs_test.cpp
View File

@ -9,8 +9,8 @@
#include "src/stdlib/labs.h"
#include "utils/UnitTest/Test.h"
TEST(LabsTest, Zero) { EXPECT_EQ(__llvm_libc::labs(0l), 0l); }
TEST(LlvmLibcLabsTest, Zero) { EXPECT_EQ(__llvm_libc::labs(0l), 0l); }
TEST(LabsTest, Positive) { EXPECT_EQ(__llvm_libc::labs(1l), 1l); }
TEST(LlvmLibcLabsTest, Positive) { EXPECT_EQ(__llvm_libc::labs(1l), 1l); }
TEST(LabsTest, Negative) { EXPECT_EQ(__llvm_libc::labs(-1l), 1l); }
TEST(LlvmLibcLabsTest, Negative) { EXPECT_EQ(__llvm_libc::labs(-1l), 1l); }

6
libc/test/src/stdlib/llabs_test.cpp
View File

@ -9,8 +9,8 @@
#include "src/stdlib/llabs.h"
#include "utils/UnitTest/Test.h"
TEST(LlabsTest, Zero) { EXPECT_EQ(__llvm_libc::llabs(0ll), 0ll); }
TEST(LlvmLibcLlabsTest, Zero) { EXPECT_EQ(__llvm_libc::llabs(0ll), 0ll); }
TEST(LlabsTest, Positive) { EXPECT_EQ(__llvm_libc::llabs(1ll), 1ll); }
TEST(LlvmLibcLlabsTest, Positive) { EXPECT_EQ(__llvm_libc::llabs(1ll), 1ll); }
TEST(LlabsTest, Negative) { EXPECT_EQ(__llvm_libc::llabs(-1ll), 1ll); }
TEST(LlvmLibcLlabsTest, Negative) { EXPECT_EQ(__llvm_libc::llabs(-1ll), 1ll); }

2
libc/test/src/string/bzero_test.cpp
View File

@ -24,7 +24,7 @@ Data getData(ArrayRef<char> filler) {
return out;
}
TEST(BzeroTest, Thorough) {
TEST(LlvmLibcBzeroTest, Thorough) {
const Data dirty = getData(kDeadcode);
for (size_t count = 0; count < 1024; ++count) {
for (size_t align = 0; align < 64; ++align) {

26
libc/test/src/string/memchr_test.cpp
View File

@ -16,7 +16,7 @@ const char *call_memchr(const void *src, int c, size_t size) {
return reinterpret_cast<const char *>(__llvm_libc::memchr(src, c, size));
}
TEST(MemChrTest, FindsCharacterAfterNullTerminator) {
TEST(LlvmLibcMemChrTest, FindsCharacterAfterNullTerminator) {
// memchr should continue searching after a null terminator.
const size_t size = 5;
const unsigned char src[size] = {'a', '\0', 'b', 'c', '\0'};
@ -24,7 +24,7 @@ TEST(MemChrTest, FindsCharacterAfterNullTerminator) {
ASSERT_STREQ(call_memchr(src, 'b', size), "bc");
}
TEST(MemChrTest, FindsCharacterInNonNullTerminatedCollection) {
TEST(LlvmLibcMemChrTest, FindsCharacterInNonNullTerminatedCollection) {
const size_t size = 3;
const unsigned char src[size] = {'a', 'b', 'c'};
// Should return 'b', 'c'.
@ -33,49 +33,49 @@ TEST(MemChrTest, FindsCharacterInNonNullTerminatedCollection) {
ASSERT_EQ(ret[1], 'c');
}
TEST(MemChrTest, FindsFirstCharacter) {
TEST(LlvmLibcMemChrTest, FindsFirstCharacter) {
const size_t size = 6;
const unsigned char src[size] = {'a', 'b', 'c', 'd', 'e', '\0'};
// Should return original array since 'a' is the first character.
ASSERT_STREQ(call_memchr(src, 'a', size), "abcde");
}
TEST(MemChrTest, FindsMiddleCharacter) {
TEST(LlvmLibcMemChrTest, FindsMiddleCharacter) {
const size_t size = 6;
const unsigned char src[size] = {'a', 'b', 'c', 'd', 'e', '\0'};
// Should return characters after (and including) 'c'.
ASSERT_STREQ(call_memchr(src, 'c', size), "cde");
}
TEST(MemChrTest, FindsLastCharacterThatIsNotNullTerminator) {
TEST(LlvmLibcMemChrTest, FindsLastCharacterThatIsNotNullTerminator) {
const size_t size = 6;
const unsigned char src[size] = {'a', 'b', 'c', 'd', 'e', '\0'};
// Should return 'e' and null-terminator.
ASSERT_STREQ(call_memchr(src, 'e', size), "e");
}
TEST(MemChrTest, FindsNullTerminator) {
TEST(LlvmLibcMemChrTest, FindsNullTerminator) {
const size_t size = 6;
const unsigned char src[size] = {'a', 'b', 'c', 'd', 'e', '\0'};
// Should return null terminator.
ASSERT_STREQ(call_memchr(src, '\0', size), "");
}
TEST(MemChrTest, CharacterNotWithinStringShouldReturnNullptr) {
TEST(LlvmLibcMemChrTest, CharacterNotWithinStringShouldReturnNullptr) {
const size_t size = 4;
const unsigned char src[size] = {'1', '2', '3', '?'};
// Since 'z' is not within 'characters', should return nullptr.
ASSERT_STREQ(call_memchr(src, 'z', size), nullptr);
}
TEST(MemChrTest, CharacterNotWithinSizeShouldReturnNullptr) {
TEST(LlvmLibcMemChrTest, CharacterNotWithinSizeShouldReturnNullptr) {
const unsigned char src[5] = {'1', '2', '3', '4', '\0'};
// Since '4' is not the first or second character, this should return nullptr.
const size_t size = 2;
ASSERT_STREQ(call_memchr(src, '4', size), nullptr);
}
TEST(MemChrTest, TheSourceShouldNotChange) {
TEST(LlvmLibcMemChrTest, TheSourceShouldNotChange) {
const size_t size = 6;
const unsigned char src[size] = {'a', 'b', 'c', 'd', 'e', '\0'};
const char *src_copy = reinterpret_cast<const char *>(src);
@ -87,14 +87,14 @@ TEST(MemChrTest, TheSourceShouldNotChange) {
ASSERT_STREQ(reinterpret_cast<const char *>(src), src_copy);
}
TEST(MemChrTest, ShouldFindFirstOfDuplicates) {
TEST(LlvmLibcMemChrTest, ShouldFindFirstOfDuplicates) {
const size_t size = 12; // 11 characters + null terminator.
const char *dups = "abc1def1ghi";
// 1 is duplicated in 'dups', but it should find the first copy.
ASSERT_STREQ(call_memchr(dups, '1', size), "1def1ghi");
}
TEST(MemChrTest, EmptyStringShouldOnlyMatchNullTerminator) {
TEST(LlvmLibcMemChrTest, EmptyStringShouldOnlyMatchNullTerminator) {
const size_t size = 1; // Null terminator.
const char *empty_string = "";
// Null terminator should match.
@ -105,14 +105,14 @@ TEST(MemChrTest, EmptyStringShouldOnlyMatchNullTerminator) {
ASSERT_STREQ(call_memchr(empty_string, '?', size), nullptr);
}
TEST(MemChrTest, SingleRepeatedCharacterShouldReturnFirst) {
TEST(LlvmLibcMemChrTest, SingleRepeatedCharacterShouldReturnFirst) {
const char *dups = "XXXXX";
const size_t size = 6; // 5 characters + null terminator.
// Should return original string since X is first character.
ASSERT_STREQ(call_memchr(dups, 'X', size), dups);
}
TEST(MemChrTest, SignedCharacterFound) {
TEST(LlvmLibcMemChrTest, SignedCharacterFound) {
char c = -1;
const size_t size = 1;
char src[size] = {c};

8
libc/test/src/string/memcmp_test.cpp
View File

@ -9,25 +9,25 @@
#include "src/string/memcmp.h"
#include "utils/UnitTest/Test.h"
TEST(MemcmpTest, CmpZeroByte) {
TEST(LlvmLibcMemcmpTest, CmpZeroByte) {
const char *lhs = "ab";
const char *rhs = "bc";
EXPECT_EQ(__llvm_libc::memcmp(lhs, rhs, 0), 0);
}
TEST(MemcmpTest, LhsRhsAreTheSame) {
TEST(LlvmLibcMemcmpTest, LhsRhsAreTheSame) {
const char *lhs = "ab";
const char *rhs = "ab";
EXPECT_EQ(__llvm_libc::memcmp(lhs, rhs, 2), 0);
}
TEST(MemcmpTest, LhsBeforeRhsLexically) {
TEST(LlvmLibcMemcmpTest, LhsBeforeRhsLexically) {
const char *lhs = "ab";
const char *rhs = "ac";
EXPECT_EQ(__llvm_libc::memcmp(lhs, rhs, 2), -1);
}
TEST(MemcmpTest, LhsAfterRhsLexically) {
TEST(LlvmLibcMemcmpTest, LhsAfterRhsLexically) {
const char *lhs = "ac";
const char *rhs = "ab";
EXPECT_EQ(__llvm_libc::memcmp(lhs, rhs, 2), 1);

2
libc/test/src/string/memcpy_test.cpp
View File

@ -25,7 +25,7 @@ Data getData(ArrayRef<char> filler) {
return out;
}
TEST(MemcpyTest, Thorough) {
TEST(LlvmLibcMemcpyTest, Thorough) {
const Data groundtruth = getData(kNumbers);
const Data dirty = getData(kDeadcode);
for (size_t count = 0; count < 1024; ++count) {

14
libc/test/src/string/memmove_test.cpp
View File

@ -11,7 +11,7 @@
#include "utils/CPP/ArrayRef.h"
#include "utils/UnitTest/Test.h"
class MemmoveTest : public __llvm_libc::testing::Test {
class LlvmLibcMemmoveTest : public __llvm_libc::testing::Test {
public:
void check_memmove(void *dest, const void *src, size_t count, const void *str,
const __llvm_libc::cpp::ArrayRef<unsigned char> expected) {
@ -25,20 +25,20 @@ public:
}
};
TEST_F(MemmoveTest, MoveZeroByte) {
TEST_F(LlvmLibcMemmoveTest, MoveZeroByte) {
unsigned char dest[] = {'a', 'b'};
const unsigned char src[] = {'y', 'z'};
const unsigned char expected[] = {'a', 'b'};
check_memmove(dest, src, 0, dest, expected);
}
TEST_F(MemmoveTest, OverlapThatDestAndSrcPointToSameAddress) {
TEST_F(LlvmLibcMemmoveTest, OverlapThatDestAndSrcPointToSameAddress) {
unsigned char str[] = {'a', 'b'};
const unsigned char expected[] = {'a', 'b'};
check_memmove(str, str, 1, str, expected);
}
TEST_F(MemmoveTest, OverlapThatDestStartsBeforeSrc) {
TEST_F(LlvmLibcMemmoveTest, OverlapThatDestStartsBeforeSrc) {
// Set boundary at beginning and end for not overstepping when
// copy forward or backward.
unsigned char str[] = {'z', 'a', 'b', 'c', 'z'};
@ -47,7 +47,7 @@ TEST_F(MemmoveTest, OverlapThatDestStartsBeforeSrc) {
check_memmove(&str[1], &str[2], 2, str, expected);
}
TEST_F(MemmoveTest, OverlapThatDestStartsAfterSrc) {
TEST_F(LlvmLibcMemmoveTest, OverlapThatDestStartsAfterSrc) {
unsigned char str[] = {'z', 'a', 'b', 'c', 'z'};
const unsigned char expected[] = {'z', 'a', 'a', 'b', 'z'};
check_memmove(&str[2], &str[1], 2, str, expected);
@ -57,13 +57,13 @@ TEST_F(MemmoveTest, OverlapThatDestStartsAfterSrc) {
// str: [abcdefghij]
// [__src_____]
// [_____dest_]
TEST_F(MemmoveTest, SrcFollowDest) {
TEST_F(LlvmLibcMemmoveTest, SrcFollowDest) {
unsigned char str[] = {'z', 'a', 'b', 'z'};
const unsigned char expected[] = {'z', 'b', 'b', 'z'};
check_memmove(&str[1], &str[2], 1, str, expected);
}
TEST_F(MemmoveTest, DestFollowSrc) {
TEST_F(LlvmLibcMemmoveTest, DestFollowSrc) {
unsigned char str[] = {'z', 'a', 'b', 'z'};
const unsigned char expected[] = {'z', 'a', 'a', 'z'};
check_memmove(&str[2], &str[1], 1, str, expected);

14
libc/test/src/string/memory_utils/memcpy_utils_test.cpp
View File

@ -79,7 +79,7 @@ extern "C" void LLVM_LIBC_MEMCPY_MONITOR(char *__restrict dst,
char *I(uintptr_t offset) { return reinterpret_cast<char *>(offset); }
TEST(MemcpyUtilsTest, CopyTrivial) {
TEST(LlvmLibcMemcpyUtilsTest, CopyTrivial) {
auto &trace = GetTrace();
trace.Clear();
@ -122,7 +122,7 @@ TEST(MemcpyUtilsTest, CopyTrivial) {
"1111111111111111111111111111111111111111111111111111111111111111");
}
TEST(MemcpyUtilsTest, CopyOffset) {
TEST(LlvmLibcMemcpyUtilsTest, CopyOffset) {
auto &trace = GetTrace();
trace.Clear();
@ -136,7 +136,7 @@ TEST(MemcpyUtilsTest, CopyOffset) {
EXPECT_STREQ(trace.Read(), "01");
}
TEST(MemcpyUtilsTest, CopyBlockOverlap) {
TEST(LlvmLibcMemcpyUtilsTest, CopyBlockOverlap) {
auto &trace = GetTrace();
trace.Clear();
@ -160,7 +160,7 @@ TEST(MemcpyUtilsTest, CopyBlockOverlap) {
EXPECT_STREQ(trace.Read(), "01112111");
}
TEST(MemcpyUtilsTest, CopyAlignedBlocks) {
TEST(LlvmLibcMemcpyUtilsTest, CopyAlignedBlocks) {
auto &trace = GetTrace();
// Source is aligned and multiple of alignment.
// "1111"
@ -211,7 +211,7 @@ TEST(MemcpyUtilsTest, CopyAlignedBlocks) {
EXPECT_STREQ(trace.Read(), "011121111111");
}
TEST(MemcpyUtilsTest, CopyAlignedBlocksWithAlignment) {
TEST(LlvmLibcMemcpyUtilsTest, CopyAlignedBlocksWithAlignment) {
auto &trace = GetTrace();
// Source is aligned and multiple of alignment.
// "11111111"
@ -228,7 +228,7 @@ TEST(MemcpyUtilsTest, CopyAlignedBlocksWithAlignment) {
EXPECT_STREQ(trace.Read(), "122211111");
}
TEST(MemcpyUtilsTest, CopyAlignedBlocksMaxReloads) {
TEST(LlvmLibcMemcpyUtilsTest, CopyAlignedBlocksMaxReloads) {
auto &trace = GetTrace();
for (size_t alignment = 0; alignment < 32; ++alignment) {
for (size_t count = 64; count < 768; ++count) {
@ -248,7 +248,7 @@ TEST(MemcpyUtilsTest, CopyAlignedBlocksMaxReloads) {
}
}
TEST(MemcpyUtilsTest, CopyAlignedBlocksWithAlignmentMaxReloads) {
TEST(LlvmLibcMemcpyUtilsTest, CopyAlignedBlocksWithAlignmentMaxReloads) {
auto &trace = GetTrace();
for (size_t alignment = 0; alignment < 32; ++alignment) {
for (size_t count = 64; count < 768; ++count) {

16
libc/test/src/string/memory_utils/utils_test.cpp
View File

@ -12,7 +12,7 @@
namespace __llvm_libc {
TEST(UtilsTest, IsPowerOfTwoOrZero) {
TEST(LlvmLibcUtilsTest, IsPowerOfTwoOrZero) {
static const cpp::Array<bool, 65> kExpectedValues{
1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // 0-15
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16-31
@ -24,7 +24,7 @@ TEST(UtilsTest, IsPowerOfTwoOrZero) {
EXPECT_EQ(is_power2_or_zero(i), kExpectedValues[i]);
}
TEST(UtilsTest, IsPowerOfTwo) {
TEST(LlvmLibcUtilsTest, IsPowerOfTwo) {
static const cpp::Array<bool, 65> kExpectedValues{
0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // 0-15
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16-31
@ -36,7 +36,7 @@ TEST(UtilsTest, IsPowerOfTwo) {
EXPECT_EQ(is_power2(i), kExpectedValues[i]);
}
TEST(UtilsTest, Log2) {
TEST(LlvmLibcUtilsTest, Log2) {
static const cpp::Array<size_t, 65> kExpectedValues{
0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, // 0-15
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, // 16-31
@ -48,7 +48,7 @@ TEST(UtilsTest, Log2) {
EXPECT_EQ(log2(i), kExpectedValues[i]);
}
TEST(UtilsTest, LEPowerOf2) {
TEST(LlvmLibcUtilsTest, LEPowerOf2) {
static const cpp::Array<size_t, 65> kExpectedValues{
0, 1, 2, 2, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, // 0-15
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, // 16-31
@ -60,7 +60,7 @@ TEST(UtilsTest, LEPowerOf2) {
EXPECT_EQ(le_power2(i), kExpectedValues[i]);
}
TEST(UtilsTest, GEPowerOf2) {
TEST(LlvmLibcUtilsTest, GEPowerOf2) {
static const cpp::Array<size_t, 66> kExpectedValues{
0, 1, 2, 4, 4, 8, 8, 8, 8, 16, 16, 16, 16, 16, 16, 16, // 0-15
16, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, // 16-31
@ -79,7 +79,7 @@ const void *forge(size_t offset) {
return reinterpret_cast<const void *>(offset);
}
TEST(UtilsTest, OffsetToNextAligned) {
TEST(LlvmLibcUtilsTest, OffsetToNextAligned) {
EXPECT_EQ(offset_to_next_aligned<16>(forge(0)), I(0));
EXPECT_EQ(offset_to_next_aligned<16>(forge(1)), I(15));
EXPECT_EQ(offset_to_next_aligned<16>(forge(16)), I(0));
@ -87,7 +87,7 @@ TEST(UtilsTest, OffsetToNextAligned) {
EXPECT_EQ(offset_to_next_aligned<32>(forge(16)), I(16));
}
TEST(UtilsTest, OffsetFromLastAligned) {
TEST(LlvmLibcUtilsTest, OffsetFromLastAligned) {
EXPECT_EQ(offset_from_last_aligned<16>(forge(0)), I(0));
EXPECT_EQ(offset_from_last_aligned<16>(forge(1)), I(1));
EXPECT_EQ(offset_from_last_aligned<16>(forge(16)), I(0));
@ -95,7 +95,7 @@ TEST(UtilsTest, OffsetFromLastAligned) {
EXPECT_EQ(offset_from_last_aligned<32>(forge(16)), I(16));
}
TEST(UtilsTest, OffsetToNextCacheLine) {
TEST(LlvmLibcUtilsTest, OffsetToNextCacheLine) {
EXPECT_GT(LLVM_LIBC_CACHELINE_SIZE, 0);
EXPECT_EQ(offset_to_next_cache_line(forge(0)), I(0));
EXPECT_EQ(offset_to_next_cache_line(forge(1)),

24
libc/test/src/string/memrchr_test.cpp
View File

@ -16,7 +16,7 @@ const char *call_memrchr(const void *src, int c, size_t size) {
return reinterpret_cast<const char *>(__llvm_libc::memrchr(src, c, size));
}
TEST(MemRChrTest, FindsCharacterAfterNullTerminator) {
TEST(LlvmLibcMemRChrTest, FindsCharacterAfterNullTerminator) {
// memrchr should continue searching after a null terminator.
const size_t size = 6;
const unsigned char src[size] = {'a', '\0', 'b', 'c', 'd', '\0'};
@ -24,7 +24,7 @@ TEST(MemRChrTest, FindsCharacterAfterNullTerminator) {
ASSERT_STREQ(call_memrchr(src, 'b', size), "bcd");
}
TEST(MemRChrTest, FindsCharacterInNonNullTerminatedCollection) {
TEST(LlvmLibcMemRChrTest, FindsCharacterInNonNullTerminatedCollection) {
const size_t size = 3;
const unsigned char src[size] = {'a', 'b', 'c'};
// Should return 'b', 'c'.
@ -33,49 +33,49 @@ TEST(MemRChrTest, FindsCharacterInNonNullTerminatedCollection) {
ASSERT_EQ(ret[1], 'c');
}
TEST(MemRChrTest, FindsFirstCharacter) {
TEST(LlvmLibcMemRChrTest, FindsFirstCharacter) {
const size_t size = 6;
const unsigned char src[size] = {'a', 'b', 'c', 'd', 'e', '\0'};
// Should return original array since 'a' is the first character.
ASSERT_STREQ(call_memrchr(src, 'a', size), "abcde");
}
TEST(MemRChrTest, FindsMiddleCharacter) {
TEST(LlvmLibcMemRChrTest, FindsMiddleCharacter) {
const size_t size = 6;
const unsigned char src[size] = {'a', 'b', 'c', 'd', 'e', '\0'};
// Should return characters after (and including) 'c'.
ASSERT_STREQ(call_memrchr(src, 'c', size), "cde");
}
TEST(MemRChrTest, FindsLastCharacterThatIsNotNullTerminator) {
TEST(LlvmLibcMemRChrTest, FindsLastCharacterThatIsNotNullTerminator) {
const size_t size = 6;
const unsigned char src[size] = {'a', 'b', 'c', 'd', 'e', '\0'};
// Should return 'e' and null-terminator.
ASSERT_STREQ(call_memrchr(src, 'e', size), "e");
}
TEST(MemRChrTest, FindsNullTerminator) {
TEST(LlvmLibcMemRChrTest, FindsNullTerminator) {
const size_t size = 6;
const unsigned char src[size] = {'a', 'b', 'c', 'd', 'e', '\0'};
// Should return null terminator.
ASSERT_STREQ(call_memrchr(src, '\0', size), "");
}
TEST(MemRChrTest, CharacterNotWithinStringShouldReturnNullptr) {
TEST(LlvmLibcMemRChrTest, CharacterNotWithinStringShouldReturnNullptr) {
const size_t size = 4;
const unsigned char src[size] = {'1', '2', '3', '?'};
// Since 'z' is not within 'characters', should return nullptr.
ASSERT_STREQ(call_memrchr(src, 'z', size), nullptr);
}
TEST(MemRChrTest, CharacterNotWithinSizeShouldReturnNullptr) {
TEST(LlvmLibcMemRChrTest, CharacterNotWithinSizeShouldReturnNullptr) {
const unsigned char src[5] = {'1', '2', '3', '4', '\0'};
// Since '4' is not within the first 2 characters, this should return nullptr.
const size_t size = 2;
ASSERT_STREQ(call_memrchr(src, '4', size), nullptr);
}
TEST(MemRChrTest, ShouldFindLastOfDuplicates) {
TEST(LlvmLibcMemRChrTest, ShouldFindLastOfDuplicates) {
size_t size = 12; // 11 characters + null terminator.
const char *dups = "abc1def1ghi";
// 1 is duplicated in 'dups', but it should find the last copy.
@ -87,7 +87,7 @@ TEST(MemRChrTest, ShouldFindLastOfDuplicates) {
ASSERT_STREQ(call_memrchr(repeated, 'X', size), "X");
}
TEST(MemRChrTest, EmptyStringShouldOnlyMatchNullTerminator) {
TEST(LlvmLibcMemRChrTest, EmptyStringShouldOnlyMatchNullTerminator) {
const size_t size = 1; // Null terminator.
const char *empty_string = "";
// Null terminator should match.
@ -98,7 +98,7 @@ TEST(MemRChrTest, EmptyStringShouldOnlyMatchNullTerminator) {
ASSERT_STREQ(call_memrchr(empty_string, '?', size), nullptr);
}
TEST(MemRChrTest, SignedCharacterFound) {
TEST(LlvmLibcMemRChrTest, SignedCharacterFound) {
char c = -1;
const size_t size = 1;
char src[size] = {c};
@ -107,7 +107,7 @@ TEST(MemRChrTest, SignedCharacterFound) {
ASSERT_EQ(actual[0], c);
}
TEST(MemRChrTest, ZeroLengthShouldReturnNullptr) {
TEST(LlvmLibcMemRChrTest, ZeroLengthShouldReturnNullptr) {
const unsigned char src[4] = {'a', 'b', 'c', '\0'};
// This will iterate over exactly zero characters, so should return nullptr.
ASSERT_STREQ(call_memrchr(src, 'd', 0), nullptr);

2
libc/test/src/string/memset_test.cpp
View File

@ -24,7 +24,7 @@ Data getData(ArrayRef<char> filler) {
return out;
}
TEST(MemsetTest, Thorough) {
TEST(LlvmLibcMemsetTest, Thorough) {
const Data dirty = getData(kDeadcode);
for (int value = -1; value <= 1; ++value) {
for (size_t count = 0; count < 1024; ++count) {

4
libc/test/src/string/strcat_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/string/strcat.h"
#include "utils/UnitTest/Test.h"
TEST(StrCatTest, EmptyDest) {
TEST(LlvmLibcStrCatTest, EmptyDest) {
const char *abc = "abc";
char dest[4];
@ -21,7 +21,7 @@ TEST(StrCatTest, EmptyDest) {
ASSERT_STREQ(dest, abc);
}
TEST(StrCatTest, NonEmptyDest) {
TEST(LlvmLibcStrCatTest, NonEmptyDest) {
const char *abc = "abc";
char dest[7];

16
libc/test/src/string/strchr_test.cpp
View File

@ -9,7 +9,7 @@
#include "src/string/strchr.h"
#include "utils/UnitTest/Test.h"
TEST(StrChrTest, FindsFirstCharacter) {
TEST(LlvmLibcStrChrTest, FindsFirstCharacter) {
const char *src = "abcde";
// Should return original string since 'a' is the first character.
@ -18,7 +18,7 @@ TEST(StrChrTest, FindsFirstCharacter) {
ASSERT_STREQ(src, "abcde");
}
TEST(StrChrTest, FindsMiddleCharacter) {
TEST(LlvmLibcStrChrTest, FindsMiddleCharacter) {
const char *src = "abcde";
// Should return characters after (and including) 'c'.
@ -27,7 +27,7 @@ TEST(StrChrTest, FindsMiddleCharacter) {
ASSERT_STREQ(src, "abcde");
}
TEST(StrChrTest, FindsLastCharacterThatIsNotNullTerminator) {
TEST(LlvmLibcStrChrTest, FindsLastCharacterThatIsNotNullTerminator) {
const char *src = "abcde";
// Should return 'e' and null-terminator.
@ -36,7 +36,7 @@ TEST(StrChrTest, FindsLastCharacterThatIsNotNullTerminator) {
ASSERT_STREQ(src, "abcde");
}
TEST(StrChrTest, FindsNullTerminator) {
TEST(LlvmLibcStrChrTest, FindsNullTerminator) {
const char *src = "abcde";
// Should return null terminator.
@ -45,12 +45,12 @@ TEST(StrChrTest, FindsNullTerminator) {
ASSERT_STREQ(src, "abcde");
}
TEST(StrChrTest, CharacterNotWithinStringShouldReturnNullptr) {
TEST(LlvmLibcStrChrTest, CharacterNotWithinStringShouldReturnNullptr) {
// Since 'z' is not within the string, should return nullptr.
ASSERT_STREQ(__llvm_libc::strchr("123?", 'z'), nullptr);
}
TEST(StrChrTest, TheSourceShouldNotChange) {
TEST(LlvmLibcStrChrTest, TheSourceShouldNotChange) {
const char *src = "abcde";
// When the character is found, the source string should not change.
__llvm_libc::strchr(src, 'd');
@ -63,7 +63,7 @@ TEST(StrChrTest, TheSourceShouldNotChange) {
ASSERT_STREQ(src, "abcde");
}
TEST(StrChrTest, ShouldFindFirstOfDuplicates) {
TEST(LlvmLibcStrChrTest, ShouldFindFirstOfDuplicates) {
// '1' is duplicated in the string, but it should find the first copy.
ASSERT_STREQ(__llvm_libc::strchr("abc1def1ghi", '1'), "1def1ghi");
@ -72,7 +72,7 @@ TEST(StrChrTest, ShouldFindFirstOfDuplicates) {
ASSERT_STREQ(__llvm_libc::strchr(dups, 'X'), dups);
}
TEST(StrChrTest, EmptyStringShouldOnlyMatchNullTerminator) {
TEST(LlvmLibcStrChrTest, EmptyStringShouldOnlyMatchNullTerminator) {
// Null terminator should match.
ASSERT_STREQ(__llvm_libc::strchr("", '\0'), "");
// All other characters should not match.

Some files were not shown because too many files have changed in this diff Show More