rippled
Loading...
Searching...
No Matches
SeqProxy_test.cpp
1#include <xrpl/beast/unit_test.h>
2#include <xrpl/protocol/SeqProxy.h>
3
4#include <limits>
5#include <sstream>
6
7namespace xrpl {
8
9struct SeqProxy_test : public beast::unit_test::suite
10{
11 // Exercise value(), isSeq(), and isTicket().
12 static constexpr bool
13 expectValues(SeqProxy seqProx, std::uint32_t value, SeqProxy::Type type)
14 {
15 bool const expectSeq{type == SeqProxy::seq};
16 return (seqProx.value() == value) && (seqProx.isSeq() == expectSeq) && (seqProx.isTicket() == !expectSeq);
17 }
18
19 // Exercise all SeqProxy comparison operators expecting lhs < rhs.
20 static constexpr bool
21 expectLt(SeqProxy lhs, SeqProxy rhs)
22 {
23 return (lhs < rhs) && (lhs <= rhs) && (!(lhs == rhs)) && (lhs != rhs) && (!(lhs >= rhs)) && (!(lhs > rhs));
24 }
25
26 // Exercise all SeqProxy comparison operators expecting lhs == rhs.
27 static constexpr bool
28 expectEq(SeqProxy lhs, SeqProxy rhs)
29 {
30 return (!(lhs < rhs)) && (lhs <= rhs) && (lhs == rhs) && (!(lhs != rhs)) && (lhs >= rhs) && (!(lhs > rhs));
31 }
32
33 // Exercise all SeqProxy comparison operators expecting lhs > rhs.
34 static constexpr bool
35 expectGt(SeqProxy lhs, SeqProxy rhs)
36 {
37 return (!(lhs < rhs)) && (!(lhs <= rhs)) && (!(lhs == rhs)) && (lhs != rhs) && (lhs >= rhs) && (lhs > rhs);
38 }
39
40 // Verify streaming.
41 bool
42 streamTest(SeqProxy seqProx)
43 {
44 std::string const type{seqProx.isSeq() ? "sequence" : "ticket"};
45 std::string const value{std::to_string(seqProx.value())};
46
47 std::stringstream ss;
48 ss << seqProx;
49 std::string str{ss.str()};
50
51 return str.find(type) == 0 && str[type.size()] == ' ' && str.find(value) == (type.size() + 1);
52 }
53
54 void
55 run() override
56 {
57 // While SeqProxy supports values of zero, they are not
58 // expected in the wild. Nevertheless they are tested here.
59 // But so are values of 1, which are expected to occur in the wild.
60 static constexpr std::uint32_t uintMax{std::numeric_limits<std::uint32_t>::max()};
61 static constexpr SeqProxy::Type seq{SeqProxy::seq};
62 static constexpr SeqProxy::Type ticket{SeqProxy::ticket};
63
64 static constexpr SeqProxy seqZero{seq, 0};
65 static constexpr SeqProxy seqSmall{seq, 1};
66 static constexpr SeqProxy seqMid0{seq, 2};
67 static constexpr SeqProxy seqMid1{seqMid0};
68 static constexpr SeqProxy seqBig{seq, uintMax};
69
70 static constexpr SeqProxy ticZero{ticket, 0};
71 static constexpr SeqProxy ticSmall{ticket, 1};
72 static constexpr SeqProxy ticMid0{ticket, 2};
73 static constexpr SeqProxy ticMid1{ticMid0};
74 static constexpr SeqProxy ticBig{ticket, uintMax};
75
76 // Verify operation of value(), isSeq() and isTicket().
77 static_assert(expectValues(seqZero, 0, seq), "");
78 static_assert(expectValues(seqSmall, 1, seq), "");
79 static_assert(expectValues(seqMid0, 2, seq), "");
80 static_assert(expectValues(seqMid1, 2, seq), "");
81 static_assert(expectValues(seqBig, uintMax, seq), "");
82
83 static_assert(expectValues(ticZero, 0, ticket), "");
84 static_assert(expectValues(ticSmall, 1, ticket), "");
85 static_assert(expectValues(ticMid0, 2, ticket), "");
86 static_assert(expectValues(ticMid1, 2, ticket), "");
87 static_assert(expectValues(ticBig, uintMax, ticket), "");
88
89 // Verify expected behavior of comparison operators.
90 static_assert(expectEq(seqZero, seqZero), "");
91 static_assert(expectLt(seqZero, seqSmall), "");
92 static_assert(expectLt(seqZero, seqMid0), "");
93 static_assert(expectLt(seqZero, seqMid1), "");
94 static_assert(expectLt(seqZero, seqBig), "");
95 static_assert(expectLt(seqZero, ticZero), "");
96 static_assert(expectLt(seqZero, ticSmall), "");
97 static_assert(expectLt(seqZero, ticMid0), "");
98 static_assert(expectLt(seqZero, ticMid1), "");
99 static_assert(expectLt(seqZero, ticBig), "");
100
101 static_assert(expectGt(seqSmall, seqZero), "");
102 static_assert(expectEq(seqSmall, seqSmall), "");
103 static_assert(expectLt(seqSmall, seqMid0), "");
104 static_assert(expectLt(seqSmall, seqMid1), "");
105 static_assert(expectLt(seqSmall, seqBig), "");
106 static_assert(expectLt(seqSmall, ticZero), "");
107 static_assert(expectLt(seqSmall, ticSmall), "");
108 static_assert(expectLt(seqSmall, ticMid0), "");
109 static_assert(expectLt(seqSmall, ticMid1), "");
110 static_assert(expectLt(seqSmall, ticBig), "");
111
112 static_assert(expectGt(seqMid0, seqZero), "");
113 static_assert(expectGt(seqMid0, seqSmall), "");
114 static_assert(expectEq(seqMid0, seqMid0), "");
115 static_assert(expectEq(seqMid0, seqMid1), "");
116 static_assert(expectLt(seqMid0, seqBig), "");
117 static_assert(expectLt(seqMid0, ticZero), "");
118 static_assert(expectLt(seqMid0, ticSmall), "");
119 static_assert(expectLt(seqMid0, ticMid0), "");
120 static_assert(expectLt(seqMid0, ticMid1), "");
121 static_assert(expectLt(seqMid0, ticBig), "");
122
123 static_assert(expectGt(seqMid1, seqZero), "");
124 static_assert(expectGt(seqMid1, seqSmall), "");
125 static_assert(expectEq(seqMid1, seqMid0), "");
126 static_assert(expectEq(seqMid1, seqMid1), "");
127 static_assert(expectLt(seqMid1, seqBig), "");
128 static_assert(expectLt(seqMid1, ticZero), "");
129 static_assert(expectLt(seqMid1, ticSmall), "");
130 static_assert(expectLt(seqMid1, ticMid0), "");
131 static_assert(expectLt(seqMid1, ticMid1), "");
132 static_assert(expectLt(seqMid1, ticBig), "");
133
134 static_assert(expectGt(seqBig, seqZero), "");
135 static_assert(expectGt(seqBig, seqSmall), "");
136 static_assert(expectGt(seqBig, seqMid0), "");
137 static_assert(expectGt(seqBig, seqMid1), "");
138 static_assert(expectEq(seqBig, seqBig), "");
139 static_assert(expectLt(seqBig, ticZero), "");
140 static_assert(expectLt(seqBig, ticSmall), "");
141 static_assert(expectLt(seqBig, ticMid0), "");
142 static_assert(expectLt(seqBig, ticMid1), "");
143 static_assert(expectLt(seqBig, ticBig), "");
144
145 static_assert(expectGt(ticZero, seqZero), "");
146 static_assert(expectGt(ticZero, seqSmall), "");
147 static_assert(expectGt(ticZero, seqMid0), "");
148 static_assert(expectGt(ticZero, seqMid1), "");
149 static_assert(expectGt(ticZero, seqBig), "");
150 static_assert(expectEq(ticZero, ticZero), "");
151 static_assert(expectLt(ticZero, ticSmall), "");
152 static_assert(expectLt(ticZero, ticMid0), "");
153 static_assert(expectLt(ticZero, ticMid1), "");
154 static_assert(expectLt(ticZero, ticBig), "");
155
156 static_assert(expectGt(ticSmall, seqZero), "");
157 static_assert(expectGt(ticSmall, seqSmall), "");
158 static_assert(expectGt(ticSmall, seqMid0), "");
159 static_assert(expectGt(ticSmall, seqMid1), "");
160 static_assert(expectGt(ticSmall, seqBig), "");
161 static_assert(expectGt(ticSmall, ticZero), "");
162 static_assert(expectEq(ticSmall, ticSmall), "");
163 static_assert(expectLt(ticSmall, ticMid0), "");
164 static_assert(expectLt(ticSmall, ticMid1), "");
165 static_assert(expectLt(ticSmall, ticBig), "");
166
167 static_assert(expectGt(ticMid0, seqZero), "");
168 static_assert(expectGt(ticMid0, seqSmall), "");
169 static_assert(expectGt(ticMid0, seqMid0), "");
170 static_assert(expectGt(ticMid0, seqMid1), "");
171 static_assert(expectGt(ticMid0, seqBig), "");
172 static_assert(expectGt(ticMid0, ticZero), "");
173 static_assert(expectGt(ticMid0, ticSmall), "");
174 static_assert(expectEq(ticMid0, ticMid0), "");
175 static_assert(expectEq(ticMid0, ticMid1), "");
176 static_assert(expectLt(ticMid0, ticBig), "");
177
178 static_assert(expectGt(ticMid1, seqZero), "");
179 static_assert(expectGt(ticMid1, seqSmall), "");
180 static_assert(expectGt(ticMid1, seqMid0), "");
181 static_assert(expectGt(ticMid1, seqMid1), "");
182 static_assert(expectGt(ticMid1, seqBig), "");
183 static_assert(expectGt(ticMid1, ticZero), "");
184 static_assert(expectGt(ticMid1, ticSmall), "");
185 static_assert(expectEq(ticMid1, ticMid0), "");
186 static_assert(expectEq(ticMid1, ticMid1), "");
187 static_assert(expectLt(ticMid1, ticBig), "");
188
189 static_assert(expectGt(ticBig, seqZero), "");
190 static_assert(expectGt(ticBig, seqSmall), "");
191 static_assert(expectGt(ticBig, seqMid0), "");
192 static_assert(expectGt(ticBig, seqMid1), "");
193 static_assert(expectGt(ticBig, seqBig), "");
194 static_assert(expectGt(ticBig, ticZero), "");
195 static_assert(expectGt(ticBig, ticSmall), "");
196 static_assert(expectGt(ticBig, ticMid0), "");
197 static_assert(expectGt(ticBig, ticMid1), "");
198 static_assert(expectEq(ticBig, ticBig), "");
199
200 // Verify streaming.
201 BEAST_EXPECT(streamTest(seqZero));
202 BEAST_EXPECT(streamTest(seqSmall));
203 BEAST_EXPECT(streamTest(seqMid0));
204 BEAST_EXPECT(streamTest(seqMid1));
205 BEAST_EXPECT(streamTest(seqBig));
206 BEAST_EXPECT(streamTest(ticZero));
207 BEAST_EXPECT(streamTest(ticSmall));
208 BEAST_EXPECT(streamTest(ticMid0));
209 BEAST_EXPECT(streamTest(ticMid1));
210 BEAST_EXPECT(streamTest(ticBig));
211 }
212};
213
214BEAST_DEFINE_TESTSUITE(SeqProxy, protocol, xrpl);
215
216} // namespace xrpl
beast::unit_test::suite
A testsuite class.
Definition suite.h:52
xrpl::SeqProxy
A type that represents either a sequence value or a ticket value.
Definition SeqProxy.h:37
xrpl::SeqProxy::isTicket
constexpr bool isTicket() const
Definition SeqProxy.h:75
xrpl::SeqProxy::value
constexpr std::uint32_t value() const
Definition SeqProxy.h:63
xrpl::SeqProxy::isSeq
constexpr bool isSeq() const
Definition SeqProxy.h:69
std::numeric_limits::max
T max(T... args)
xrpl
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:6
std::stringstream::str
T str(T... args)
xrpl::SeqProxy_test
Definition SeqProxy_test.cpp:10
xrpl::SeqProxy_test::run
void run() override
Runs the suite.
Definition SeqProxy_test.cpp:55
xrpl::SeqProxy_test::expectGt
static constexpr bool expectGt(SeqProxy lhs, SeqProxy rhs)
Definition SeqProxy_test.cpp:35
xrpl::SeqProxy_test::expectLt
static constexpr bool expectLt(SeqProxy lhs, SeqProxy rhs)
Definition SeqProxy_test.cpp:21
xrpl::SeqProxy_test::expectValues
static constexpr bool expectValues(SeqProxy seqProx, std::uint32_t value, SeqProxy::Type type)
Definition SeqProxy_test.cpp:13
xrpl::SeqProxy_test::expectEq
static constexpr bool expectEq(SeqProxy lhs, SeqProxy rhs)
Definition SeqProxy_test.cpp:28
xrpl::SeqProxy_test::streamTest
bool streamTest(SeqProxy seqProx)
Definition SeqProxy_test.cpp:42
std::to_string
T to_string(T... args)
Generated by doxygen 1.9.8