mirror of
https://github.com/XRPLF/rippled.git
synced 2026-06-04 01:06:48 +00:00
224 lines
9.4 KiB
C++
224 lines
9.4 KiB
C++
#include <xrpl/beast/unit_test/suite.h>
|
|
#include <xrpl/protocol/SeqProxy.h>
|
|
|
|
#include <cstdint>
|
|
#include <limits>
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
namespace xrpl {
|
|
|
|
struct SeqProxy_test : public beast::unit_test::suite
|
|
{
|
|
// Exercise value(), isSeq(), and isTicket().
|
|
static constexpr bool
|
|
expectValues(SeqProxy seqProx, std::uint32_t value, SeqProxy::Type type)
|
|
{
|
|
bool const expectSeq{type == SeqProxy::seq};
|
|
return (seqProx.value() == value) && (seqProx.isSeq() == expectSeq) &&
|
|
(seqProx.isTicket() == !expectSeq);
|
|
}
|
|
|
|
// Exercise all SeqProxy comparison operators expecting lhs < rhs.
|
|
static constexpr bool
|
|
expectLt(SeqProxy lhs, SeqProxy rhs)
|
|
{
|
|
return (lhs < rhs) && (lhs <= rhs) && (!(lhs == rhs)) && (lhs != rhs) && (!(lhs >= rhs)) &&
|
|
(!(lhs > rhs));
|
|
}
|
|
|
|
// Exercise all SeqProxy comparison operators expecting lhs == rhs.
|
|
static constexpr bool
|
|
expectEq(SeqProxy lhs, SeqProxy rhs)
|
|
{
|
|
return (!(lhs < rhs)) && (lhs <= rhs) && (lhs == rhs) && (!(lhs != rhs)) && (lhs >= rhs) &&
|
|
(!(lhs > rhs));
|
|
}
|
|
|
|
// Exercise all SeqProxy comparison operators expecting lhs > rhs.
|
|
static constexpr bool
|
|
expectGt(SeqProxy lhs, SeqProxy rhs)
|
|
{
|
|
return (!(lhs < rhs)) && (!(lhs <= rhs)) && (!(lhs == rhs)) && (lhs != rhs) &&
|
|
(lhs >= rhs) && (lhs > rhs);
|
|
}
|
|
|
|
// Verify streaming.
|
|
static bool
|
|
streamTest(SeqProxy seqProx)
|
|
{
|
|
std::string const type{seqProx.isSeq() ? "sequence" : "ticket"};
|
|
std::string const value{std::to_string(seqProx.value())};
|
|
|
|
std::stringstream ss;
|
|
ss << seqProx;
|
|
std::string str{ss.str()};
|
|
|
|
return str.find(type) == 0 && str[type.size()] == ' ' &&
|
|
str.find(value) == (type.size() + 1);
|
|
}
|
|
|
|
void
|
|
run() override
|
|
{
|
|
// While SeqProxy supports values of zero, they are not
|
|
// expected in the wild. Nevertheless they are tested here.
|
|
// But so are values of 1, which are expected to occur in the wild.
|
|
static constexpr std::uint32_t uintMax{std::numeric_limits<std::uint32_t>::max()};
|
|
static constexpr SeqProxy::Type seq{SeqProxy::seq};
|
|
static constexpr SeqProxy::Type ticket{SeqProxy::ticket};
|
|
|
|
static constexpr SeqProxy seqZero{seq, 0};
|
|
static constexpr SeqProxy seqSmall{seq, 1};
|
|
static constexpr SeqProxy seqMid0{seq, 2};
|
|
static constexpr SeqProxy seqMid1{seqMid0};
|
|
static constexpr SeqProxy seqBig{seq, uintMax};
|
|
|
|
static constexpr SeqProxy ticZero{ticket, 0};
|
|
static constexpr SeqProxy ticSmall{ticket, 1};
|
|
static constexpr SeqProxy ticMid0{ticket, 2};
|
|
static constexpr SeqProxy ticMid1{ticMid0};
|
|
static constexpr SeqProxy ticBig{ticket, uintMax};
|
|
|
|
// Verify operation of value(), isSeq() and isTicket().
|
|
static_assert(expectValues(seqZero, 0, seq), "");
|
|
static_assert(expectValues(seqSmall, 1, seq), "");
|
|
static_assert(expectValues(seqMid0, 2, seq), "");
|
|
static_assert(expectValues(seqMid1, 2, seq), "");
|
|
static_assert(expectValues(seqBig, uintMax, seq), "");
|
|
|
|
static_assert(expectValues(ticZero, 0, ticket), "");
|
|
static_assert(expectValues(ticSmall, 1, ticket), "");
|
|
static_assert(expectValues(ticMid0, 2, ticket), "");
|
|
static_assert(expectValues(ticMid1, 2, ticket), "");
|
|
static_assert(expectValues(ticBig, uintMax, ticket), "");
|
|
|
|
// Verify expected behavior of comparison operators.
|
|
static_assert(expectEq(seqZero, seqZero), "");
|
|
static_assert(expectLt(seqZero, seqSmall), "");
|
|
static_assert(expectLt(seqZero, seqMid0), "");
|
|
static_assert(expectLt(seqZero, seqMid1), "");
|
|
static_assert(expectLt(seqZero, seqBig), "");
|
|
static_assert(expectLt(seqZero, ticZero), "");
|
|
static_assert(expectLt(seqZero, ticSmall), "");
|
|
static_assert(expectLt(seqZero, ticMid0), "");
|
|
static_assert(expectLt(seqZero, ticMid1), "");
|
|
static_assert(expectLt(seqZero, ticBig), "");
|
|
|
|
static_assert(expectGt(seqSmall, seqZero), "");
|
|
static_assert(expectEq(seqSmall, seqSmall), "");
|
|
static_assert(expectLt(seqSmall, seqMid0), "");
|
|
static_assert(expectLt(seqSmall, seqMid1), "");
|
|
static_assert(expectLt(seqSmall, seqBig), "");
|
|
static_assert(expectLt(seqSmall, ticZero), "");
|
|
static_assert(expectLt(seqSmall, ticSmall), "");
|
|
static_assert(expectLt(seqSmall, ticMid0), "");
|
|
static_assert(expectLt(seqSmall, ticMid1), "");
|
|
static_assert(expectLt(seqSmall, ticBig), "");
|
|
|
|
static_assert(expectGt(seqMid0, seqZero), "");
|
|
static_assert(expectGt(seqMid0, seqSmall), "");
|
|
static_assert(expectEq(seqMid0, seqMid0), "");
|
|
static_assert(expectEq(seqMid0, seqMid1), "");
|
|
static_assert(expectLt(seqMid0, seqBig), "");
|
|
static_assert(expectLt(seqMid0, ticZero), "");
|
|
static_assert(expectLt(seqMid0, ticSmall), "");
|
|
static_assert(expectLt(seqMid0, ticMid0), "");
|
|
static_assert(expectLt(seqMid0, ticMid1), "");
|
|
static_assert(expectLt(seqMid0, ticBig), "");
|
|
|
|
static_assert(expectGt(seqMid1, seqZero), "");
|
|
static_assert(expectGt(seqMid1, seqSmall), "");
|
|
static_assert(expectEq(seqMid1, seqMid0), "");
|
|
static_assert(expectEq(seqMid1, seqMid1), "");
|
|
static_assert(expectLt(seqMid1, seqBig), "");
|
|
static_assert(expectLt(seqMid1, ticZero), "");
|
|
static_assert(expectLt(seqMid1, ticSmall), "");
|
|
static_assert(expectLt(seqMid1, ticMid0), "");
|
|
static_assert(expectLt(seqMid1, ticMid1), "");
|
|
static_assert(expectLt(seqMid1, ticBig), "");
|
|
|
|
static_assert(expectGt(seqBig, seqZero), "");
|
|
static_assert(expectGt(seqBig, seqSmall), "");
|
|
static_assert(expectGt(seqBig, seqMid0), "");
|
|
static_assert(expectGt(seqBig, seqMid1), "");
|
|
static_assert(expectEq(seqBig, seqBig), "");
|
|
static_assert(expectLt(seqBig, ticZero), "");
|
|
static_assert(expectLt(seqBig, ticSmall), "");
|
|
static_assert(expectLt(seqBig, ticMid0), "");
|
|
static_assert(expectLt(seqBig, ticMid1), "");
|
|
static_assert(expectLt(seqBig, ticBig), "");
|
|
|
|
static_assert(expectGt(ticZero, seqZero), "");
|
|
static_assert(expectGt(ticZero, seqSmall), "");
|
|
static_assert(expectGt(ticZero, seqMid0), "");
|
|
static_assert(expectGt(ticZero, seqMid1), "");
|
|
static_assert(expectGt(ticZero, seqBig), "");
|
|
static_assert(expectEq(ticZero, ticZero), "");
|
|
static_assert(expectLt(ticZero, ticSmall), "");
|
|
static_assert(expectLt(ticZero, ticMid0), "");
|
|
static_assert(expectLt(ticZero, ticMid1), "");
|
|
static_assert(expectLt(ticZero, ticBig), "");
|
|
|
|
static_assert(expectGt(ticSmall, seqZero), "");
|
|
static_assert(expectGt(ticSmall, seqSmall), "");
|
|
static_assert(expectGt(ticSmall, seqMid0), "");
|
|
static_assert(expectGt(ticSmall, seqMid1), "");
|
|
static_assert(expectGt(ticSmall, seqBig), "");
|
|
static_assert(expectGt(ticSmall, ticZero), "");
|
|
static_assert(expectEq(ticSmall, ticSmall), "");
|
|
static_assert(expectLt(ticSmall, ticMid0), "");
|
|
static_assert(expectLt(ticSmall, ticMid1), "");
|
|
static_assert(expectLt(ticSmall, ticBig), "");
|
|
|
|
static_assert(expectGt(ticMid0, seqZero), "");
|
|
static_assert(expectGt(ticMid0, seqSmall), "");
|
|
static_assert(expectGt(ticMid0, seqMid0), "");
|
|
static_assert(expectGt(ticMid0, seqMid1), "");
|
|
static_assert(expectGt(ticMid0, seqBig), "");
|
|
static_assert(expectGt(ticMid0, ticZero), "");
|
|
static_assert(expectGt(ticMid0, ticSmall), "");
|
|
static_assert(expectEq(ticMid0, ticMid0), "");
|
|
static_assert(expectEq(ticMid0, ticMid1), "");
|
|
static_assert(expectLt(ticMid0, ticBig), "");
|
|
|
|
static_assert(expectGt(ticMid1, seqZero), "");
|
|
static_assert(expectGt(ticMid1, seqSmall), "");
|
|
static_assert(expectGt(ticMid1, seqMid0), "");
|
|
static_assert(expectGt(ticMid1, seqMid1), "");
|
|
static_assert(expectGt(ticMid1, seqBig), "");
|
|
static_assert(expectGt(ticMid1, ticZero), "");
|
|
static_assert(expectGt(ticMid1, ticSmall), "");
|
|
static_assert(expectEq(ticMid1, ticMid0), "");
|
|
static_assert(expectEq(ticMid1, ticMid1), "");
|
|
static_assert(expectLt(ticMid1, ticBig), "");
|
|
|
|
static_assert(expectGt(ticBig, seqZero), "");
|
|
static_assert(expectGt(ticBig, seqSmall), "");
|
|
static_assert(expectGt(ticBig, seqMid0), "");
|
|
static_assert(expectGt(ticBig, seqMid1), "");
|
|
static_assert(expectGt(ticBig, seqBig), "");
|
|
static_assert(expectGt(ticBig, ticZero), "");
|
|
static_assert(expectGt(ticBig, ticSmall), "");
|
|
static_assert(expectGt(ticBig, ticMid0), "");
|
|
static_assert(expectGt(ticBig, ticMid1), "");
|
|
static_assert(expectEq(ticBig, ticBig), "");
|
|
|
|
// Verify streaming.
|
|
BEAST_EXPECT(streamTest(seqZero));
|
|
BEAST_EXPECT(streamTest(seqSmall));
|
|
BEAST_EXPECT(streamTest(seqMid0));
|
|
BEAST_EXPECT(streamTest(seqMid1));
|
|
BEAST_EXPECT(streamTest(seqBig));
|
|
BEAST_EXPECT(streamTest(ticZero));
|
|
BEAST_EXPECT(streamTest(ticSmall));
|
|
BEAST_EXPECT(streamTest(ticMid0));
|
|
BEAST_EXPECT(streamTest(ticMid1));
|
|
BEAST_EXPECT(streamTest(ticBig));
|
|
}
|
|
};
|
|
|
|
BEAST_DEFINE_TESTSUITE(SeqProxy, protocol, xrpl);
|
|
|
|
} // namespace xrpl
|