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