ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-08-19 05:10:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: Move float constants under FloatTest

Browse Source
This commit is contained in:
TimothyBanks
2026-08-18 11:28:18 -04:00
parent 6c32ca3538
commit c6c68090f2
15 changed files with 127 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/tests/libxrpl/tx/wasm/FloatFixture.h
View File

@@ -11,40 +11,34 @@
namespace xrpl::test {
// Known float bit patterns (12-byte `wasm_float` regions) — inputs / expected values for
// the float host functions. `kNormalExp` is the exponent offset the encoding uses.
namespace floats {
inline constexpr int kNormalExp = 18;
// clang-format off
inline Bytes const kIntMin = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}; // -2^63 (rounds to -(2^63-1))
inline Bytes const kIntZero = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00}; // 0
inline Bytes const kIntMax = {0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00}; // 2^63-1
inline Bytes const kUintMax = {0x19, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9A, 0x00, 0x00, 0x00, 0x01}; // 2^64-1
inline Bytes const kMaxExp = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00}; // 1e(kMaxExponent + kNormalExp)
inline Bytes const kPreMaxExp = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF}; // 1e(kMaxExponent + kNormalExp - 1)
inline Bytes const kMinusMaxExp = {0xF2, 0x1F, 0x49, 0x4C, 0x58, 0x9C, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00}; // -1e(kMaxExponent + kNormalExp)
inline Bytes const kMinExp = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00}; // 1e(kMinExponent - kNormalExp)
inline Bytes const kMax = {0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x80, 0x00}; // kMaxRep e(kMaxExponent - kNormalExp)
inline Bytes const kMaxIOU = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x63, 0xFF, 0x9C, 0x00, 0x00, 0x00, 0x4E}; // 9999999999999999e(96)
inline Bytes const kMinIOU = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x9D}; // 1e(-81)
inline Bytes const kOne = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE}; // 1
inline Bytes const kMinusOne = {0xF2, 0x1F, 0x49, 0x4C, 0x58, 0x9C, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE}; // -1
inline Bytes const kOneMore = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x03, 0xE8, 0xFF, 0xFF, 0xFF, 0xEE}; // 1.000000000000001
inline Bytes const kTwo = {0x1B, 0xC1, 0x6D, 0x67, 0x4E, 0xC8, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE}; // 2
inline Bytes const kTen = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEF}; // 10
inline Bytes const kPi = {0x2B, 0x99, 0x2D, 0xDF, 0xA2, 0x32, 0x48, 0xE8, 0xFF, 0xFF, 0xFF, 0xEE}; // 3.141592653589793
inline Bytes const kInvalidZero = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00}; // non-canonical zero
inline Bytes const kMinusThree = {0xD6, 0x5D, 0xDB, 0xE5, 0x09, 0xD4, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE}; // -3
// clang-format on
inline std::string const kInvalidData = "invalid_data";
} // namespace floats
struct FloatTest : WasmImplTest
{
static constexpr std::int64_t kMin64 = std::numeric_limits<std::int64_t>::min();
static constexpr std::int64_t kMax64 = std::numeric_limits<std::int64_t>::max();
static constexpr std::int32_t kNormalExp = 18;
static inline std::string const kInvalidData = "invalid_data";
// clang-format off
static inline Bytes const kIntMin = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}; // -2^63 (rounds to -(2^63-1))
static inline Bytes const kIntZero = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00}; // 0
static inline Bytes const kIntMax = {0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00}; // 2^63-1
static inline Bytes const kUintMax = {0x19, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9A, 0x00, 0x00, 0x00, 0x01}; // 2^64-1
static inline Bytes const kMaxExp = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00}; // 1e(kMaxExponent + kNormalExp)
static inline Bytes const kPreMaxExp = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF}; // 1e(kMaxExponent + kNormalExp - 1)
static inline Bytes const kMinusMaxExp = {0xF2, 0x1F, 0x49, 0x4C, 0x58, 0x9C, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00}; // -1e(kMaxExponent + kNormalExp)
static inline Bytes const kMinExp = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00}; // 1e(kMinExponent - kNormalExp)
static inline Bytes const kMax = {0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x80, 0x00}; // kMaxRep e(kMaxExponent - kNormalExp)
static inline Bytes const kMaxIOU = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x63, 0xFF, 0x9C, 0x00, 0x00, 0x00, 0x4E}; // 9999999999999999e(96)
static inline Bytes const kMinIOU = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x9D}; // 1e(-81)
static inline Bytes const kOne = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE}; // 1
static inline Bytes const kMinusOne = {0xF2, 0x1F, 0x49, 0x4C, 0x58, 0x9C, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE}; // -1
static inline Bytes const kOneMore = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x03, 0xE8, 0xFF, 0xFF, 0xFF, 0xEE}; // 1.000000000000001
static inline Bytes const kTwo = {0x1B, 0xC1, 0x6D, 0x67, 0x4E, 0xC8, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE}; // 2
static inline Bytes const kTen = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEF}; // 10
static inline Bytes const kPi = {0x2B, 0x99, 0x2D, 0xDF, 0xA2, 0x32, 0x48, 0xE8, 0xFF, 0xFF, 0xFF, 0xEE}; // 3.141592653589793
static inline Bytes const kInvalidZero = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00}; // non-canonical zero
static inline Bytes const kMinusThree = {0xD6, 0x5D, 0xDB, 0xE5, 0x09, 0xD4, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE}; // -3
// clang-format on
static Slice
slice(Bytes const& b)

13
src/tests/libxrpl/tx/wasm/host_functions/FloatAdd.cpp
View File

@@ -14,33 +14,36 @@ struct FloatAddImpl : FloatTest
TEST_F(FloatAddImpl, BadModeIsMalformed)
{
expectError(
makeHost()->floatAdd(slice(floats::kOne), slice(floats::kOne), -1),
makeHost()->floatAdd(slice(FloatTest::kOne), slice(FloatTest::kOne), -1),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatAddImpl, MalformedInput)
{
expectError(
makeHost()->floatAdd(slice(floats::kOne), Slice{}, 0),
makeHost()->floatAdd(slice(FloatTest::kOne), Slice{}, 0),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatAddImpl, MaxIouPlusMaxExpIsMaxExp)
{
expectValue(
makeHost()->floatAdd(slice(floats::kMaxIOU), slice(floats::kMaxExp), 0), floats::kMaxExp);
makeHost()->floatAdd(slice(FloatTest::kMaxIOU), slice(FloatTest::kMaxExp), 0),
FloatTest::kMaxExp);
}
TEST_F(FloatAddImpl, MinPlusZeroIsMin)
{
expectValue(
makeHost()->floatAdd(slice(floats::kIntMin), slice(floats::kIntZero), 0), floats::kIntMin);
makeHost()->floatAdd(slice(FloatTest::kIntMin), slice(FloatTest::kIntZero), 0),
FloatTest::kIntMin);
}
TEST_F(FloatAddImpl, MaxPlusMinIsZero)
{
expectValue(
makeHost()->floatAdd(slice(floats::kIntMax), slice(floats::kIntMin), 0), floats::kIntZero);
makeHost()->floatAdd(slice(FloatTest::kIntMax), slice(FloatTest::kIntMin), 0),
FloatTest::kIntZero);
}
} // namespace xrpl::test

10
src/tests/libxrpl/tx/wasm/host_functions/FloatCompare.cpp
View File

@@ -17,23 +17,23 @@ TEST_F(FloatCompareImpl, MalformedInputs)
// 12-byte buffer, so size is the only rejection.
expectError(makeHost()->floatCompare(Slice{}, Slice{}), HostFunctionError::FloatInputMalformed);
expectError(
makeHost()->floatCompare(slice(floats::kOne), Slice{}),
makeHost()->floatCompare(slice(FloatTest::kOne), Slice{}),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatCompareImpl, Less)
{
expectValue(makeHost()->floatCompare(slice(floats::kIntMin), slice(floats::kIntZero)), 2);
expectValue(makeHost()->floatCompare(slice(FloatTest::kIntMin), slice(FloatTest::kIntZero)), 2);
}
TEST_F(FloatCompareImpl, Greater)
{
expectValue(makeHost()->floatCompare(slice(floats::kIntMax), slice(floats::kIntZero)), 1);
expectValue(makeHost()->floatCompare(slice(FloatTest::kIntMax), slice(FloatTest::kIntZero)), 1);
}
TEST_F(FloatCompareImpl, Equal)
{
expectValue(makeHost()->floatCompare(slice(floats::kOne), slice(floats::kOne)), 0);
expectValue(makeHost()->floatCompare(slice(FloatTest::kOne), slice(FloatTest::kOne)), 0);
}
// A non-canonical encoding of 10 (mantissa 100000, exponent -4) is normalized on decode, so
@@ -42,7 +42,7 @@ TEST_F(FloatCompareImpl, NonCanonicalNormalizes)
{
Bytes const nonCanonicalTen{
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x86, 0xA0, 0xFF, 0xFF, 0xFF, 0xFC};
expectValue(makeHost()->floatCompare(slice(nonCanonicalTen), slice(floats::kTen)), 0);
expectValue(makeHost()->floatCompare(slice(nonCanonicalTen), slice(FloatTest::kTen)), 0);
}
} // namespace xrpl::test

21
src/tests/libxrpl/tx/wasm/host_functions/FloatDivide.cpp
View File

@@ -15,45 +15,46 @@ struct FloatDivideImpl : FloatTest
TEST_F(FloatDivideImpl, BadModeIsMalformed)
{
expectError(
makeHost()->floatDivide(slice(floats::kOne), slice(floats::kOne), -1),
makeHost()->floatDivide(slice(FloatTest::kOne), slice(FloatTest::kOne), -1),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatDivideImpl, MalformedInput)
{
expectError(
makeHost()->floatDivide(slice(floats::kOne), Slice{}, 0),
makeHost()->floatDivide(slice(FloatTest::kOne), Slice{}, 0),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatDivideImpl, DivideByZeroIsComputationError)
{
expectError(
makeHost()->floatDivide(slice(floats::kOne), slice(floats::kIntZero), 0),
makeHost()->floatDivide(slice(FloatTest::kOne), slice(FloatTest::kIntZero), 0),
HostFunctionError::FloatComputationError);
}
TEST_F(FloatDivideImpl, OverflowIsComputationError)
{
// A divisor just below 1, so max / it overflows.
auto const y = makeHost()->floatFromMantExp(STAmount::kMaxValue, -floats::kNormalExp - 1, 0);
auto const y = makeHost()->floatFromMantExp(STAmount::kMaxValue, -FloatTest::kNormalExp - 1, 0);
ASSERT_TRUE(y.has_value());
expectError(
makeHost()->floatDivide(slice(floats::kMax), slice(*y), 0),
makeHost()->floatDivide(slice(FloatTest::kMax), slice(*y), 0),
HostFunctionError::FloatComputationError);
}
TEST_F(FloatDivideImpl, ZeroDividedByOneIsZero)
{
expectValue(
makeHost()->floatDivide(slice(floats::kIntZero), slice(floats::kOne), 0), floats::kIntZero);
makeHost()->floatDivide(slice(FloatTest::kIntZero), slice(FloatTest::kOne), 0),
FloatTest::kIntZero);
}
TEST_F(FloatDivideImpl, MaxExpDividedByTenIsPreMaxExp)
{
expectValue(
makeHost()->floatDivide(slice(floats::kMaxExp), slice(floats::kTen), 0),
floats::kPreMaxExp);
makeHost()->floatDivide(slice(FloatTest::kMaxExp), slice(FloatTest::kTen), 0),
FloatTest::kPreMaxExp);
}
// The rounding mode changes an inexact result: 1/3 rounded Downward differs from Upward.
@@ -61,8 +62,8 @@ TEST_F(FloatDivideImpl, RoundingModeAffectsInexactResult)
{
auto const three = makeHost()->floatFromInt(3, 0);
ASSERT_TRUE(three.has_value());
auto const down = makeHost()->floatDivide(slice(floats::kOne), slice(*three), 2);
auto const up = makeHost()->floatDivide(slice(floats::kOne), slice(*three), 3);
auto const down = makeHost()->floatDivide(slice(FloatTest::kOne), slice(*three), 2);
auto const up = makeHost()->floatDivide(slice(FloatTest::kOne), slice(*three), 3);
ASSERT_TRUE(down.has_value() && up.has_value());
EXPECT_NE(*down, *up);
}

6
src/tests/libxrpl/tx/wasm/host_functions/FloatFromInt.cpp
View File

@@ -18,17 +18,17 @@ TEST_F(FloatFromIntImpl, BadModeIsMalformed)
TEST_F(FloatFromIntImpl, MinInt)
{
expectValue(makeHost()->floatFromInt(kMin64, 0), floats::kIntMin);
expectValue(makeHost()->floatFromInt(kMin64, 0), FloatTest::kIntMin);
}
TEST_F(FloatFromIntImpl, Zero)
{
expectValue(makeHost()->floatFromInt(0, 0), floats::kIntZero);
expectValue(makeHost()->floatFromInt(0, 0), FloatTest::kIntZero);
}
TEST_F(FloatFromIntImpl, MaxInt)
{
expectValue(makeHost()->floatFromInt(kMax64, 0), floats::kIntMax);
expectValue(makeHost()->floatFromInt(kMax64, 0), FloatTest::kIntMax);
}
} // namespace xrpl::test

20
src/tests/libxrpl/tx/wasm/host_functions/FloatFromMantExp.cpp
View File

@@ -10,8 +10,8 @@ namespace xrpl::test {
struct FloatFromMantExpImpl : FloatTest
{
static constexpr int kMaxRawExp = Number::kMaxExponent + floats::kNormalExp;
static constexpr int kMinRawExp = Number::kMinExponent + floats::kNormalExp;
static constexpr int kMaxRawExp = Number::kMaxExponent + FloatTest::kNormalExp;
static constexpr int kMinRawExp = Number::kMinExponent + FloatTest::kNormalExp;
};
TEST_F(FloatFromMantExpImpl, BadModeIsMalformed)
@@ -28,41 +28,41 @@ TEST_F(FloatFromMantExpImpl, ExponentTooHighIsMalformed)
TEST_F(FloatFromMantExpImpl, UnderflowIsZero)
{
expectValue(makeHost()->floatFromMantExp(1, kMinRawExp - 1, 0), floats::kIntZero);
expectValue(makeHost()->floatFromMantExp(1, kMinRawExp - 1, 0), FloatTest::kIntZero);
}
TEST_F(FloatFromMantExpImpl, MaxExponent)
{
expectValue(makeHost()->floatFromMantExp(1, kMaxRawExp, 0), floats::kMaxExp);
expectValue(makeHost()->floatFromMantExp(1, kMaxRawExp, 0), FloatTest::kMaxExp);
}
TEST_F(FloatFromMantExpImpl, MinusMaxExponent)
{
expectValue(makeHost()->floatFromMantExp(-1, kMaxRawExp, 0), floats::kMinusMaxExp);
expectValue(makeHost()->floatFromMantExp(-1, kMaxRawExp, 0), FloatTest::kMinusMaxExp);
}
TEST_F(FloatFromMantExpImpl, PreMaxExponent)
{
expectValue(makeHost()->floatFromMantExp(1, kMaxRawExp - 1, 0), floats::kPreMaxExp);
expectValue(makeHost()->floatFromMantExp(1, kMaxRawExp - 1, 0), FloatTest::kPreMaxExp);
}
TEST_F(FloatFromMantExpImpl, MaxIou)
{
expectValue(
makeHost()->floatFromMantExp(STAmount::kMaxValue, STAmount::kMaxOffset, 0),
floats::kMaxIOU);
FloatTest::kMaxIOU);
}
TEST_F(FloatFromMantExpImpl, MinExponent)
{
expectValue(
makeHost()->floatFromMantExp(1, Number::kMinExponent - floats::kNormalExp, 0),
floats::kMinExp);
makeHost()->floatFromMantExp(1, Number::kMinExponent - FloatTest::kNormalExp, 0),
FloatTest::kMinExp);
}
TEST_F(FloatFromMantExpImpl, TenTimesTenthIsOne)
{
expectValue(makeHost()->floatFromMantExp(10, -1, 0), floats::kOne);
expectValue(makeHost()->floatFromMantExp(10, -1, 0), FloatTest::kOne);
}
} // namespace xrpl::test

6
src/tests/libxrpl/tx/wasm/host_functions/FloatFromStAmount.cpp
View File

@@ -32,7 +32,7 @@ TEST_F(FloatFromStAmountImpl, BadModeIsMalformed)
TEST_F(FloatFromStAmountImpl, ZeroXrp)
{
expectValue(makeHost()->floatFromSTAmount(STAmount{XRP(0)}, 0), floats::kIntZero);
expectValue(makeHost()->floatFromSTAmount(STAmount{XRP(0)}, 0), FloatTest::kIntZero);
}
TEST_F(FloatFromStAmountImpl, MinusOneXrp)
@@ -54,14 +54,14 @@ TEST_F(FloatFromStAmountImpl, MinIou)
{
auto const amount = STAmount{
IOUAmount{static_cast<std::int64_t>(STAmount::kMinValue), STAmount::kMinOffset}, usd()};
expectValue(makeHost()->floatFromSTAmount(amount, 0), floats::kMinIOU);
expectValue(makeHost()->floatFromSTAmount(amount, 0), FloatTest::kMinIOU);
}
TEST_F(FloatFromStAmountImpl, MaxIou)
{
auto const amount = STAmount{
IOUAmount{static_cast<std::int64_t>(STAmount::kMaxValue), STAmount::kMaxOffset}, usd()};
expectValue(makeHost()->floatFromSTAmount(amount, 0), floats::kMaxIOU);
expectValue(makeHost()->floatFromSTAmount(amount, 0), FloatTest::kMaxIOU);
}
} // namespace xrpl::test

6
src/tests/libxrpl/tx/wasm/host_functions/FloatFromStNumber.cpp
View File

@@ -27,13 +27,13 @@ TEST_F(FloatFromStNumberImpl, MaxUint)
{
auto const n = STNumber{
sfNumber, Number(std::numeric_limits<std::uint64_t>::max(), 0, Number::Normalized{})};
expectValue(makeHost()->floatFromSTNumber(n, 0), floats::kUintMax);
expectValue(makeHost()->floatFromSTNumber(n, 0), FloatTest::kUintMax);
}
TEST_F(FloatFromStNumberImpl, MinusMaxExponent)
{
auto const n = STNumber{sfNumber, Number(-1, Number::kMaxExponent + floats::kNormalExp)};
expectValue(makeHost()->floatFromSTNumber(n, 0), floats::kMinusMaxExp);
auto const n = STNumber{sfNumber, Number(-1, Number::kMaxExponent + FloatTest::kNormalExp)};
expectValue(makeHost()->floatFromSTNumber(n, 0), FloatTest::kMinusMaxExp);
}
} // namespace xrpl::test

4
src/tests/libxrpl/tx/wasm/host_functions/FloatFromUint.cpp
View File

@@ -22,12 +22,12 @@ TEST_F(FloatFromUintImpl, BadModeIsMalformed)
TEST_F(FloatFromUintImpl, Zero)
{
expectValue(makeHost()->floatFromUint(0, 0), floats::kIntZero);
expectValue(makeHost()->floatFromUint(0, 0), FloatTest::kIntZero);
}
TEST_F(FloatFromUintImpl, MaxUint)
{
expectValue(makeHost()->floatFromUint(kMaxU64, 0), floats::kUintMax);
expectValue(makeHost()->floatFromUint(kMaxU64, 0), FloatTest::kUintMax);
}
} // namespace xrpl::test

17
src/tests/libxrpl/tx/wasm/host_functions/FloatMultiply.cpp
View File

@@ -14,42 +14,43 @@ struct FloatMultiplyImpl : FloatTest
TEST_F(FloatMultiplyImpl, BadModeIsMalformed)
{
expectError(
makeHost()->floatMultiply(slice(floats::kOne), slice(floats::kOne), -1),
makeHost()->floatMultiply(slice(FloatTest::kOne), slice(FloatTest::kOne), -1),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatMultiplyImpl, MalformedInput)
{
expectError(
makeHost()->floatMultiply(slice(floats::kOne), Slice{}, 0),
makeHost()->floatMultiply(slice(FloatTest::kOne), Slice{}, 0),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatMultiplyImpl, OverflowIsComputationError)
{
expectError(
makeHost()->floatMultiply(slice(floats::kMax), slice(floats::kOneMore), 0),
makeHost()->floatMultiply(slice(FloatTest::kMax), slice(FloatTest::kOneMore), 0),
HostFunctionError::FloatComputationError);
}
TEST_F(FloatMultiplyImpl, OneTimesOneIsOne)
{
expectValue(
makeHost()->floatMultiply(slice(floats::kOne), slice(floats::kOne), 0), floats::kOne);
makeHost()->floatMultiply(slice(FloatTest::kOne), slice(FloatTest::kOne), 0),
FloatTest::kOne);
}
TEST_F(FloatMultiplyImpl, ZeroTimesMaxIouIsZero)
{
expectValue(
makeHost()->floatMultiply(slice(floats::kIntZero), slice(floats::kMaxIOU), 0),
floats::kIntZero);
makeHost()->floatMultiply(slice(FloatTest::kIntZero), slice(FloatTest::kMaxIOU), 0),
FloatTest::kIntZero);
}
TEST_F(FloatMultiplyImpl, TenTimesPreMaxExpIsMaxExp)
{
expectValue(
makeHost()->floatMultiply(slice(floats::kTen), slice(floats::kPreMaxExp), 0),
floats::kMaxExp);
makeHost()->floatMultiply(slice(FloatTest::kTen), slice(FloatTest::kPreMaxExp), 0),
FloatTest::kMaxExp);
}
} // namespace xrpl::test

16
src/tests/libxrpl/tx/wasm/host_functions/FloatPower.cpp
View File

@@ -15,7 +15,8 @@ struct FloatPowerImpl : FloatTest
TEST_F(FloatPowerImpl, BadModeIsMalformed)
{
expectError(
makeHost()->floatPower(slice(floats::kOne), 2, -1), HostFunctionError::FloatInputMalformed);
makeHost()->floatPower(slice(FloatTest::kOne), 2, -1),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatPowerImpl, MalformedInput)
@@ -26,38 +27,39 @@ TEST_F(FloatPowerImpl, MalformedInput)
TEST_F(FloatPowerImpl, NegativeDegreeIsMalformed)
{
expectError(
makeHost()->floatPower(slice(floats::kOne), -2, 0), HostFunctionError::FloatInputMalformed);
makeHost()->floatPower(slice(FloatTest::kOne), -2, 0),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatPowerImpl, OverflowIsComputationError)
{
expectError(
makeHost()->floatPower(slice(floats::kMax), 2, 0),
makeHost()->floatPower(slice(FloatTest::kMax), 2, 0),
HostFunctionError::FloatComputationError);
}
TEST_F(FloatPowerImpl, DegreeTooLargeIsMalformed)
{
expectError(
makeHost()->floatPower(slice(floats::kMax), Number::kMaxExponent + 1, 0),
makeHost()->floatPower(slice(FloatTest::kMax), Number::kMaxExponent + 1, 0),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatPowerImpl, DegreeZeroIsOne)
{
expectValue(makeHost()->floatPower(slice(floats::kMaxIOU), 0, 0), floats::kOne);
expectValue(makeHost()->floatPower(slice(FloatTest::kMaxIOU), 0, 0), FloatTest::kOne);
}
TEST_F(FloatPowerImpl, DegreeOneIsIdentity)
{
expectValue(makeHost()->floatPower(slice(floats::kMaxIOU), 1, 0), floats::kMaxIOU);
expectValue(makeHost()->floatPower(slice(FloatTest::kMaxIOU), 1, 0), FloatTest::kMaxIOU);
}
TEST_F(FloatPowerImpl, TenSquaredIsHundred)
{
auto const hundred = makeHost()->floatFromMantExp(100, 0, 0);
ASSERT_TRUE(hundred.has_value());
expectValue(makeHost()->floatPower(slice(floats::kTen), 2, 0), *hundred);
expectValue(makeHost()->floatPower(slice(FloatTest::kTen), 2, 0), *hundred);
}
TEST_F(FloatPowerImpl, TenthSquaredIsHundredth)

14
src/tests/libxrpl/tx/wasm/host_functions/FloatRoot.cpp
View File

@@ -14,7 +14,8 @@ struct FloatRootImpl : FloatTest
TEST_F(FloatRootImpl, BadModeIsMalformed)
{
expectError(
makeHost()->floatRoot(slice(floats::kOne), 2, -1), HostFunctionError::FloatInputMalformed);
makeHost()->floatRoot(slice(FloatTest::kOne), 2, -1),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatRootImpl, MalformedInput)
@@ -25,31 +26,32 @@ TEST_F(FloatRootImpl, MalformedInput)
TEST_F(FloatRootImpl, NegativeDegreeIsMalformed)
{
expectError(
makeHost()->floatRoot(slice(floats::kOne), -2, 0), HostFunctionError::FloatInputMalformed);
makeHost()->floatRoot(slice(FloatTest::kOne), -2, 0),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatRootImpl, RootOfZeroIsZero)
{
expectValue(makeHost()->floatRoot(slice(floats::kIntZero), 2, 0), floats::kIntZero);
expectValue(makeHost()->floatRoot(slice(FloatTest::kIntZero), 2, 0), FloatTest::kIntZero);
}
TEST_F(FloatRootImpl, FirstRootIsIdentity)
{
expectValue(makeHost()->floatRoot(slice(floats::kMaxIOU), 1, 0), floats::kMaxIOU);
expectValue(makeHost()->floatRoot(slice(FloatTest::kMaxIOU), 1, 0), FloatTest::kMaxIOU);
}
TEST_F(FloatRootImpl, SquareRootOfHundredIsTen)
{
auto const hundred = makeHost()->floatFromMantExp(100, 0, 0);
ASSERT_TRUE(hundred.has_value());
expectValue(makeHost()->floatRoot(slice(*hundred), 2, 0), floats::kTen);
expectValue(makeHost()->floatRoot(slice(*hundred), 2, 0), FloatTest::kTen);
}
TEST_F(FloatRootImpl, CubeRootOfThousandIsTen)
{
auto const thousand = makeHost()->floatFromMantExp(1000, 0, 0);
ASSERT_TRUE(thousand.has_value());
expectValue(makeHost()->floatRoot(slice(*thousand), 3, 0), floats::kTen);
expectValue(makeHost()->floatRoot(slice(*thousand), 3, 0), FloatTest::kTen);
}
TEST_F(FloatRootImpl, SquareRootOfHundredthIsTenth)

16
src/tests/libxrpl/tx/wasm/host_functions/FloatSubtract.cpp
View File

@@ -14,36 +14,36 @@ struct FloatSubtractImpl : FloatTest
TEST_F(FloatSubtractImpl, BadModeIsMalformed)
{
expectError(
makeHost()->floatSubtract(slice(floats::kOne), slice(floats::kOne), -1),
makeHost()->floatSubtract(slice(FloatTest::kOne), slice(FloatTest::kOne), -1),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatSubtractImpl, MalformedInput)
{
expectError(
makeHost()->floatSubtract(slice(floats::kOne), Slice{}, 0),
makeHost()->floatSubtract(slice(FloatTest::kOne), Slice{}, 0),
HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatSubtractImpl, MinusMaxExpMinusMaxIouIsMinusMaxExp)
{
expectValue(
makeHost()->floatSubtract(slice(floats::kMinusMaxExp), slice(floats::kMaxIOU), 0),
floats::kMinusMaxExp);
makeHost()->floatSubtract(slice(FloatTest::kMinusMaxExp), slice(FloatTest::kMaxIOU), 0),
FloatTest::kMinusMaxExp);
}
TEST_F(FloatSubtractImpl, MinMinusZeroIsMin)
{
expectValue(
makeHost()->floatSubtract(slice(floats::kIntMin), slice(floats::kIntZero), 0),
floats::kIntMin);
makeHost()->floatSubtract(slice(FloatTest::kIntMin), slice(FloatTest::kIntZero), 0),
FloatTest::kIntMin);
}
TEST_F(FloatSubtractImpl, ZeroMinusOneIsMinusOne)
{
expectValue(
makeHost()->floatSubtract(slice(floats::kIntZero), slice(floats::kOne), 0),
floats::kMinusOne);
makeHost()->floatSubtract(slice(FloatTest::kIntZero), slice(FloatTest::kOne), 0),
FloatTest::kMinusOne);
}
} // namespace xrpl::test

24
src/tests/libxrpl/tx/wasm/host_functions/FloatToInt.cpp
View File

@@ -16,9 +16,9 @@ struct FloatToIntImpl : FloatTest
TEST_F(FloatToIntImpl, BadModeIsMalformed)
{
expectError(
makeHost()->floatToInt(slice(floats::kOne), -1), HostFunctionError::FloatInputMalformed);
makeHost()->floatToInt(slice(FloatTest::kOne), -1), HostFunctionError::FloatInputMalformed);
expectError(
makeHost()->floatToInt(slice(floats::kOne), 4), HostFunctionError::FloatInputMalformed);
makeHost()->floatToInt(slice(FloatTest::kOne), 4), HostFunctionError::FloatInputMalformed);
}
TEST_F(FloatToIntImpl, MalformedInputs)
@@ -28,43 +28,43 @@ TEST_F(FloatToIntImpl, MalformedInputs)
TEST_F(FloatToIntImpl, Zero)
{
expectValue(makeHost()->floatToInt(slice(floats::kIntZero), 0), std::int64_t{0});
expectValue(makeHost()->floatToInt(slice(FloatTest::kIntZero), 0), std::int64_t{0});
}
TEST_F(FloatToIntImpl, One)
{
expectValue(makeHost()->floatToInt(slice(floats::kOne), 0), std::int64_t{1});
expectValue(makeHost()->floatToInt(slice(FloatTest::kOne), 0), std::int64_t{1});
}
TEST_F(FloatToIntImpl, MinusOne)
{
expectValue(makeHost()->floatToInt(slice(floats::kMinusOne), 0), std::int64_t{-1});
expectValue(makeHost()->floatToInt(slice(FloatTest::kMinusOne), 0), std::int64_t{-1});
}
TEST_F(FloatToIntImpl, Max)
{
expectValue(makeHost()->floatToInt(slice(floats::kIntMax), 0), kMax64);
expectValue(makeHost()->floatToInt(slice(FloatTest::kIntMax), 0), kMax64);
}
TEST_F(FloatToIntImpl, Min)
{
// floatIntMin rounds to -(2^63-1), i.e. -kMax64.
expectValue(makeHost()->floatToInt(slice(floats::kIntMin), 0), -kMax64);
expectValue(makeHost()->floatToInt(slice(FloatTest::kIntMin), 0), -kMax64);
}
TEST_F(FloatToIntImpl, OverflowsInt64IsComputationError)
{
expectError(
makeHost()->floatToInt(slice(floats::kUintMax), 0),
makeHost()->floatToInt(slice(FloatTest::kUintMax), 0),
HostFunctionError::FloatComputationError);
}
TEST_F(FloatToIntImpl, PiRoundsByMode)
{
expectValue(makeHost()->floatToInt(slice(floats::kPi), 0), std::int64_t{3}); // ToNearest
expectValue(makeHost()->floatToInt(slice(floats::kPi), 1), std::int64_t{3}); // TowardsZero
expectValue(makeHost()->floatToInt(slice(floats::kPi), 2), std::int64_t{3}); // Downward
expectValue(makeHost()->floatToInt(slice(floats::kPi), 3), std::int64_t{4}); // Upward
expectValue(makeHost()->floatToInt(slice(FloatTest::kPi), 0), std::int64_t{3}); // ToNearest
expectValue(makeHost()->floatToInt(slice(FloatTest::kPi), 1), std::int64_t{3}); // TowardsZero
expectValue(makeHost()->floatToInt(slice(FloatTest::kPi), 2), std::int64_t{3}); // Downward
expectValue(makeHost()->floatToInt(slice(FloatTest::kPi), 3), std::int64_t{4}); // Upward
}
} // namespace xrpl::test

24
src/tests/libxrpl/tx/wasm/host_functions/FloatToMantExp.cpp
View File

@@ -29,51 +29,51 @@ TEST_F(FloatToMantExpImpl, MalformedInput)
TEST_F(FloatToMantExpImpl, Zero)
{
expectValue(makeHost()->floatToMantExp(slice(floats::kIntZero)), pair(0, kExpMin));
expectValue(makeHost()->floatToMantExp(slice(FloatTest::kIntZero)), pair(0, kExpMin));
}
TEST_F(FloatToMantExpImpl, One)
{
expectValue(
makeHost()->floatToMantExp(slice(floats::kOne)),
pair(1'000'000'000'000'000'000, -floats::kNormalExp));
makeHost()->floatToMantExp(slice(FloatTest::kOne)),
pair(1'000'000'000'000'000'000, -FloatTest::kNormalExp));
}
TEST_F(FloatToMantExpImpl, MinusOne)
{
expectValue(
makeHost()->floatToMantExp(slice(floats::kMinusOne)),
pair(-1'000'000'000'000'000'000, -floats::kNormalExp));
makeHost()->floatToMantExp(slice(FloatTest::kMinusOne)),
pair(-1'000'000'000'000'000'000, -FloatTest::kNormalExp));
}
TEST_F(FloatToMantExpImpl, Ten)
{
expectValue(
makeHost()->floatToMantExp(slice(floats::kTen)),
pair(1'000'000'000'000'000'000, -floats::kNormalExp + 1));
makeHost()->floatToMantExp(slice(FloatTest::kTen)),
pair(1'000'000'000'000'000'000, -FloatTest::kNormalExp + 1));
}
TEST_F(FloatToMantExpImpl, Pi)
{
expectValue(
makeHost()->floatToMantExp(slice(floats::kPi)),
pair(3'141'592'653'589'793'000, -floats::kNormalExp));
makeHost()->floatToMantExp(slice(FloatTest::kPi)),
pair(3'141'592'653'589'793'000, -FloatTest::kNormalExp));
}
TEST_F(FloatToMantExpImpl, IntMax)
{
expectValue(makeHost()->floatToMantExp(slice(floats::kIntMax)), pair(kMax64, 0));
expectValue(makeHost()->floatToMantExp(slice(FloatTest::kIntMax)), pair(kMax64, 0));
}
TEST_F(FloatToMantExpImpl, IntMin)
{
expectValue(makeHost()->floatToMantExp(slice(floats::kIntMin)), pair(-kMax64, 0));
expectValue(makeHost()->floatToMantExp(slice(FloatTest::kIntMin)), pair(-kMax64, 0));
}
TEST_F(FloatToMantExpImpl, Max)
{
expectValue(
makeHost()->floatToMantExp(slice(floats::kMax)),
makeHost()->floatToMantExp(slice(FloatTest::kMax)),
pair(Number::kMaxRep, Number::kMaxExponent));
}