20 changes: 10 additions & 10 deletions libc/test/src/math/smoke/FMinimumMagTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,34 +26,34 @@ class FMinimumMagTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
void testNaN(FMinimumMagFunc func) {
EXPECT_FP_EQ(aNaN, func(aNaN, inf));
EXPECT_FP_EQ(aNaN, func(neg_inf, aNaN));
EXPECT_FP_EQ(aNaN, func(aNaN, 0.0));
EXPECT_FP_EQ(aNaN, func(-0.0, aNaN));
EXPECT_FP_EQ(aNaN, func(aNaN, zero));
EXPECT_FP_EQ(aNaN, func(neg_zero, aNaN));
EXPECT_FP_EQ(aNaN, func(aNaN, T(-1.2345)));
EXPECT_FP_EQ(aNaN, func(T(1.2345), aNaN));
EXPECT_FP_EQ(aNaN, func(aNaN, aNaN));
}

void testInfArg(FMinimumMagFunc func) {
EXPECT_FP_EQ(neg_inf, func(neg_inf, inf));
EXPECT_FP_EQ(0.0, func(inf, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, inf));
EXPECT_FP_EQ(zero, func(inf, zero));
EXPECT_FP_EQ(neg_zero, func(neg_zero, inf));
EXPECT_FP_EQ(T(1.2345), func(inf, T(1.2345)));
EXPECT_FP_EQ(T(-1.2345), func(T(-1.2345), inf));
}

void testNegInfArg(FMinimumMagFunc func) {
EXPECT_FP_EQ(neg_inf, func(inf, neg_inf));
EXPECT_FP_EQ(0.0, func(neg_inf, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, neg_inf));
EXPECT_FP_EQ(zero, func(neg_inf, zero));
EXPECT_FP_EQ(neg_zero, func(neg_zero, neg_inf));
EXPECT_FP_EQ(T(-1.2345), func(neg_inf, T(-1.2345)));
EXPECT_FP_EQ(T(1.2345), func(T(1.2345), neg_inf));
}

void testBothZero(FMinimumMagFunc func) {
EXPECT_FP_EQ(0.0, func(0.0, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, 0.0));
EXPECT_FP_EQ(-0.0, func(0.0, -0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
EXPECT_FP_EQ(zero, func(zero, zero));
EXPECT_FP_EQ(neg_zero, func(neg_zero, zero));
EXPECT_FP_EQ(neg_zero, func(zero, neg_zero));
EXPECT_FP_EQ(neg_zero, func(neg_zero, neg_zero));
}

void testRange(FMinimumMagFunc func) {
Expand Down
24 changes: 12 additions & 12 deletions libc/test/src/math/smoke/FMinimumNumTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,10 +29,10 @@ class FMinimumNumTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
EXPECT_FP_EQ(neg_inf, func(neg_inf, aNaN));
EXPECT_FP_EQ_WITH_EXCEPTION(neg_inf, func(neg_inf, sNaN), FE_INVALID);
EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(aNaN, aNaN)).uintval());
EXPECT_FP_EQ(0.0, func(aNaN, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, aNaN));
EXPECT_FP_EQ_WITH_EXCEPTION(0.0, func(sNaN, 0.0), FE_INVALID);
EXPECT_FP_EQ_WITH_EXCEPTION(-0.0, func(-0.0, sNaN), FE_INVALID);
EXPECT_FP_EQ(zero, func(aNaN, zero));
EXPECT_FP_EQ(neg_zero, func(neg_zero, aNaN));
EXPECT_FP_EQ_WITH_EXCEPTION(zero, func(sNaN, zero), FE_INVALID);
EXPECT_FP_EQ_WITH_EXCEPTION(neg_zero, func(neg_zero, sNaN), FE_INVALID);
EXPECT_FP_EQ(T(-1.2345), func(aNaN, T(-1.2345)));
EXPECT_FP_EQ(T(1.2345), func(T(1.2345), aNaN));
EXPECT_FP_EQ_WITH_EXCEPTION(T(-1.2345), func(sNaN, T(-1.2345)), FE_INVALID);
Expand All @@ -46,25 +46,25 @@ class FMinimumNumTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {

void testInfArg(FMinimumNumFunc func) {
EXPECT_FP_EQ(neg_inf, func(neg_inf, inf));
EXPECT_FP_EQ(0.0, func(inf, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, inf));
EXPECT_FP_EQ(zero, func(inf, zero));
EXPECT_FP_EQ(neg_zero, func(neg_zero, inf));
EXPECT_FP_EQ(T(1.2345), func(inf, T(1.2345)));
EXPECT_FP_EQ(T(-1.2345), func(T(-1.2345), inf));
}

void testNegInfArg(FMinimumNumFunc func) {
EXPECT_FP_EQ(neg_inf, func(inf, neg_inf));
EXPECT_FP_EQ(neg_inf, func(neg_inf, 0.0));
EXPECT_FP_EQ(neg_inf, func(-0.0, neg_inf));
EXPECT_FP_EQ(neg_inf, func(neg_inf, zero));
EXPECT_FP_EQ(neg_inf, func(neg_zero, neg_inf));
EXPECT_FP_EQ(neg_inf, func(neg_inf, T(-1.2345)));
EXPECT_FP_EQ(neg_inf, func(T(1.2345), neg_inf));
}

void testBothZero(FMinimumNumFunc func) {
EXPECT_FP_EQ(0.0, func(0.0, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, 0.0));
EXPECT_FP_EQ(-0.0, func(0.0, -0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
EXPECT_FP_EQ(zero, func(zero, zero));
EXPECT_FP_EQ(neg_zero, func(neg_zero, zero));
EXPECT_FP_EQ(neg_zero, func(zero, neg_zero));
EXPECT_FP_EQ(neg_zero, func(neg_zero, neg_zero));
}

void testRange(FMinimumNumFunc func) {
Expand Down
20 changes: 10 additions & 10 deletions libc/test/src/math/smoke/FMinimumTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,34 +25,34 @@ class FMinimumTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
void testNaN(FMinimumFunc func) {
EXPECT_FP_EQ(aNaN, func(aNaN, inf));
EXPECT_FP_EQ(aNaN, func(neg_inf, aNaN));
EXPECT_FP_EQ(aNaN, func(aNaN, 0.0));
EXPECT_FP_EQ(aNaN, func(-0.0, aNaN));
EXPECT_FP_EQ(aNaN, func(aNaN, zero));
EXPECT_FP_EQ(aNaN, func(neg_zero, aNaN));
EXPECT_FP_EQ(aNaN, func(aNaN, T(-1.2345)));
EXPECT_FP_EQ(aNaN, func(T(1.2345), aNaN));
EXPECT_FP_EQ(aNaN, func(aNaN, aNaN));
}

void testInfArg(FMinimumFunc func) {
EXPECT_FP_EQ(neg_inf, func(neg_inf, inf));
EXPECT_FP_EQ(0.0, func(inf, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, inf));
EXPECT_FP_EQ(zero, func(inf, zero));
EXPECT_FP_EQ(neg_zero, func(neg_zero, inf));
EXPECT_FP_EQ(T(1.2345), func(inf, T(1.2345)));
EXPECT_FP_EQ(T(1.2345), func(T(1.2345), inf));
}

void testNegInfArg(FMinimumFunc func) {
EXPECT_FP_EQ(neg_inf, func(inf, neg_inf));
EXPECT_FP_EQ(neg_inf, func(neg_inf, 0.0));
EXPECT_FP_EQ(neg_inf, func(-0.0, neg_inf));
EXPECT_FP_EQ(neg_inf, func(neg_inf, zero));
EXPECT_FP_EQ(neg_inf, func(neg_zero, neg_inf));
EXPECT_FP_EQ(neg_inf, func(neg_inf, T(-1.2345)));
EXPECT_FP_EQ(neg_inf, func(T(1.2345), neg_inf));
}

void testBothZero(FMinimumFunc func) {
EXPECT_FP_EQ(0.0, func(0.0, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, 0.0));
EXPECT_FP_EQ(-0.0, func(0.0, -0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
EXPECT_FP_EQ(zero, func(zero, zero));
EXPECT_FP_EQ(neg_zero, func(neg_zero, zero));
EXPECT_FP_EQ(neg_zero, func(zero, neg_zero));
EXPECT_FP_EQ(neg_zero, func(neg_zero, neg_zero));
}

void testRange(FMinimumFunc func) {
Expand Down
170 changes: 85 additions & 85 deletions libc/test/src/math/smoke/FModTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,16 +35,16 @@ class FmodTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {

void testSpecialNumbers(FModFunc f) {
// fmod (+0, y) == +0 for y != 0.
TEST_SPECIAL(0.0, 3.0, 0.0, false, 0);
TEST_SPECIAL(0.0, min_denormal, 0.0, false, 0);
TEST_SPECIAL(0.0, -min_denormal, 0.0, false, 0);
TEST_SPECIAL(0.0, min_normal, 0.0, false, 0);
TEST_SPECIAL(0.0, -min_normal, 0.0, false, 0);
TEST_SPECIAL(0.0, max_normal, 0.0, false, 0);
TEST_SPECIAL(0.0, -max_normal, 0.0, false, 0);
TEST_SPECIAL(zero, T(3.0), zero, false, 0);
TEST_SPECIAL(zero, min_denormal, zero, false, 0);
TEST_SPECIAL(zero, -min_denormal, zero, false, 0);
TEST_SPECIAL(zero, min_normal, zero, false, 0);
TEST_SPECIAL(zero, -min_normal, zero, false, 0);
TEST_SPECIAL(zero, max_normal, zero, false, 0);
TEST_SPECIAL(zero, -max_normal, zero, false, 0);

// fmod (-0, y) == -0 for y != 0.
TEST_SPECIAL(neg_zero, 3.0, neg_zero, false, 0);
TEST_SPECIAL(neg_zero, T(3.0), neg_zero, false, 0);
TEST_SPECIAL(neg_zero, min_denormal, neg_zero, false, 0);
TEST_SPECIAL(neg_zero, -min_denormal, neg_zero, false, 0);
TEST_SPECIAL(neg_zero, min_normal, neg_zero, false, 0);
Expand All @@ -53,9 +53,9 @@ class FmodTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
TEST_SPECIAL(neg_zero, -max_normal, neg_zero, false, 0);

// fmod (+inf, y) == aNaN plus invalid exception.
TEST_SPECIAL(inf, 3.0, aNaN, true, FE_INVALID);
TEST_SPECIAL(inf, -1.1L, aNaN, true, FE_INVALID);
TEST_SPECIAL(inf, 0.0, aNaN, true, FE_INVALID);
TEST_SPECIAL(inf, T(3.0), aNaN, true, FE_INVALID);
TEST_SPECIAL(inf, T(-1.1), aNaN, true, FE_INVALID);
TEST_SPECIAL(inf, zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(inf, neg_zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(inf, min_denormal, aNaN, true, FE_INVALID);
TEST_SPECIAL(inf, min_normal, aNaN, true, FE_INVALID);
Expand All @@ -64,9 +64,9 @@ class FmodTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
TEST_SPECIAL(inf, neg_inf, aNaN, true, FE_INVALID);

// fmod (-inf, y) == aNaN plus invalid exception.
TEST_SPECIAL(neg_inf, 3.0, aNaN, true, FE_INVALID);
TEST_SPECIAL(neg_inf, -1.1L, aNaN, true, FE_INVALID);
TEST_SPECIAL(neg_inf, 0.0, aNaN, true, FE_INVALID);
TEST_SPECIAL(neg_inf, T(3.0), aNaN, true, FE_INVALID);
TEST_SPECIAL(neg_inf, T(-1.1), aNaN, true, FE_INVALID);
TEST_SPECIAL(neg_inf, zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(neg_inf, neg_zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(neg_inf, min_denormal, aNaN, true, FE_INVALID);
TEST_SPECIAL(neg_inf, min_normal, aNaN, true, FE_INVALID);
Expand All @@ -75,74 +75,74 @@ class FmodTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
TEST_SPECIAL(neg_inf, neg_inf, aNaN, true, FE_INVALID);

// fmod (x, +0) == aNaN plus invalid exception.
TEST_SPECIAL(3.0, 0.0, aNaN, true, FE_INVALID);
TEST_SPECIAL(-1.1L, 0.0, aNaN, true, FE_INVALID);
TEST_SPECIAL(0.0, 0.0, aNaN, true, FE_INVALID);
TEST_SPECIAL(neg_zero, 0.0, aNaN, true, FE_INVALID);
TEST_SPECIAL(min_denormal, 0.0, aNaN, true, FE_INVALID);
TEST_SPECIAL(min_normal, 0.0, aNaN, true, FE_INVALID);
TEST_SPECIAL(max_normal, 0.0, aNaN, true, FE_INVALID);
TEST_SPECIAL(T(3.0), zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(T(-1.1), zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(zero, zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(neg_zero, zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(min_denormal, zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(min_normal, zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(max_normal, zero, aNaN, true, FE_INVALID);

// fmod (x, -0) == aNaN plus invalid exception.
TEST_SPECIAL(3.0, neg_zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(-1.1L, neg_zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(0.0, neg_zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(T(3.0), neg_zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(T(-1.1), neg_zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(zero, neg_zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(neg_zero, neg_zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(min_denormal, neg_zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(min_normal, neg_zero, aNaN, true, FE_INVALID);
TEST_SPECIAL(max_normal, neg_zero, aNaN, true, FE_INVALID);

// fmod (x, +inf) == x for x not infinite.
TEST_SPECIAL(0.0, inf, 0.0, false, 0);
TEST_SPECIAL(zero, inf, zero, false, 0);
TEST_SPECIAL(neg_zero, inf, neg_zero, false, 0);
TEST_SPECIAL(min_denormal, inf, min_denormal, false, 0);
TEST_SPECIAL(min_normal, inf, min_normal, false, 0);
TEST_SPECIAL(max_normal, inf, max_normal, false, 0);
TEST_SPECIAL(3.0, inf, 3.0, false, 0);
TEST_SPECIAL(T(3.0), inf, T(3.0), false, 0);
// fmod (x, -inf) == x for x not infinite.
TEST_SPECIAL(0.0, neg_inf, 0.0, false, 0);
TEST_SPECIAL(zero, neg_inf, zero, false, 0);
TEST_SPECIAL(neg_zero, neg_inf, neg_zero, false, 0);
TEST_SPECIAL(min_denormal, neg_inf, min_denormal, false, 0);
TEST_SPECIAL(min_normal, neg_inf, min_normal, false, 0);
TEST_SPECIAL(max_normal, neg_inf, max_normal, false, 0);
TEST_SPECIAL(3.0, neg_inf, 3.0, false, 0);
TEST_SPECIAL(T(3.0), neg_inf, T(3.0), false, 0);

TEST_SPECIAL(0.0, aNaN, aNaN, false, 0);
TEST_SPECIAL(0.0, -aNaN, aNaN, false, 0);
TEST_SPECIAL(zero, aNaN, aNaN, false, 0);
TEST_SPECIAL(zero, -aNaN, aNaN, false, 0);
TEST_SPECIAL(neg_zero, aNaN, aNaN, false, 0);
TEST_SPECIAL(neg_zero, -aNaN, aNaN, false, 0);
TEST_SPECIAL(1.0, aNaN, aNaN, false, 0);
TEST_SPECIAL(1.0, -aNaN, aNaN, false, 0);
TEST_SPECIAL(T(1.0), aNaN, aNaN, false, 0);
TEST_SPECIAL(T(1.0), -aNaN, aNaN, false, 0);
TEST_SPECIAL(inf, aNaN, aNaN, false, 0);
TEST_SPECIAL(inf, -aNaN, aNaN, false, 0);
TEST_SPECIAL(neg_inf, aNaN, aNaN, false, 0);
TEST_SPECIAL(neg_inf, -aNaN, aNaN, false, 0);
TEST_SPECIAL(0.0, sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(0.0, -sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(zero, sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(zero, -sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(neg_zero, sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(neg_zero, -sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(1.0, sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(1.0, -sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(T(1.0), sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(T(1.0), -sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(inf, sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(inf, -sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(neg_inf, sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(neg_inf, -sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(aNaN, 0.0, aNaN, false, 0);
TEST_SPECIAL(-aNaN, 0.0, aNaN, false, 0);
TEST_SPECIAL(aNaN, zero, aNaN, false, 0);
TEST_SPECIAL(-aNaN, zero, aNaN, false, 0);
TEST_SPECIAL(aNaN, neg_zero, aNaN, false, 0);
TEST_SPECIAL(-aNaN, neg_zero, aNaN, false, 0);
TEST_SPECIAL(aNaN, 1.0, aNaN, false, 0);
TEST_SPECIAL(-aNaN, 1.0, aNaN, false, 0);
TEST_SPECIAL(aNaN, T(1.0), aNaN, false, 0);
TEST_SPECIAL(-aNaN, T(1.0), aNaN, false, 0);
TEST_SPECIAL(aNaN, inf, aNaN, false, 0);
TEST_SPECIAL(-aNaN, inf, aNaN, false, 0);
TEST_SPECIAL(aNaN, neg_inf, aNaN, false, 0);
TEST_SPECIAL(-aNaN, neg_inf, aNaN, false, 0);
TEST_SPECIAL(sNaN, 0.0, aNaN, false, FE_INVALID);
TEST_SPECIAL(-sNaN, 0.0, aNaN, false, FE_INVALID);
TEST_SPECIAL(sNaN, zero, aNaN, false, FE_INVALID);
TEST_SPECIAL(-sNaN, zero, aNaN, false, FE_INVALID);
TEST_SPECIAL(sNaN, neg_zero, aNaN, false, FE_INVALID);
TEST_SPECIAL(-sNaN, neg_zero, aNaN, false, FE_INVALID);
TEST_SPECIAL(sNaN, 1.0, aNaN, false, FE_INVALID);
TEST_SPECIAL(-sNaN, 1.0, aNaN, false, FE_INVALID);
TEST_SPECIAL(sNaN, T(1.0), aNaN, false, FE_INVALID);
TEST_SPECIAL(-sNaN, T(1.0), aNaN, false, FE_INVALID);
TEST_SPECIAL(sNaN, inf, aNaN, false, FE_INVALID);
TEST_SPECIAL(-sNaN, inf, aNaN, false, FE_INVALID);
TEST_SPECIAL(sNaN, neg_inf, aNaN, false, FE_INVALID);
Expand All @@ -164,17 +164,17 @@ class FmodTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
TEST_SPECIAL(-sNaN, sNaN, aNaN, false, FE_INVALID);
TEST_SPECIAL(-sNaN, -sNaN, aNaN, false, FE_INVALID);

TEST_SPECIAL(6.5, 2.25L, 2.0L, false, 0);
TEST_SPECIAL(-6.5, 2.25L, -2.0L, false, 0);
TEST_SPECIAL(6.5, -2.25L, 2.0L, false, 0);
TEST_SPECIAL(-6.5, -2.25L, -2.0L, false, 0);

TEST_SPECIAL(max_normal, max_normal, 0.0, false, 0);
TEST_SPECIAL(max_normal, -max_normal, 0.0, false, 0);
TEST_SPECIAL(max_normal, min_normal, 0.0, false, 0);
TEST_SPECIAL(max_normal, -min_normal, 0.0, false, 0);
TEST_SPECIAL(max_normal, min_denormal, 0.0, false, 0);
TEST_SPECIAL(max_normal, -min_denormal, 0.0, false, 0);
TEST_SPECIAL(T(6.5), T(2.25), T(2.0), false, 0);
TEST_SPECIAL(T(-6.5), T(2.25), T(-2.0), false, 0);
TEST_SPECIAL(T(6.5), T(-2.25), T(2.0), false, 0);
TEST_SPECIAL(T(-6.5), T(-2.25), T(-2.0), false, 0);

TEST_SPECIAL(max_normal, max_normal, zero, false, 0);
TEST_SPECIAL(max_normal, -max_normal, zero, false, 0);
TEST_SPECIAL(max_normal, min_normal, zero, false, 0);
TEST_SPECIAL(max_normal, -min_normal, zero, false, 0);
TEST_SPECIAL(max_normal, min_denormal, zero, false, 0);
TEST_SPECIAL(max_normal, -min_denormal, zero, false, 0);
TEST_SPECIAL(-max_normal, max_normal, neg_zero, false, 0);
TEST_SPECIAL(-max_normal, -max_normal, neg_zero, false, 0);
TEST_SPECIAL(-max_normal, min_normal, neg_zero, false, 0);
Expand All @@ -184,10 +184,10 @@ class FmodTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {

TEST_SPECIAL(min_normal, max_normal, min_normal, false, 0);
TEST_SPECIAL(min_normal, -max_normal, min_normal, false, 0);
TEST_SPECIAL(min_normal, min_normal, 0.0, false, 0);
TEST_SPECIAL(min_normal, -min_normal, 0.0, false, 0);
TEST_SPECIAL(min_normal, min_denormal, 0.0, false, 0);
TEST_SPECIAL(min_normal, -min_denormal, 0.0, false, 0);
TEST_SPECIAL(min_normal, min_normal, zero, false, 0);
TEST_SPECIAL(min_normal, -min_normal, zero, false, 0);
TEST_SPECIAL(min_normal, min_denormal, zero, false, 0);
TEST_SPECIAL(min_normal, -min_denormal, zero, false, 0);
TEST_SPECIAL(-min_normal, max_normal, -min_normal, false, 0);
TEST_SPECIAL(-min_normal, -max_normal, -min_normal, false, 0);
TEST_SPECIAL(-min_normal, min_normal, neg_zero, false, 0);
Expand All @@ -199,8 +199,8 @@ class FmodTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
TEST_SPECIAL(min_denormal, -max_normal, min_denormal, false, 0);
TEST_SPECIAL(min_denormal, min_normal, min_denormal, false, 0);
TEST_SPECIAL(min_denormal, -min_normal, min_denormal, false, 0);
TEST_SPECIAL(min_denormal, min_denormal, 0.0, false, 0);
TEST_SPECIAL(min_denormal, -min_denormal, 0.0, false, 0);
TEST_SPECIAL(min_denormal, min_denormal, zero, false, 0);
TEST_SPECIAL(min_denormal, -min_denormal, zero, false, 0);
TEST_SPECIAL(-min_denormal, max_normal, -min_denormal, false, 0);
TEST_SPECIAL(-min_denormal, -max_normal, -min_denormal, false, 0);
TEST_SPECIAL(-min_denormal, min_normal, -min_denormal, false, 0);
Expand All @@ -212,33 +212,33 @@ class FmodTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
void testRegularExtreme(FModFunc f) {
if constexpr (sizeof(T) < sizeof(float))
return;
TEST_REGULAR(0x1p127L, 0x3p-149L, 0x1p-149L);
TEST_REGULAR(0x1p127L, -0x3p-149L, 0x1p-149L);
TEST_REGULAR(0x1p127L, 0x3p-148L, 0x1p-147L);
TEST_REGULAR(0x1p127L, -0x3p-148L, 0x1p-147L);
TEST_REGULAR(0x1p127L, 0x3p-126L, 0x1p-125L);
TEST_REGULAR(0x1p127L, -0x3p-126L, 0x1p-125L);
TEST_REGULAR(-0x1p127L, 0x3p-149L, -0x1p-149L);
TEST_REGULAR(-0x1p127L, -0x3p-149L, -0x1p-149L);
TEST_REGULAR(-0x1p127L, 0x3p-148L, -0x1p-147L);
TEST_REGULAR(-0x1p127L, -0x3p-148L, -0x1p-147L);
TEST_REGULAR(-0x1p127L, 0x3p-126L, -0x1p-125L);
TEST_REGULAR(-0x1p127L, -0x3p-126L, -0x1p-125L);
TEST_REGULAR(T(0x1p127), T(0x3p-149), T(0x1p-149));
TEST_REGULAR(T(0x1p127), T(-0x3p-149), T(0x1p-149));
TEST_REGULAR(T(0x1p127), T(0x3p-148), T(0x1p-147));
TEST_REGULAR(T(0x1p127), T(-0x3p-148), T(0x1p-147));
TEST_REGULAR(T(0x1p127), T(0x3p-126), T(0x1p-125));
TEST_REGULAR(T(0x1p127), T(-0x3p-126), T(0x1p-125));
TEST_REGULAR(T(-0x1p127), T(0x3p-149), T(-0x1p-149));
TEST_REGULAR(T(-0x1p127), T(-0x3p-149), T(-0x1p-149));
TEST_REGULAR(T(-0x1p127), T(0x3p-148), T(-0x1p-147));
TEST_REGULAR(T(-0x1p127), T(-0x3p-148), T(-0x1p-147));
TEST_REGULAR(T(-0x1p127), T(0x3p-126), T(-0x1p-125));
TEST_REGULAR(T(-0x1p127), T(-0x3p-126), T(-0x1p-125));

if constexpr (sizeof(T) < sizeof(double))
return;
TEST_REGULAR(0x1p1023L, 0x3p-1074L, 0x1p-1073L);
TEST_REGULAR(0x1p1023L, -0x3p-1074L, 0x1p-1073L);
TEST_REGULAR(0x1p1023L, 0x3p-1073L, 0x1p-1073L);
TEST_REGULAR(0x1p1023L, -0x3p-1073L, 0x1p-1073L);
TEST_REGULAR(0x1p1023L, 0x3p-1022L, 0x1p-1021L);
TEST_REGULAR(0x1p1023L, -0x3p-1022L, 0x1p-1021L);
TEST_REGULAR(-0x1p1023L, 0x3p-1074L, -0x1p-1073L);
TEST_REGULAR(-0x1p1023L, -0x3p-1074L, -0x1p-1073L);
TEST_REGULAR(-0x1p1023L, 0x3p-1073L, -0x1p-1073L);
TEST_REGULAR(-0x1p1023L, -0x3p-1073L, -0x1p-1073L);
TEST_REGULAR(-0x1p1023L, 0x3p-1022L, -0x1p-1021L);
TEST_REGULAR(-0x1p1023L, -0x3p-1022L, -0x1p-1021L);
TEST_REGULAR(T(0x1p1023), T(0x3p-1074), T(0x1p-1073));
TEST_REGULAR(T(0x1p1023), T(-0x3p-1074), T(0x1p-1073));
TEST_REGULAR(T(0x1p1023), T(0x3p-1073), T(0x1p-1073));
TEST_REGULAR(T(0x1p1023), T(-0x3p-1073), T(0x1p-1073));
TEST_REGULAR(T(0x1p1023), T(0x3p-1022), T(0x1p-1021));
TEST_REGULAR(T(0x1p1023), T(-0x3p-1022), T(0x1p-1021));
TEST_REGULAR(T(-0x1p1023), T(0x3p-1074), T(-0x1p-1073));
TEST_REGULAR(T(-0x1p1023), T(-0x3p-1074), T(-0x1p-1073));
TEST_REGULAR(T(-0x1p1023), T(0x3p-1073), T(-0x1p-1073));
TEST_REGULAR(T(-0x1p1023), T(-0x3p-1073), T(-0x1p-1073));
TEST_REGULAR(T(-0x1p1023), T(0x3p-1022), T(-0x1p-1021));
TEST_REGULAR(T(-0x1p1023), T(-0x3p-1022), T(-0x1p-1021));
}
};

Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/math/smoke/FrexpTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,10 +24,10 @@ class FrexpTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
EXPECT_FP_EQ_ALL_ROUNDING(inf, func(inf, &exponent));
EXPECT_FP_EQ_ALL_ROUNDING(neg_inf, func(neg_inf, &exponent));

EXPECT_FP_EQ_ALL_ROUNDING(0.0, func(0.0, &exponent));
EXPECT_FP_EQ_ALL_ROUNDING(zero, func(zero, &exponent));
EXPECT_EQ(exponent, 0);

EXPECT_FP_EQ_ALL_ROUNDING(-0.0, func(-0.0, &exponent));
EXPECT_FP_EQ_ALL_ROUNDING(-zero, func(-zero, &exponent));
EXPECT_EQ(exponent, 0);
}

Expand Down
16 changes: 8 additions & 8 deletions libc/test/src/math/smoke/ILogbTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -47,13 +47,13 @@ class LlvmLibcILogbTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
EXPECT_EQ(OutType(2), func(InType(-4.0)));

EXPECT_EQ(OutType(3), func(InType(8.0)));
EXPECT_EQ(OutType(3), func(-8.0));
EXPECT_EQ(OutType(3), func(InType(-8.0)));

EXPECT_EQ(OutType(4), func(16.0));
EXPECT_EQ(OutType(4), func(-16.0));
EXPECT_EQ(OutType(4), func(InType(16.0)));
EXPECT_EQ(OutType(4), func(InType(-16.0)));

EXPECT_EQ(OutType(5), func(32.0));
EXPECT_EQ(OutType(5), func(-32.0));
EXPECT_EQ(OutType(5), func(InType(32.0)));
EXPECT_EQ(OutType(5), func(InType(-32.0)));
}

void test_some_integers(Func func) {
Expand All @@ -67,10 +67,10 @@ class LlvmLibcILogbTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
EXPECT_EQ(OutType(3), func(InType(-10.0)));

EXPECT_EQ(OutType(4), func(InType(31.0)));
EXPECT_EQ(OutType(4), func(-31.0));
EXPECT_EQ(OutType(4), func(InType(-31.0)));

EXPECT_EQ(OutType(5), func(55.0));
EXPECT_EQ(OutType(5), func(-55.0));
EXPECT_EQ(OutType(5), func(InType(55.0)));
EXPECT_EQ(OutType(5), func(InType(-55.0)));
}

void test_subnormal_range(Func func) {
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/math/smoke/LogbTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,8 +27,8 @@ class LogbTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
ASSERT_FP_EQ(aNaN, func(aNaN));
ASSERT_FP_EQ(inf, func(inf));
ASSERT_FP_EQ(inf, func(neg_inf));
ASSERT_FP_EQ(neg_inf, func(0.0));
ASSERT_FP_EQ(neg_inf, func(-0.0));
ASSERT_FP_EQ(neg_inf, func(zero));
ASSERT_FP_EQ(neg_inf, func(neg_zero));
}

void testPowersOfTwo(LogbFunc func) {
Expand Down
7 changes: 3 additions & 4 deletions libc/test/src/stdio/sprintf_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -630,7 +630,7 @@ TEST(LlvmLibcSPrintfTest, PointerConv) {
ASSERT_STREQ(buff, "0x1a2b3c4d5e6f7081");
}

written = LIBC_NAMESPACE::sprintf(buff, "%p", buff);
written = LIBC_NAMESPACE::sprintf(buff, "%p", &written);
EXPECT_GT(written, 0);

// Width tests:
Expand Down Expand Up @@ -1687,9 +1687,6 @@ TEST_F(LlvmLibcSPrintfTest, FloatDecimalConv) {
TEST_F(LlvmLibcSPrintfTest, FloatDecimalLongDoubleConv) {
ForceRoundingMode r(RoundingMode::Nearest);

char big_buff[10000]; // Used for long doubles and other extremely wide
// numbers.

// Length Modifier Tests.

// TODO(michaelrj): Add tests for LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64 and 128
Expand Down Expand Up @@ -1741,6 +1738,8 @@ TEST_F(LlvmLibcSPrintfTest, FloatDecimalLongDoubleConv) {
"000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000");

char big_buff[10000]; // Used for extremely wide numbers.

written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e1000L);
ASSERT_STREQ_LEN(
written, big_buff,
Expand Down
22 changes: 22 additions & 0 deletions libc/test/src/string/memory_utils/op_tests.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -192,6 +192,13 @@ TYPED_TEST(LlvmLibcOpTest, Memset, MemsetImplementations) {
}
}

#ifdef LIBC_TARGET_ARCH_IS_X86_64
// Prevent GCC warning due to ignored __aligned__ attributes when passing x86
// SIMD types as template arguments.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wignored-attributes"
#endif // LIBC_TARGET_ARCH_IS_X86_64

using BcmpImplementations = testing::TypeList<
#ifdef LIBC_TARGET_ARCH_IS_X86_64
#ifdef __SSE4_1__
Expand Down Expand Up @@ -224,6 +231,10 @@ using BcmpImplementations = testing::TypeList<
generic::BcmpSequence<uint8_t, uint8_t, uint8_t>, //
generic::Bcmp<uint8_t>>;

#ifdef LIBC_TARGET_ARCH_IS_X86_64
#pragma GCC diagnostic pop
#endif // LIBC_TARGET_ARCH_IS_X86_64

// Adapt CheckBcmp signature to op implementation signatures.
template <auto FnImpl>
int CmpAdaptor(cpp::span<char> p1, cpp::span<char> p2, size_t size) {
Expand Down Expand Up @@ -275,6 +286,13 @@ TYPED_TEST(LlvmLibcOpTest, Bcmp, BcmpImplementations) {
}
}

#ifdef LIBC_TARGET_ARCH_IS_X86_64
// Prevent GCC warning due to ignored __aligned__ attributes when passing x86
// SIMD types as template arguments.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wignored-attributes"
#endif // LIBC_TARGET_ARCH_IS_X86_64

using MemcmpImplementations = testing::TypeList<
#ifdef LIBC_TARGET_ARCH_IS_X86_64
#ifdef __SSE2__
Expand Down Expand Up @@ -304,6 +322,10 @@ using MemcmpImplementations = testing::TypeList<
generic::MemcmpSequence<uint8_t, uint8_t, uint8_t>,
generic::Memcmp<uint8_t>>;

#ifdef LIBC_TARGET_ARCH_IS_X86_64
#pragma GCC diagnostic pop
#endif // LIBC_TARGET_ARCH_IS_X86_64

TYPED_TEST(LlvmLibcOpTest, Memcmp, MemcmpImplementations) {
using Impl = ParamType;
constexpr size_t kSize = Impl::SIZE;
Expand Down