rippled
Loading...
Searching...
No Matches
Issue_test.cpp
1#include <xrpl/basics/UnorderedContainers.h>
2#include <xrpl/beast/unit_test.h>
3#include <xrpl/protocol/Book.h>
4#include <xrpl/protocol/Issue.h>
5
6#include <sys/types.h>
7
8#include <map>
9#include <optional>
10#include <set>
11#include <typeinfo>
12#include <unordered_set>
13
14#if BEAST_MSVC
15#define STL_SET_HAS_EMPLACE 1
16#else
17#define STL_SET_HAS_EMPLACE 0
18#endif
19
20namespace xrpl {
21
22class Issue_test : public beast::unit_test::suite
23{
24public:
25 using Domain = uint256;
26
27 // Comparison, hash tests for uint60 (via base_uint)
28 template <typename Unsigned>
29 void
30 testUnsigned()
31 {
32 Unsigned const u1(1);
33 Unsigned const u2(2);
34 Unsigned const u3(3);
35
36 BEAST_EXPECT(u1 != u2);
37 BEAST_EXPECT(u1 < u2);
38 BEAST_EXPECT(u1 <= u2);
39 BEAST_EXPECT(u2 <= u2);
40 BEAST_EXPECT(u2 == u2);
41 BEAST_EXPECT(u2 >= u2);
42 BEAST_EXPECT(u3 >= u2);
43 BEAST_EXPECT(u3 > u2);
44
45 std::hash<Unsigned> hash;
46
47 BEAST_EXPECT(hash(u1) == hash(u1));
48 BEAST_EXPECT(hash(u2) == hash(u2));
49 BEAST_EXPECT(hash(u3) == hash(u3));
50 BEAST_EXPECT(hash(u1) != hash(u2));
51 BEAST_EXPECT(hash(u1) != hash(u3));
52 BEAST_EXPECT(hash(u2) != hash(u3));
53 }
54
55 //--------------------------------------------------------------------------
56
57 // Comparison, hash tests for Issue
58 template <class Issue>
59 void
60 testIssue()
61 {
62 Currency const c1(1);
63 AccountID const i1(1);
64 Currency const c2(2);
65 AccountID const i2(2);
66 Currency const c3(3);
67 AccountID const i3(3);
68
69 BEAST_EXPECT(Issue(c1, i1) != Issue(c2, i1));
70 BEAST_EXPECT(Issue(c1, i1) < Issue(c2, i1));
71 BEAST_EXPECT(Issue(c1, i1) <= Issue(c2, i1));
72 BEAST_EXPECT(Issue(c2, i1) <= Issue(c2, i1));
73 BEAST_EXPECT(Issue(c2, i1) == Issue(c2, i1));
74 BEAST_EXPECT(Issue(c2, i1) >= Issue(c2, i1));
75 BEAST_EXPECT(Issue(c3, i1) >= Issue(c2, i1));
76 BEAST_EXPECT(Issue(c3, i1) > Issue(c2, i1));
77 BEAST_EXPECT(Issue(c1, i1) != Issue(c1, i2));
78 BEAST_EXPECT(Issue(c1, i1) < Issue(c1, i2));
79 BEAST_EXPECT(Issue(c1, i1) <= Issue(c1, i2));
80 BEAST_EXPECT(Issue(c1, i2) <= Issue(c1, i2));
81 BEAST_EXPECT(Issue(c1, i2) == Issue(c1, i2));
82 BEAST_EXPECT(Issue(c1, i2) >= Issue(c1, i2));
83 BEAST_EXPECT(Issue(c1, i3) >= Issue(c1, i2));
84 BEAST_EXPECT(Issue(c1, i3) > Issue(c1, i2));
85
86 std::hash<Issue> hash;
87
88 BEAST_EXPECT(hash(Issue(c1, i1)) == hash(Issue(c1, i1)));
89 BEAST_EXPECT(hash(Issue(c1, i2)) == hash(Issue(c1, i2)));
90 BEAST_EXPECT(hash(Issue(c1, i3)) == hash(Issue(c1, i3)));
91 BEAST_EXPECT(hash(Issue(c2, i1)) == hash(Issue(c2, i1)));
92 BEAST_EXPECT(hash(Issue(c2, i2)) == hash(Issue(c2, i2)));
93 BEAST_EXPECT(hash(Issue(c2, i3)) == hash(Issue(c2, i3)));
94 BEAST_EXPECT(hash(Issue(c3, i1)) == hash(Issue(c3, i1)));
95 BEAST_EXPECT(hash(Issue(c3, i2)) == hash(Issue(c3, i2)));
96 BEAST_EXPECT(hash(Issue(c3, i3)) == hash(Issue(c3, i3)));
97 BEAST_EXPECT(hash(Issue(c1, i1)) != hash(Issue(c1, i2)));
98 BEAST_EXPECT(hash(Issue(c1, i1)) != hash(Issue(c1, i3)));
99 BEAST_EXPECT(hash(Issue(c1, i1)) != hash(Issue(c2, i1)));
100 BEAST_EXPECT(hash(Issue(c1, i1)) != hash(Issue(c2, i2)));
101 BEAST_EXPECT(hash(Issue(c1, i1)) != hash(Issue(c2, i3)));
102 BEAST_EXPECT(hash(Issue(c1, i1)) != hash(Issue(c3, i1)));
103 BEAST_EXPECT(hash(Issue(c1, i1)) != hash(Issue(c3, i2)));
104 BEAST_EXPECT(hash(Issue(c1, i1)) != hash(Issue(c3, i3)));
105 }
106
107 template <class Set>
108 void
109 testIssueSet()
110 {
111 Currency const c1(1);
112 AccountID const i1(1);
113 Currency const c2(2);
114 AccountID const i2(2);
115 Issue const a1(c1, i1);
116 Issue const a2(c2, i2);
117
118 {
119 Set c;
120
121 c.insert(a1);
122 if (!BEAST_EXPECT(c.size() == 1))
123 return;
124 c.insert(a2);
125 if (!BEAST_EXPECT(c.size() == 2))
126 return;
127
128 if (!BEAST_EXPECT(c.erase(Issue(c1, i2)) == 0))
129 return;
130 if (!BEAST_EXPECT(c.erase(Issue(c1, i1)) == 1))
131 return;
132 if (!BEAST_EXPECT(c.erase(Issue(c2, i2)) == 1))
133 return;
134 if (!BEAST_EXPECT(c.empty()))
135 return;
136 }
137
138 {
139 Set c;
140
141 c.insert(a1);
142 if (!BEAST_EXPECT(c.size() == 1))
143 return;
144 c.insert(a2);
145 if (!BEAST_EXPECT(c.size() == 2))
146 return;
147
148 if (!BEAST_EXPECT(c.erase(Issue(c1, i2)) == 0))
149 return;
150 if (!BEAST_EXPECT(c.erase(Issue(c1, i1)) == 1))
151 return;
152 if (!BEAST_EXPECT(c.erase(Issue(c2, i2)) == 1))
153 return;
154 if (!BEAST_EXPECT(c.empty()))
155 return;
156
157#if STL_SET_HAS_EMPLACE
158 c.emplace(c1, i1);
159 if (!BEAST_EXPECT(c.size() == 1))
160 return;
161 c.emplace(c2, i2);
162 if (!BEAST_EXPECT(c.size() == 2))
163 return;
164#endif
165 }
166 }
167
168 template <class Map>
169 void
170 testIssueMap()
171 {
172 Currency const c1(1);
173 AccountID const i1(1);
174 Currency const c2(2);
175 AccountID const i2(2);
176 Issue const a1(c1, i1);
177 Issue const a2(c2, i2);
178
179 {
180 Map c;
181
182 c.insert(std::make_pair(a1, 1));
183 if (!BEAST_EXPECT(c.size() == 1))
184 return;
185 c.insert(std::make_pair(a2, 2));
186 if (!BEAST_EXPECT(c.size() == 2))
187 return;
188
189 if (!BEAST_EXPECT(c.erase(Issue(c1, i2)) == 0))
190 return;
191 if (!BEAST_EXPECT(c.erase(Issue(c1, i1)) == 1))
192 return;
193 if (!BEAST_EXPECT(c.erase(Issue(c2, i2)) == 1))
194 return;
195 if (!BEAST_EXPECT(c.empty()))
196 return;
197 }
198
199 {
200 Map c;
201
202 c.insert(std::make_pair(a1, 1));
203 if (!BEAST_EXPECT(c.size() == 1))
204 return;
205 c.insert(std::make_pair(a2, 2));
206 if (!BEAST_EXPECT(c.size() == 2))
207 return;
208
209 if (!BEAST_EXPECT(c.erase(Issue(c1, i2)) == 0))
210 return;
211 if (!BEAST_EXPECT(c.erase(Issue(c1, i1)) == 1))
212 return;
213 if (!BEAST_EXPECT(c.erase(Issue(c2, i2)) == 1))
214 return;
215 if (!BEAST_EXPECT(c.empty()))
216 return;
217 }
218 }
219
220 template <class Set>
221 void
222 testIssueDomainSet()
223 {
224 Currency const c1(1);
225 AccountID const i1(1);
226 Currency const c2(2);
227 AccountID const i2(2);
228 Issue const a1(c1, i1);
229 Issue const a2(c2, i2);
230 uint256 const domain1{1};
231 uint256 const domain2{2};
232
233 Set c;
234
235 c.insert(std::make_pair(a1, domain1));
236 if (!BEAST_EXPECT(c.size() == 1))
237 return;
238 c.insert(std::make_pair(a2, domain1));
239 if (!BEAST_EXPECT(c.size() == 2))
240 return;
241 c.insert(std::make_pair(a2, domain2));
242 if (!BEAST_EXPECT(c.size() == 3))
243 return;
244
245 if (!BEAST_EXPECT(c.erase(std::make_pair(Issue(c1, i2), domain1)) == 0))
246 return;
247 if (!BEAST_EXPECT(c.erase(std::make_pair(a1, domain1)) == 1))
248 return;
249 if (!BEAST_EXPECT(c.erase(std::make_pair(a2, domain1)) == 1))
250 return;
251 if (!BEAST_EXPECT(c.erase(std::make_pair(a2, domain2)) == 1))
252 return;
253 if (!BEAST_EXPECT(c.empty()))
254 return;
255 }
256
257 template <class Map>
258 void
259 testIssueDomainMap()
260 {
261 Currency const c1(1);
262 AccountID const i1(1);
263 Currency const c2(2);
264 AccountID const i2(2);
265 Issue const a1(c1, i1);
266 Issue const a2(c2, i2);
267 uint256 const domain1{1};
268 uint256 const domain2{2};
269
270 Map c;
271
272 c.insert(std::make_pair(std::make_pair(a1, domain1), 1));
273 if (!BEAST_EXPECT(c.size() == 1))
274 return;
275 c.insert(std::make_pair(std::make_pair(a2, domain1), 2));
276 if (!BEAST_EXPECT(c.size() == 2))
277 return;
278 c.insert(std::make_pair(std::make_pair(a2, domain2), 2));
279 if (!BEAST_EXPECT(c.size() == 3))
280 return;
281
282 if (!BEAST_EXPECT(c.erase(std::make_pair(Issue(c1, i2), domain1)) == 0))
283 return;
284 if (!BEAST_EXPECT(c.erase(std::make_pair(a1, domain1)) == 1))
285 return;
286 if (!BEAST_EXPECT(c.erase(std::make_pair(a2, domain1)) == 1))
287 return;
288 if (!BEAST_EXPECT(c.erase(std::make_pair(a2, domain2)) == 1))
289 return;
290 if (!BEAST_EXPECT(c.empty()))
291 return;
292 }
293
294 void
295 testIssueDomainSets()
296 {
297 testcase("std::set <std::pair<Issue, Domain>>");
298 testIssueDomainSet<std::set<std::pair<Issue, Domain>>>();
299
300 testcase("std::set <std::pair<Issue, Domain>>");
301 testIssueDomainSet<std::set<std::pair<Issue, Domain>>>();
302
303 testcase("hash_set <std::pair<Issue, Domain>>");
304 testIssueDomainSet<hash_set<std::pair<Issue, Domain>>>();
305
306 testcase("hash_set <std::pair<Issue, Domain>>");
307 testIssueDomainSet<hash_set<std::pair<Issue, Domain>>>();
308 }
309
310 void
311 testIssueDomainMaps()
312 {
313 testcase("std::map <std::pair<Issue, Domain>, int>");
314 testIssueDomainMap<std::map<std::pair<Issue, Domain>, int>>();
315
316 testcase("std::map <std::pair<Issue, Domain>, int>");
317 testIssueDomainMap<std::map<std::pair<Issue, Domain>, int>>();
318
319#if XRPL_ASSETS_ENABLE_STD_HASH
320 testcase("hash_map <std::pair<Issue, Domain>, int>");
321 testIssueDomainMap<hash_map<std::pair<Issue, Domain>, int>>();
322
323 testcase("hash_map <std::pair<Issue, Domain>, int>");
324 testIssueDomainMap<hash_map<std::pair<Issue, Domain>, int>>();
325
326 testcase("hardened_hash_map <std::pair<Issue, Domain>, int>");
327 testIssueDomainMap<hardened_hash_map<std::pair<Issue, Domain>, int>>();
328
329 testcase("hardened_hash_map <std::pair<Issue, Domain>, int>");
330 testIssueDomainMap<hardened_hash_map<std::pair<Issue, Domain>, int>>();
331#endif
332 }
333
334 void
335 testIssueSets()
336 {
337 testcase("std::set <Issue>");
338 testIssueSet<std::set<Issue>>();
339
340 testcase("std::set <Issue>");
341 testIssueSet<std::set<Issue>>();
342
343#if XRPL_ASSETS_ENABLE_STD_HASH
344 testcase("std::unordered_set <Issue>");
345 testIssueSet<std::unordered_set<Issue>>();
346
347 testcase("std::unordered_set <Issue>");
348 testIssueSet<std::unordered_set<Issue>>();
349#endif
350
351 testcase("hash_set <Issue>");
352 testIssueSet<hash_set<Issue>>();
353
354 testcase("hash_set <Issue>");
355 testIssueSet<hash_set<Issue>>();
356 }
357
358 void
359 testIssueMaps()
360 {
361 testcase("std::map <Issue, int>");
362 testIssueMap<std::map<Issue, int>>();
363
364 testcase("std::map <Issue, int>");
365 testIssueMap<std::map<Issue, int>>();
366
367#if XRPL_ASSETS_ENABLE_STD_HASH
368 testcase("std::unordered_map <Issue, int>");
369 testIssueMap<std::unordered_map<Issue, int>>();
370
371 testcase("std::unordered_map <Issue, int>");
372 testIssueMap<std::unordered_map<Issue, int>>();
373
374 testcase("hash_map <Issue, int>");
375 testIssueMap<hash_map<Issue, int>>();
376
377 testcase("hash_map <Issue, int>");
378 testIssueMap<hash_map<Issue, int>>();
379
380#endif
381 }
382
383 //--------------------------------------------------------------------------
384
385 // Comparison, hash tests for Book
386 template <class Book>
387 void
388 testBook()
389 {
390 Currency const c1(1);
391 AccountID const i1(1);
392 Currency const c2(2);
393 AccountID const i2(2);
394 Currency const c3(3);
395 AccountID const i3(3);
396
397 Issue a1(c1, i1);
398 Issue a2(c1, i2);
399 Issue a3(c2, i2);
400 Issue a4(c3, i2);
401 uint256 const domain1{1};
402 uint256 const domain2{2};
403
404 // Books without domains
405 BEAST_EXPECT(Book(a1, a2, std::nullopt) != Book(a2, a3, std::nullopt));
406 BEAST_EXPECT(Book(a1, a2, std::nullopt) < Book(a2, a3, std::nullopt));
407 BEAST_EXPECT(Book(a1, a2, std::nullopt) <= Book(a2, a3, std::nullopt));
408 BEAST_EXPECT(Book(a2, a3, std::nullopt) <= Book(a2, a3, std::nullopt));
409 BEAST_EXPECT(Book(a2, a3, std::nullopt) == Book(a2, a3, std::nullopt));
410 BEAST_EXPECT(Book(a2, a3, std::nullopt) >= Book(a2, a3, std::nullopt));
411 BEAST_EXPECT(Book(a3, a4, std::nullopt) >= Book(a2, a3, std::nullopt));
412 BEAST_EXPECT(Book(a3, a4, std::nullopt) > Book(a2, a3, std::nullopt));
413
414 // test domain books
415 {
416 // Books with different domains
417 BEAST_EXPECT(Book(a2, a3, domain1) != Book(a2, a3, domain2));
418 BEAST_EXPECT(Book(a2, a3, domain1) < Book(a2, a3, domain2));
419 BEAST_EXPECT(Book(a2, a3, domain2) > Book(a2, a3, domain1));
420
421 // One Book has a domain, the other does not
422 BEAST_EXPECT(Book(a2, a3, domain1) != Book(a2, a3, std::nullopt));
423 BEAST_EXPECT(Book(a2, a3, std::nullopt) < Book(a2, a3, domain1));
424 BEAST_EXPECT(Book(a2, a3, domain1) > Book(a2, a3, std::nullopt));
425
426 // Both Books have the same domain
427 BEAST_EXPECT(Book(a2, a3, domain1) == Book(a2, a3, domain1));
428 BEAST_EXPECT(Book(a2, a3, domain2) == Book(a2, a3, domain2));
429 BEAST_EXPECT(Book(a2, a3, std::nullopt) == Book(a2, a3, std::nullopt));
430
431 // Both Books have no domain
432 BEAST_EXPECT(Book(a2, a3, std::nullopt) == Book(a2, a3, std::nullopt));
433
434 // Testing comparisons with >= and <=
435
436 // When comparing books with domain1 vs domain2
437 BEAST_EXPECT(Book(a2, a3, domain1) <= Book(a2, a3, domain2));
438 BEAST_EXPECT(Book(a2, a3, domain2) >= Book(a2, a3, domain1));
439 BEAST_EXPECT(Book(a2, a3, domain1) >= Book(a2, a3, domain1));
440 BEAST_EXPECT(Book(a2, a3, domain2) <= Book(a2, a3, domain2));
441
442 // One Book has domain1 and the other has no domain
443 BEAST_EXPECT(Book(a2, a3, domain1) > Book(a2, a3, std::nullopt));
444 BEAST_EXPECT(Book(a2, a3, std::nullopt) < Book(a2, a3, domain1));
445
446 // One Book has domain2 and the other has no domain
447 BEAST_EXPECT(Book(a2, a3, domain2) > Book(a2, a3, std::nullopt));
448 BEAST_EXPECT(Book(a2, a3, std::nullopt) < Book(a2, a3, domain2));
449
450 // Comparing two Books with no domains
451 BEAST_EXPECT(Book(a2, a3, std::nullopt) <= Book(a2, a3, std::nullopt));
452 BEAST_EXPECT(Book(a2, a3, std::nullopt) >= Book(a2, a3, std::nullopt));
453
454 // Test case where domain1 is less than domain2
455 BEAST_EXPECT(Book(a2, a3, domain1) <= Book(a2, a3, domain2));
456 BEAST_EXPECT(Book(a2, a3, domain2) >= Book(a2, a3, domain1));
457
458 // Test case where domain2 is equal to domain1
459 BEAST_EXPECT(Book(a2, a3, domain1) >= Book(a2, a3, domain1));
460 BEAST_EXPECT(Book(a2, a3, domain1) <= Book(a2, a3, domain1));
461
462 // More test cases involving a4 (with domain2)
463
464 // Comparing Book with domain2 (a4) to a Book with domain1
465 BEAST_EXPECT(Book(a2, a3, domain1) < Book(a3, a4, domain2));
466 BEAST_EXPECT(Book(a3, a4, domain2) > Book(a2, a3, domain1));
467
468 // Comparing Book with domain2 (a4) to a Book with no domain
469 BEAST_EXPECT(Book(a3, a4, domain2) > Book(a2, a3, std::nullopt));
470 BEAST_EXPECT(Book(a2, a3, std::nullopt) < Book(a3, a4, domain2));
471
472 // Comparing Book with domain2 (a4) to a Book with the same domain
473 BEAST_EXPECT(Book(a3, a4, domain2) == Book(a3, a4, domain2));
474
475 // Comparing Book with domain2 (a4) to a Book with domain1
476 BEAST_EXPECT(Book(a2, a3, domain1) < Book(a3, a4, domain2));
477 BEAST_EXPECT(Book(a3, a4, domain2) > Book(a2, a3, domain1));
478 }
479
480 std::hash<Book> hash;
481
482 // log << std::hex << hash (Book (a1, a2));
483 // log << std::hex << hash (Book (a1, a2));
484 //
485 // log << std::hex << hash (Book (a1, a3));
486 // log << std::hex << hash (Book (a1, a3));
487 //
488 // log << std::hex << hash (Book (a1, a4));
489 // log << std::hex << hash (Book (a1, a4));
490 //
491 // log << std::hex << hash (Book (a2, a3));
492 // log << std::hex << hash (Book (a2, a3));
493 //
494 // log << std::hex << hash (Book (a2, a4));
495 // log << std::hex << hash (Book (a2, a4));
496 //
497 // log << std::hex << hash (Book (a3, a4));
498 // log << std::hex << hash (Book (a3, a4));
499
500 BEAST_EXPECT(hash(Book(a1, a2, std::nullopt)) == hash(Book(a1, a2, std::nullopt)));
501 BEAST_EXPECT(hash(Book(a1, a3, std::nullopt)) == hash(Book(a1, a3, std::nullopt)));
502 BEAST_EXPECT(hash(Book(a1, a4, std::nullopt)) == hash(Book(a1, a4, std::nullopt)));
503 BEAST_EXPECT(hash(Book(a2, a3, std::nullopt)) == hash(Book(a2, a3, std::nullopt)));
504 BEAST_EXPECT(hash(Book(a2, a4, std::nullopt)) == hash(Book(a2, a4, std::nullopt)));
505 BEAST_EXPECT(hash(Book(a3, a4, std::nullopt)) == hash(Book(a3, a4, std::nullopt)));
506
507 BEAST_EXPECT(hash(Book(a1, a2, std::nullopt)) != hash(Book(a1, a3, std::nullopt)));
508 BEAST_EXPECT(hash(Book(a1, a2, std::nullopt)) != hash(Book(a1, a4, std::nullopt)));
509 BEAST_EXPECT(hash(Book(a1, a2, std::nullopt)) != hash(Book(a2, a3, std::nullopt)));
510 BEAST_EXPECT(hash(Book(a1, a2, std::nullopt)) != hash(Book(a2, a4, std::nullopt)));
511 BEAST_EXPECT(hash(Book(a1, a2, std::nullopt)) != hash(Book(a3, a4, std::nullopt)));
512
513 // Books with domain
514 BEAST_EXPECT(hash(Book(a1, a2, domain1)) == hash(Book(a1, a2, domain1)));
515 BEAST_EXPECT(hash(Book(a1, a3, domain1)) == hash(Book(a1, a3, domain1)));
516 BEAST_EXPECT(hash(Book(a1, a4, domain1)) == hash(Book(a1, a4, domain1)));
517 BEAST_EXPECT(hash(Book(a2, a3, domain1)) == hash(Book(a2, a3, domain1)));
518 BEAST_EXPECT(hash(Book(a2, a4, domain1)) == hash(Book(a2, a4, domain1)));
519 BEAST_EXPECT(hash(Book(a3, a4, domain1)) == hash(Book(a3, a4, domain1)));
520 BEAST_EXPECT(hash(Book(a1, a2, std::nullopt)) == hash(Book(a1, a2, std::nullopt)));
521
522 // Comparing Books with domain1 vs no domain
523 BEAST_EXPECT(hash(Book(a1, a2, std::nullopt)) != hash(Book(a1, a2, domain1)));
524 BEAST_EXPECT(hash(Book(a1, a3, std::nullopt)) != hash(Book(a1, a3, domain1)));
525 BEAST_EXPECT(hash(Book(a1, a4, std::nullopt)) != hash(Book(a1, a4, domain1)));
526 BEAST_EXPECT(hash(Book(a2, a3, std::nullopt)) != hash(Book(a2, a3, domain1)));
527 BEAST_EXPECT(hash(Book(a2, a4, std::nullopt)) != hash(Book(a2, a4, domain1)));
528 BEAST_EXPECT(hash(Book(a3, a4, std::nullopt)) != hash(Book(a3, a4, domain1)));
529
530 // Books with domain1 but different Issues
531 BEAST_EXPECT(hash(Book(a1, a2, domain1)) != hash(Book(a1, a3, domain1)));
532 BEAST_EXPECT(hash(Book(a1, a2, domain1)) != hash(Book(a1, a4, domain1)));
533 BEAST_EXPECT(hash(Book(a2, a3, domain1)) != hash(Book(a2, a4, domain1)));
534 BEAST_EXPECT(hash(Book(a1, a2, domain1)) != hash(Book(a2, a3, domain1)));
535 BEAST_EXPECT(hash(Book(a2, a4, domain1)) != hash(Book(a3, a4, domain1)));
536 BEAST_EXPECT(hash(Book(a3, a4, domain1)) != hash(Book(a1, a4, domain1)));
537
538 // Books with domain1 and domain2
539 BEAST_EXPECT(hash(Book(a1, a2, domain1)) != hash(Book(a1, a2, domain2)));
540 BEAST_EXPECT(hash(Book(a1, a3, domain1)) != hash(Book(a1, a3, domain2)));
541 BEAST_EXPECT(hash(Book(a1, a4, domain1)) != hash(Book(a1, a4, domain2)));
542 BEAST_EXPECT(hash(Book(a2, a3, domain1)) != hash(Book(a2, a3, domain2)));
543 BEAST_EXPECT(hash(Book(a2, a4, domain1)) != hash(Book(a2, a4, domain2)));
544 BEAST_EXPECT(hash(Book(a3, a4, domain1)) != hash(Book(a3, a4, domain2)));
545 }
546
547 //--------------------------------------------------------------------------
548
549 template <class Set>
550 void
551 testBookSet()
552 {
553 Currency const c1(1);
554 AccountID const i1(1);
555 Currency const c2(2);
556 AccountID const i2(2);
557 Issue const a1(c1, i1);
558 Issue const a2(c2, i2);
559 Book const b1(a1, a2, std::nullopt);
560 Book const b2(a2, a1, std::nullopt);
561
562 uint256 const domain1{1};
563 uint256 const domain2{2};
564
565 Book const b1_d1(a1, a2, domain1);
566 Book const b2_d1(a2, a1, domain1);
567 Book const b1_d2(a1, a2, domain2);
568 Book const b2_d2(a2, a1, domain2);
569
570 {
571 Set c;
572
573 c.insert(b1);
574 if (!BEAST_EXPECT(c.size() == 1))
575 return;
576 c.insert(b2);
577 if (!BEAST_EXPECT(c.size() == 2))
578 return;
579
580 if (!BEAST_EXPECT(c.erase(Book(a1, a1, std::nullopt)) == 0))
581 return;
582 if (!BEAST_EXPECT(c.erase(Book(a1, a2, std::nullopt)) == 1))
583 return;
584 if (!BEAST_EXPECT(c.erase(Book(a2, a1, std::nullopt)) == 1))
585 return;
586 if (!BEAST_EXPECT(c.empty()))
587 return;
588 }
589
590 {
591 Set c;
592
593 c.insert(b1);
594 if (!BEAST_EXPECT(c.size() == 1))
595 return;
596 c.insert(b2);
597 if (!BEAST_EXPECT(c.size() == 2))
598 return;
599
600 if (!BEAST_EXPECT(c.erase(Book(a1, a1, std::nullopt)) == 0))
601 return;
602 if (!BEAST_EXPECT(c.erase(Book(a1, a2, std::nullopt)) == 1))
603 return;
604 if (!BEAST_EXPECT(c.erase(Book(a2, a1, std::nullopt)) == 1))
605 return;
606 if (!BEAST_EXPECT(c.empty()))
607 return;
608
609#if STL_SET_HAS_EMPLACE
610 c.emplace(a1, a2);
611 if (!BEAST_EXPECT(c.size() == 1))
612 return;
613 c.emplace(a2, a1);
614 if (!BEAST_EXPECT(c.size() == 2))
615 return;
616#endif
617 }
618
619 {
620 Set c;
621
622 c.insert(b1_d1);
623 if (!BEAST_EXPECT(c.size() == 1))
624 return;
625 c.insert(b2_d1);
626 if (!BEAST_EXPECT(c.size() == 2))
627 return;
628 c.insert(b1_d2);
629 if (!BEAST_EXPECT(c.size() == 3))
630 return;
631 c.insert(b2_d2);
632 if (!BEAST_EXPECT(c.size() == 4))
633 return;
634
635 // Try removing non-existent elements
636 if (!BEAST_EXPECT(c.erase(Book(a2, a2, domain1)) == 0))
637 return;
638
639 if (!BEAST_EXPECT(c.erase(Book(a1, a2, domain1)) == 1))
640 return;
641 if (!BEAST_EXPECT(c.erase(Book(a2, a1, domain1)) == 1))
642 return;
643 if (!BEAST_EXPECT(c.size() == 2))
644 return;
645
646 if (!BEAST_EXPECT(c.erase(Book(a1, a2, domain2)) == 1))
647 return;
648 if (!BEAST_EXPECT(c.erase(Book(a2, a1, domain2)) == 1))
649 return;
650 if (!BEAST_EXPECT(c.empty()))
651 return;
652 }
653
654 {
655 Set c;
656
657 c.insert(b1);
658 c.insert(b2);
659 c.insert(b1_d1);
660 c.insert(b2_d1);
661 if (!BEAST_EXPECT(c.size() == 4))
662 return;
663
664 if (!BEAST_EXPECT(c.erase(Book(a1, a2, std::nullopt)) == 1))
665 return;
666 if (!BEAST_EXPECT(c.erase(Book(a2, a1, std::nullopt)) == 1))
667 return;
668 if (!BEAST_EXPECT(c.size() == 2))
669 return;
670
671 if (!BEAST_EXPECT(c.erase(Book(a1, a2, domain1)) == 1))
672 return;
673 if (!BEAST_EXPECT(c.erase(Book(a2, a1, domain1)) == 1))
674 return;
675 if (!BEAST_EXPECT(c.empty()))
676 return;
677 }
678 }
679
680 template <class Map>
681 void
682 testBookMap()
683 {
684 Currency const c1(1);
685 AccountID const i1(1);
686 Currency const c2(2);
687 AccountID const i2(2);
688 Issue const a1(c1, i1);
689 Issue const a2(c2, i2);
690 Book const b1(a1, a2, std::nullopt);
691 Book const b2(a2, a1, std::nullopt);
692
693 uint256 const domain1{1};
694 uint256 const domain2{2};
695
696 Book const b1_d1(a1, a2, domain1);
697 Book const b2_d1(a2, a1, domain1);
698 Book const b1_d2(a1, a2, domain2);
699 Book const b2_d2(a2, a1, domain2);
700
701 // typename Map::value_type value_type;
702 // std::pair <Book const, int> value_type;
703
704 {
705 Map c;
706
707 // c.insert (value_type (b1, 1));
708 c.insert(std::make_pair(b1, 1));
709 if (!BEAST_EXPECT(c.size() == 1))
710 return;
711 // c.insert (value_type (b2, 2));
712 c.insert(std::make_pair(b2, 1));
713 if (!BEAST_EXPECT(c.size() == 2))
714 return;
715
716 if (!BEAST_EXPECT(c.erase(Book(a1, a1, std::nullopt)) == 0))
717 return;
718 if (!BEAST_EXPECT(c.erase(Book(a1, a2, std::nullopt)) == 1))
719 return;
720 if (!BEAST_EXPECT(c.erase(Book(a2, a1, std::nullopt)) == 1))
721 return;
722 if (!BEAST_EXPECT(c.empty()))
723 return;
724 }
725
726 {
727 Map c;
728
729 // c.insert (value_type (b1, 1));
730 c.insert(std::make_pair(b1, 1));
731 if (!BEAST_EXPECT(c.size() == 1))
732 return;
733 // c.insert (value_type (b2, 2));
734 c.insert(std::make_pair(b2, 1));
735 if (!BEAST_EXPECT(c.size() == 2))
736 return;
737
738 if (!BEAST_EXPECT(c.erase(Book(a1, a1, std::nullopt)) == 0))
739 return;
740 if (!BEAST_EXPECT(c.erase(Book(a1, a2, std::nullopt)) == 1))
741 return;
742 if (!BEAST_EXPECT(c.erase(Book(a2, a1, std::nullopt)) == 1))
743 return;
744 if (!BEAST_EXPECT(c.empty()))
745 return;
746 }
747
748 {
749 Map c;
750
751 c.insert(std::make_pair(b1_d1, 10));
752 if (!BEAST_EXPECT(c.size() == 1))
753 return;
754 c.insert(std::make_pair(b2_d1, 20));
755 if (!BEAST_EXPECT(c.size() == 2))
756 return;
757 c.insert(std::make_pair(b1_d2, 30));
758 if (!BEAST_EXPECT(c.size() == 3))
759 return;
760 c.insert(std::make_pair(b2_d2, 40));
761 if (!BEAST_EXPECT(c.size() == 4))
762 return;
763
764 // Try removing non-existent elements
765 if (!BEAST_EXPECT(c.erase(Book(a2, a2, domain1)) == 0))
766 return;
767
768 if (!BEAST_EXPECT(c.erase(Book(a1, a2, domain1)) == 1))
769 return;
770 if (!BEAST_EXPECT(c.erase(Book(a2, a1, domain1)) == 1))
771 return;
772 if (!BEAST_EXPECT(c.size() == 2))
773 return;
774
775 if (!BEAST_EXPECT(c.erase(Book(a1, a2, domain2)) == 1))
776 return;
777 if (!BEAST_EXPECT(c.erase(Book(a2, a1, domain2)) == 1))
778 return;
779 if (!BEAST_EXPECT(c.empty()))
780 return;
781 }
782
783 {
784 Map c;
785
786 c.insert(std::make_pair(b1, 1));
787 c.insert(std::make_pair(b2, 2));
788 c.insert(std::make_pair(b1_d1, 3));
789 c.insert(std::make_pair(b2_d1, 4));
790 if (!BEAST_EXPECT(c.size() == 4))
791 return;
792
793 // Try removing non-existent elements
794 if (!BEAST_EXPECT(c.erase(Book(a1, a1, domain1)) == 0))
795 return;
796 if (!BEAST_EXPECT(c.erase(Book(a2, a2, domain2)) == 0))
797 return;
798
799 if (!BEAST_EXPECT(c.erase(Book(a1, a2, std::nullopt)) == 1))
800 return;
801 if (!BEAST_EXPECT(c.erase(Book(a2, a1, std::nullopt)) == 1))
802 return;
803 if (!BEAST_EXPECT(c.size() == 2))
804 return;
805
806 if (!BEAST_EXPECT(c.erase(Book(a1, a2, domain1)) == 1))
807 return;
808 if (!BEAST_EXPECT(c.erase(Book(a2, a1, domain1)) == 1))
809 return;
810 if (!BEAST_EXPECT(c.empty()))
811 return;
812 }
813 }
814
815 void
816 testBookSets()
817 {
818 testcase("std::set <Book>");
819 testBookSet<std::set<Book>>();
820
821 testcase("std::set <Book>");
822 testBookSet<std::set<Book>>();
823
824#if XRPL_ASSETS_ENABLE_STD_HASH
825 testcase("std::unordered_set <Book>");
826 testBookSet<std::unordered_set<Book>>();
827
828 testcase("std::unordered_set <Book>");
829 testBookSet<std::unordered_set<Book>>();
830#endif
831
832 testcase("hash_set <Book>");
833 testBookSet<hash_set<Book>>();
834
835 testcase("hash_set <Book>");
836 testBookSet<hash_set<Book>>();
837 }
838
839 void
840 testBookMaps()
841 {
842 testcase("std::map <Book, int>");
843 testBookMap<std::map<Book, int>>();
844
845 testcase("std::map <Book, int>");
846 testBookMap<std::map<Book, int>>();
847
848#if XRPL_ASSETS_ENABLE_STD_HASH
849 testcase("std::unordered_map <Book, int>");
850 testBookMap<std::unordered_map<Book, int>>();
851
852 testcase("std::unordered_map <Book, int>");
853 testBookMap<std::unordered_map<Book, int>>();
854
855 testcase("hash_map <Book, int>");
856 testBookMap<hash_map<Book, int>>();
857
858 testcase("hash_map <Book, int>");
859 testBookMap<hash_map<Book, int>>();
860#endif
861 }
862
863 //--------------------------------------------------------------------------
864
865 void
866 run() override
867 {
868 testcase("Currency");
869 testUnsigned<Currency>();
870
871 testcase("AccountID");
872 testUnsigned<AccountID>();
873
874 // ---
875
876 testcase("Issue");
877 testIssue<Issue>();
878
879 testcase("Issue");
880 testIssue<Issue>();
881
882 testIssueSets();
883 testIssueMaps();
884
885 // ---
886
887 testcase("Book");
888 testBook<Book>();
889
890 testcase("Book");
891 testBook<Book>();
892
893 testBookSets();
894 testBookMaps();
895
896 // ---
897 testIssueDomainSets();
898 testIssueDomainMaps();
899 }
900};
901
902BEAST_DEFINE_TESTSUITE(Issue, protocol, xrpl);
903
904} // namespace xrpl
beast::unit_test::suite
A testsuite class.
Definition suite.h:51
beast::unit_test::suite::testcase
testcase_t testcase
Memberspace for declaring test cases.
Definition suite.h:147
xrpl::Book
Specifies an order book.
Definition Book.h:16
xrpl::Issue_test
Definition Issue_test.cpp:23
xrpl::Issue_test::testBook
void testBook()
Definition Issue_test.cpp:388
xrpl::Issue_test::run
void run() override
Runs the suite.
Definition Issue_test.cpp:866
xrpl::Issue_test::testIssueDomainMaps
void testIssueDomainMaps()
Definition Issue_test.cpp:311
xrpl::Issue_test::testIssueDomainMap
void testIssueDomainMap()
Definition Issue_test.cpp:259
xrpl::Issue_test::testUnsigned
void testUnsigned()
Definition Issue_test.cpp:30
xrpl::Issue_test::testIssueDomainSet
void testIssueDomainSet()
Definition Issue_test.cpp:222
xrpl::Issue_test::testIssueDomainSets
void testIssueDomainSets()
Definition Issue_test.cpp:295
xrpl::Issue_test::testBookMaps
void testBookMaps()
Definition Issue_test.cpp:840
xrpl::Issue_test::testIssueMaps
void testIssueMaps()
Definition Issue_test.cpp:359
xrpl::Issue_test::testBookSet
void testBookSet()
Definition Issue_test.cpp:551
xrpl::Issue_test::testIssueMap
void testIssueMap()
Definition Issue_test.cpp:170
xrpl::Issue_test::testBookMap
void testBookMap()
Definition Issue_test.cpp:682
xrpl::Issue_test::testIssueSet
void testIssueSet()
Definition Issue_test.cpp:109
xrpl::Issue_test::testIssueSets
void testIssueSets()
Definition Issue_test.cpp:335
xrpl::Issue_test::testBookSets
void testBookSets()
Definition Issue_test.cpp:816
xrpl::Issue_test::testIssue
void testIssue()
Definition Issue_test.cpp:60
xrpl::Issue
A currency issued by an account.
Definition Issue.h:13
xrpl::base_uint< 256 >
std::is_same_v
T is_same_v
std::make_pair
T make_pair(T... args)
xrpl
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
xrpl::uint256
base_uint< 256 > uint256
Definition base_uint.h:526
Generated by doxygen 1.9.8