76 changes: 40 additions & 36 deletions libc/test/src/__support/FPUtil/fpbits_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,8 +26,8 @@ TEST(LlvmLibcFPBitsTest, FPType_IEEE754_Binary16) {
EXPECT_EQ(u16(0b0'00001'0000000000), u16(Rep::min_normal()));
EXPECT_EQ(u16(0b0'11110'1111111111), u16(Rep::max_normal()));
EXPECT_EQ(u16(0b0'11111'0000000000), u16(Rep::inf()));
EXPECT_EQ(u16(0b0'11111'0100000000), u16(Rep::build_nan()));
EXPECT_EQ(u16(0b0'11111'1000000000), u16(Rep::build_quiet_nan()));
EXPECT_EQ(u16(0b0'11111'0100000000), u16(Rep::signaling_nan()));
EXPECT_EQ(u16(0b0'11111'1000000000), u16(Rep::quiet_nan()));
}

TEST(LlvmLibcFPBitsTest, FPType_IEEE754_Binary32) {
Expand All @@ -43,9 +43,9 @@ TEST(LlvmLibcFPBitsTest, FPType_IEEE754_Binary32) {
EXPECT_EQ(u32(0b0'00000001'00000000000000000000000), u32(Rep::min_normal()));
EXPECT_EQ(u32(0b0'11111110'11111111111111111111111), u32(Rep::max_normal()));
EXPECT_EQ(u32(0b0'11111111'00000000000000000000000), u32(Rep::inf()));
EXPECT_EQ(u32(0b0'11111111'01000000000000000000000), u32(Rep::build_nan()));
EXPECT_EQ(u32(0b0'11111111'10000000000000000000000),
u32(Rep::build_quiet_nan()));
EXPECT_EQ(u32(0b0'11111111'01000000000000000000000),
u32(Rep::signaling_nan()));
EXPECT_EQ(u32(0b0'11111111'10000000000000000000000), u32(Rep::quiet_nan()));
}

TEST(LlvmLibcFPBitsTest, FPType_IEEE754_Binary64) {
Expand Down Expand Up @@ -75,10 +75,10 @@ TEST(LlvmLibcFPBitsTest, FPType_IEEE754_Binary64) {
u64(Rep::inf()));
EXPECT_EQ(
u64(0b0'11111111111'0100000000000000000000000000000000000000000000000000),
u64(Rep::build_nan()));
u64(Rep::signaling_nan()));
EXPECT_EQ(
u64(0b0'11111111111'1000000000000000000000000000000000000000000000000000),
u64(Rep::build_quiet_nan()));
u64(Rep::quiet_nan()));
}

static constexpr UInt128 u128(uint64_t hi, uint64_t lo) {
Expand Down Expand Up @@ -123,11 +123,11 @@ TEST(LlvmLibcFPBitsTest, FPType_IEEE754_Binary128) {
EXPECT_EQ(
u128(0b0'111111111111111'010000000000000000000000000000000000000000000000,
0b0000000000000000000000000000000000000000000000000000000000000000),
UInt128(Rep::build_nan()));
UInt128(Rep::signaling_nan()));
EXPECT_EQ(
u128(0b0'111111111111111'100000000000000000000000000000000000000000000000,
0b0000000000000000000000000000000000000000000000000000000000000000),
UInt128(Rep::build_quiet_nan()));
UInt128(Rep::quiet_nan()));
}

TEST(LlvmLibcFPBitsTest, FPType_X86_Binary80) {
Expand Down Expand Up @@ -164,11 +164,11 @@ TEST(LlvmLibcFPBitsTest, FPType_X86_Binary80) {
EXPECT_EQ(
u128(0b0'111111111111111,
0b1010000000000000000000000000000000000000000000000000000000000000),
UInt128(Rep::build_nan()));
UInt128(Rep::signaling_nan()));
EXPECT_EQ(
u128(0b0'111111111111111,
0b1100000000000000000000000000000000000000000000000000000000000000),
UInt128(Rep::build_quiet_nan()));
UInt128(Rep::quiet_nan()));
}

TEST(LlvmLibcFPBitsTest, FPType_X86_Binary80_IsNan) {
Expand Down Expand Up @@ -227,8 +227,8 @@ enum class FP {
ONE,
MAX_NORMAL,
INF,
BUILD_NAN,
BUILD_QUIET_NAN
SIGNALING_NAN,
QUIET_NAN
};

using FPTypes = LIBC_NAMESPACE::testing::TypeList<
Expand All @@ -254,10 +254,10 @@ TYPED_TEST(LlvmLibcFPBitsTest, Properties, FPTypes) {
return T::max_normal(sign);
case FP::INF:
return T::inf(sign);
case FP::BUILD_NAN:
return T::build_nan(sign);
case FP::BUILD_QUIET_NAN:
return T::build_quiet_nan(sign);
case FP::SIGNALING_NAN:
return T::signaling_nan(sign);
case FP::QUIET_NAN:
return T::quiet_nan(sign);
}
};
static constexpr auto make = [](Sign sign, FP fp) -> T {
Expand All @@ -266,31 +266,32 @@ TYPED_TEST(LlvmLibcFPBitsTest, Properties, FPTypes) {
constexpr FP fp_values[] = {
FP::ZERO, FP::MIN_SUBNORMAL, FP::MAX_SUBNORMAL,
FP::MIN_NORMAL, FP::ONE, FP::MAX_NORMAL,
FP::INF, FP::BUILD_NAN, FP::BUILD_QUIET_NAN};
FP::INF, FP::SIGNALING_NAN, FP::QUIET_NAN,
};
constexpr Sign signs[] = {Sign::POS, Sign::NEG};
for (Sign sign : signs) {
for (FP fp : fp_values) {
const T value = make(sign, fp);
// is_zero
ASSERT_EQ(value.is_zero(), fp == FP::ZERO);
// is_inf_or_nan
ASSERT_EQ(value.is_inf_or_nan(), fp == FP::INF || fp == FP::BUILD_NAN ||
fp == FP::BUILD_QUIET_NAN);
ASSERT_EQ(value.is_inf_or_nan(), fp == FP::INF ||
fp == FP::SIGNALING_NAN ||
fp == FP::QUIET_NAN);
// is_finite
ASSERT_EQ(value.is_finite(), fp != FP::INF && fp != FP::BUILD_NAN &&
fp != FP::BUILD_QUIET_NAN);
ASSERT_EQ(value.is_finite(), fp != FP::INF && fp != FP::SIGNALING_NAN &&
fp != FP::QUIET_NAN);
// is_inf
ASSERT_EQ(value.is_inf(), fp == FP::INF);
// is_nan
ASSERT_EQ(value.is_nan(),
fp == FP::BUILD_NAN || fp == FP::BUILD_QUIET_NAN);
ASSERT_EQ(value.is_nan(), fp == FP::SIGNALING_NAN || fp == FP::QUIET_NAN);
// is_normal
ASSERT_EQ(value.is_normal(),
fp == FP::MIN_NORMAL || fp == FP::ONE || fp == FP::MAX_NORMAL);
// is_quiet_nan
ASSERT_EQ(value.is_quiet_nan(), fp == FP::BUILD_QUIET_NAN);
ASSERT_EQ(value.is_quiet_nan(), fp == FP::QUIET_NAN);
// is_signaling_nan
ASSERT_EQ(value.is_signaling_nan(), fp == FP::BUILD_NAN);
ASSERT_EQ(value.is_signaling_nan(), fp == FP::SIGNALING_NAN);
// is_subnormal
ASSERT_EQ(value.is_subnormal(), fp == FP::ZERO ||
fp == FP::MIN_SUBNORMAL ||
Expand All @@ -312,7 +313,8 @@ TEST(LlvmLibcFPBitsTest, FloatType) {
"(+Infinity)");
EXPECT_STREQ(LIBC_NAMESPACE::str(FloatBits::inf(Sign::NEG)).c_str(),
"(-Infinity)");
EXPECT_STREQ(LIBC_NAMESPACE::str(FloatBits::build_nan()).c_str(), "(NaN)");
EXPECT_STREQ(LIBC_NAMESPACE::str(FloatBits::signaling_nan()).c_str(),
"(NaN)");

FloatBits zero(0.0f);
EXPECT_TRUE(zero.is_pos());
Expand Down Expand Up @@ -362,7 +364,7 @@ TEST(LlvmLibcFPBitsTest, FloatType) {
EXPECT_STREQ(LIBC_NAMESPACE::str(negnum).c_str(),
"0xBF900000 = (S: 1, E: 0x007F, M: 0x00100000)");

FloatBits quiet_nan = FloatBits::build_quiet_nan();
FloatBits quiet_nan = FloatBits::quiet_nan();
EXPECT_EQ(quiet_nan.is_quiet_nan(), true);
}

Expand All @@ -373,7 +375,8 @@ TEST(LlvmLibcFPBitsTest, DoubleType) {
"(+Infinity)");
EXPECT_STREQ(LIBC_NAMESPACE::str(DoubleBits::inf(Sign::NEG)).c_str(),
"(-Infinity)");
EXPECT_STREQ(LIBC_NAMESPACE::str(DoubleBits::build_nan()).c_str(), "(NaN)");
EXPECT_STREQ(LIBC_NAMESPACE::str(DoubleBits::signaling_nan()).c_str(),
"(NaN)");

DoubleBits zero(0.0);
EXPECT_TRUE(zero.is_pos());
Expand Down Expand Up @@ -423,7 +426,7 @@ TEST(LlvmLibcFPBitsTest, DoubleType) {
EXPECT_STREQ(LIBC_NAMESPACE::str(negnum).c_str(),
"0xBFF2000000000000 = (S: 1, E: 0x03FF, M: 0x0002000000000000)");

DoubleBits quiet_nan = DoubleBits::build_quiet_nan();
DoubleBits quiet_nan = DoubleBits::quiet_nan();
EXPECT_EQ(quiet_nan.is_quiet_nan(), true);
}

Expand All @@ -438,7 +441,7 @@ TEST(LlvmLibcFPBitsTest, X86LongDoubleType) {
"(+Infinity)");
EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::inf(Sign::NEG)).c_str(),
"(-Infinity)");
EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::build_nan()).c_str(),
EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::signaling_nan()).c_str(),
"(NaN)");

LongDoubleBits zero(0.0l);
Expand Down Expand Up @@ -504,7 +507,7 @@ TEST(LlvmLibcFPBitsTest, X86LongDoubleType) {
"0x000000000000BFFF9000000000000000 = "
"(S: 1, E: 0x3FFF, I: 1, M: 0x00000000000000001000000000000000)");

LongDoubleBits quiet_nan = LongDoubleBits::build_quiet_nan();
LongDoubleBits quiet_nan = LongDoubleBits::quiet_nan();
EXPECT_EQ(quiet_nan.is_quiet_nan(), true);
}
#else
Expand All @@ -518,7 +521,7 @@ TEST(LlvmLibcFPBitsTest, LongDoubleType) {
"(+Infinity)");
EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::inf(Sign::NEG)).c_str(),
"(-Infinity)");
EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::build_nan()).c_str(),
EXPECT_STREQ(LIBC_NAMESPACE::str(LongDoubleBits::signaling_nan()).c_str(),
"(NaN)");

LongDoubleBits zero(0.0l);
Expand Down Expand Up @@ -578,7 +581,7 @@ TEST(LlvmLibcFPBitsTest, LongDoubleType) {
"0xBFFF2000000000000000000000000000 = "
"(S: 1, E: 0x3FFF, M: 0x00002000000000000000000000000000)");

LongDoubleBits quiet_nan = LongDoubleBits::build_quiet_nan();
LongDoubleBits quiet_nan = LongDoubleBits::quiet_nan();
EXPECT_EQ(quiet_nan.is_quiet_nan(), true);
#endif
}
Expand All @@ -592,7 +595,8 @@ TEST(LlvmLibcFPBitsTest, Float128Type) {
"(+Infinity)");
EXPECT_STREQ(LIBC_NAMESPACE::str(Float128Bits::inf(Sign::NEG)).c_str(),
"(-Infinity)");
EXPECT_STREQ(LIBC_NAMESPACE::str(Float128Bits::build_nan()).c_str(), "(NaN)");
EXPECT_STREQ(LIBC_NAMESPACE::str(Float128Bits::signaling_nan()).c_str(),
"(NaN)");

Float128Bits zero = Float128Bits::zero(Sign::POS);
EXPECT_TRUE(zero.is_pos());
Expand Down Expand Up @@ -651,7 +655,7 @@ TEST(LlvmLibcFPBitsTest, Float128Type) {
"0xBFFF2000000000000000000000000000 = "
"(S: 1, E: 0x3FFF, M: 0x00002000000000000000000000000000)");

Float128Bits quiet_nan = Float128Bits::build_quiet_nan();
Float128Bits quiet_nan = Float128Bits::quiet_nan();
EXPECT_EQ(quiet_nan.is_quiet_nan(), true);
}
#endif // LIBC_COMPILER_HAS_FLOAT128
2 changes: 1 addition & 1 deletion libc/test/src/math/FDimTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,7 +24,7 @@ class FDimTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

void test_na_n_arg(FuncPtr func) {
EXPECT_FP_EQ(nan, func(nan, inf));
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/FmaTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,7 +32,7 @@ class FmaTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

static constexpr StorageType MAX_NORMAL = FPBits::max_normal().uintval();
static constexpr StorageType MIN_NORMAL = FPBits::min_normal().uintval();
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/HypotTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,7 @@ class HypotTestTemplate : public LIBC_NAMESPACE::testing::Test {
using FPBits = LIBC_NAMESPACE::fputil::FPBits<T>;
using Sign = LIBC_NAMESPACE::fputil::Sign;
using StorageType = typename FPBits::StorageType;
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();
const T inf = FPBits::inf().get_val();
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero().get_val();
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/ILogbTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ class LlvmLibcILogbTest : public LIBC_NAMESPACE::testing::Test {
using Sign = LIBC_NAMESPACE::fputil::Sign;
EXPECT_EQ(FP_ILOGB0, func(FPBits::zero(Sign::POS).get_val()));
EXPECT_EQ(FP_ILOGB0, func(FPBits::zero(Sign::NEG).get_val()));
EXPECT_EQ(FP_ILOGBNAN, func(FPBits::build_quiet_nan().get_val()));
EXPECT_EQ(FP_ILOGBNAN, func(FPBits::quiet_nan().get_val()));
EXPECT_EQ(INT_MAX, func(FPBits::inf(Sign::POS).get_val()));
EXPECT_EQ(INT_MAX, func(FPBits::inf(Sign::NEG).get_val()));
}
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/LdExpTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,7 +29,7 @@ class LdExpTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

// A normalized mantissa to be used with tests.
static constexpr StorageType MANTISSA = NormalFloat::ONE + 0x1234;
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/NextAfterTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ class NextAfterTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

const StorageType min_subnormal = FPBits::min_subnormal().uintval();
const StorageType max_subnormal = FPBits::max_subnormal().uintval();
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/RIntTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -38,7 +38,7 @@ class RIntTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

static constexpr StorageType MIN_SUBNORMAL =
FPBits::min_subnormal().uintval();
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/RemQuoTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,7 @@ class RemQuoTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

static constexpr StorageType MIN_SUBNORMAL =
FPBits::min_subnormal().uintval();
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/RoundToIntegerTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -37,7 +37,7 @@ class RoundToIntegerTestTemplate : public LIBC_NAMESPACE::testing::Test {
const F neg_zero = FPBits::zero(Sign::NEG).get_val();
const F inf = FPBits::inf().get_val();
const F neg_inf = FPBits::inf(Sign::NEG).get_val();
const F nan = FPBits::build_quiet_nan().get_val();
const F nan = FPBits::quiet_nan().get_val();

static constexpr StorageType MAX_NORMAL = FPBits::max_normal().uintval();
static constexpr StorageType MIN_NORMAL = FPBits::min_normal().uintval();
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/smoke/FDimTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,7 +24,7 @@ class FDimTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

void test_na_n_arg(FuncPtr func) {
EXPECT_FP_EQ(nan, func(nan, inf));
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/smoke/FmaTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,7 @@ class FmaTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

public:
void test_special_numbers(Func func) {
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/smoke/HypotTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,7 +22,7 @@ class HypotTestTemplate : public LIBC_NAMESPACE::testing::Test {
using FPBits = LIBC_NAMESPACE::fputil::FPBits<T>;
using StorageType = typename FPBits::StorageType;
using Sign = LIBC_NAMESPACE::fputil::Sign;
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();
const T inf = FPBits::inf(Sign::POS).get_val();
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/smoke/ILogbTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ class LlvmLibcILogbTest : public LIBC_NAMESPACE::testing::Test {
using Sign = LIBC_NAMESPACE::fputil::Sign;
EXPECT_EQ(FP_ILOGB0, func(FPBits::zero(Sign::POS).get_val()));
EXPECT_EQ(FP_ILOGB0, func(FPBits::zero(Sign::NEG).get_val()));
EXPECT_EQ(FP_ILOGBNAN, func(FPBits::build_quiet_nan().get_val()));
EXPECT_EQ(FP_ILOGBNAN, func(FPBits::quiet_nan().get_val()));
EXPECT_EQ(INT_MAX, func(FPBits::inf(Sign::POS).get_val()));
EXPECT_EQ(INT_MAX, func(FPBits::inf(Sign::NEG).get_val()));
}
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/smoke/LdExpTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,7 +29,7 @@ class LdExpTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

// A normalized mantissa to be used with tests.
static constexpr StorageType MANTISSA = NormalFloat::ONE + 0x1234;
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/smoke/NextAfterTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -38,7 +38,7 @@ class NextAfterTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

static constexpr StorageType min_subnormal =
FPBits::min_subnormal().uintval();
Expand Down
4 changes: 2 additions & 2 deletions libc/test/src/math/smoke/NextTowardTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -40,11 +40,11 @@ class NextTowardTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

const long double to_zero = ToFPBits::zero().get_val();
const long double to_neg_zero = ToFPBits::zero(Sign::NEG).get_val();
const long double to_nan = ToFPBits::build_quiet_nan().get_val();
const long double to_nan = ToFPBits::quiet_nan().get_val();

static constexpr StorageType min_subnormal =
FPBits::min_subnormal().uintval();
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/smoke/RIntTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,7 +35,7 @@ class RIntTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

public:
void testSpecialNumbers(RIntFunc func) {
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/smoke/RemQuoTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,7 @@ class RemQuoTestTemplate : public LIBC_NAMESPACE::testing::Test {
const T neg_inf = FPBits::inf(Sign::NEG).get_val();
const T zero = FPBits::zero(Sign::POS).get_val();
const T neg_zero = FPBits::zero(Sign::NEG).get_val();
const T nan = FPBits::build_quiet_nan().get_val();
const T nan = FPBits::quiet_nan().get_val();

public:
typedef T (*RemQuoFunc)(T, T, int *);
Expand Down
2 changes: 1 addition & 1 deletion libc/test/src/math/smoke/RoundToIntegerTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -34,7 +34,7 @@ class RoundToIntegerTestTemplate : public LIBC_NAMESPACE::testing::Test {
const F neg_zero = FPBits::zero(Sign::NEG).get_val();
const F inf = FPBits::inf(Sign::POS).get_val();
const F neg_inf = FPBits::inf(Sign::NEG).get_val();
const F nan = FPBits::build_quiet_nan().get_val();
const F nan = FPBits::quiet_nan().get_val();

static constexpr StorageType MAX_SUBNORMAL =
FPBits::max_subnormal().uintval();
Expand Down
14 changes: 5 additions & 9 deletions libc/test/src/stdio/sprintf_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -586,8 +586,7 @@ TEST(LlvmLibcSPrintfTest, OctConv) {
TEST_F(LlvmLibcSPrintfTest, FloatHexExpConv) {
ForceRoundingMode r(RoundingMode::Nearest);
double inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
double nan =
LIBC_NAMESPACE::fputil::FPBits<double>::build_quiet_nan().get_val();
double nan = LIBC_NAMESPACE::fputil::FPBits<double>::quiet_nan().get_val();
written = LIBC_NAMESPACE::sprintf(buff, "%a", 1.0);
ASSERT_STREQ_LEN(written, buff, "0x1p+0");

Expand Down Expand Up @@ -951,12 +950,11 @@ TEST_F(LlvmLibcSPrintfTest, FloatHexExpConv) {
TEST_F(LlvmLibcSPrintfTest, FloatDecimalConv) {
ForceRoundingMode r(RoundingMode::Nearest);
double inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
double nan =
LIBC_NAMESPACE::fputil::FPBits<double>::build_quiet_nan().get_val();
double nan = LIBC_NAMESPACE::fputil::FPBits<double>::quiet_nan().get_val();
long double ld_inf =
LIBC_NAMESPACE::fputil::FPBits<long double>::inf().get_val();
long double ld_nan =
LIBC_NAMESPACE::fputil::FPBits<long double>::build_quiet_nan().get_val();
LIBC_NAMESPACE::fputil::FPBits<long double>::quiet_nan().get_val();

char big_buff[10000]; // Used for long doubles and other extremely wide
// numbers.
Expand Down Expand Up @@ -1805,8 +1803,7 @@ TEST_F(LlvmLibcSPrintfTest, FloatDecimalLongDoubleConv) {
TEST_F(LlvmLibcSPrintfTest, FloatExponentConv) {
ForceRoundingMode r(RoundingMode::Nearest);
double inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
double nan =
LIBC_NAMESPACE::fputil::FPBits<double>::build_quiet_nan().get_val();
double nan = LIBC_NAMESPACE::fputil::FPBits<double>::quiet_nan().get_val();

written = LIBC_NAMESPACE::sprintf(buff, "%e", 1.0);
ASSERT_STREQ_LEN(written, buff, "1.000000e+00");
Expand Down Expand Up @@ -2413,8 +2410,7 @@ TEST_F(LlvmLibcSPrintfTest, FloatExponentLongDoubleConv) {
TEST_F(LlvmLibcSPrintfTest, FloatAutoConv) {
ForceRoundingMode r(RoundingMode::Nearest);
double inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
double nan =
LIBC_NAMESPACE::fputil::FPBits<double>::build_quiet_nan().get_val();
double nan = LIBC_NAMESPACE::fputil::FPBits<double>::quiet_nan().get_val();

written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.0);
ASSERT_STREQ_LEN(written, buff, "1");
Expand Down
8 changes: 3 additions & 5 deletions libc/test/src/stdio/sscanf_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -231,8 +231,7 @@ TEST(LlvmLibcSScanfTest, FloatConvSimple) {
float result = 0;

float inf = LIBC_NAMESPACE::fputil::FPBits<float>::inf().get_val();
float nan =
LIBC_NAMESPACE::fputil::FPBits<float>::build_quiet_nan().get_val();
float nan = LIBC_NAMESPACE::fputil::FPBits<float>::quiet_nan().get_val();

ret_val = LIBC_NAMESPACE::sscanf("123", "%f", &result);
EXPECT_EQ(ret_val, 1);
Expand Down Expand Up @@ -297,7 +296,7 @@ TEST(LlvmLibcSScanfTest, FloatConvLengthModifier) {

double d_inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
long double ld_nan =
LIBC_NAMESPACE::fputil::FPBits<long double>::build_quiet_nan().get_val();
LIBC_NAMESPACE::fputil::FPBits<long double>::quiet_nan().get_val();

ret_val = LIBC_NAMESPACE::sscanf("123", "%lf", &d_result);
EXPECT_EQ(ret_val, 1);
Expand Down Expand Up @@ -393,8 +392,7 @@ TEST(LlvmLibcSScanfTest, FloatConvComplexParsing) {
float result = 0;

float inf = LIBC_NAMESPACE::fputil::FPBits<float>::inf().get_val();
float nan =
LIBC_NAMESPACE::fputil::FPBits<float>::build_quiet_nan().get_val();
float nan = LIBC_NAMESPACE::fputil::FPBits<float>::quiet_nan().get_val();

ret_val = LIBC_NAMESPACE::sscanf("0x1.0e3", "%f", &result);
EXPECT_EQ(ret_val, 1);
Expand Down