xrpld
Loading...
Searching...
No Matches
MultiApiJson_test.cpp
1#include <xrpl/beast/unit_test/suite.h>
2#include <xrpl/json/json_value.h>
3#include <xrpl/protocol/ApiVersion.h>
4#include <xrpl/protocol/MultiApiJson.h>
5
6#include <array>
7#include <iterator>
8#include <limits>
9#include <optional>
10#include <type_traits>
11#include <utility>
12
13namespace xrpl::test {
14
15namespace {
16
17// This needs to be in a namespace because of deduction guide
18template <typename... Ts>
19struct Overload : Ts...
20{
21 using Ts::operator()...;
22};
23template <typename... Ts>
24Overload(Ts...) -> Overload<Ts...>;
25
26} // namespace
27
29{
30 static auto
31 makeJson(char const* key, int val)
32 {
34 obj1[key] = val;
35 return obj1;
36 }
37
38 void
39 run() override
40 {
42
43 json::Value const obj1 = makeJson("value", 1);
44 json::Value const obj2 = makeJson("value", 2);
45 json::Value const obj3 = makeJson("value", 3);
46 json::Value const jsonNull{};
47
48 MultiApiJson<1, 3> subject{};
49 static_assert(sizeof(subject) == sizeof(subject.val));
50 static_assert(subject.kSize == subject.val.size());
51 static_assert(std::is_same_v<decltype(subject.val), std::array<json::Value, 3>>);
52
53 BEAST_EXPECT(subject.val.size() == 3);
54 BEAST_EXPECT((subject.val == std::array<json::Value, 3>{jsonNull, jsonNull, jsonNull}));
55
56 subject.val[0] = obj1;
57 subject.val[1] = obj2;
58
59 {
60 testcase("forApiVersions, forAllApiVersions");
61
62 // Some static data for test inputs
63 static int const kPrimes[] = {
64 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
65 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
66 };
67 static_assert(std::size(kPrimes) > rpc::kApiMaximumValidVersion);
68
70 static_assert(
72
73 int productAllVersions = 1;
75 ++i)
76 {
77 auto const index = i - rpc::kApiMinimumSupportedVersion;
78 BEAST_EXPECT(index == s1.index(i));
79 BEAST_EXPECT(s1.valid(i));
80 s1.val[index] = makeJson("value", kPrimes[i]);
81 productAllVersions *= kPrimes[i];
82 }
83 BEAST_EXPECT(!s1.valid(0));
84 BEAST_EXPECT(!s1.valid(rpc::kApiMaximumValidVersion + 1));
85 BEAST_EXPECT(!s1.valid(
86 std::numeric_limits<decltype(rpc::kApiMaximumValidVersion.value)>::max()));
87
88 int result = 1;
91 std::as_const(s1).visit(),
92 [this](json::Value const& json, unsigned int version, int* result) {
93 BEAST_EXPECT(
96 if (BEAST_EXPECT(json.isMember("value")))
97 {
98 *result *= json["value"].asInt();
99 }
100 },
101 &result);
102 BEAST_EXPECT(
103 result ==
106
107 // Check all the values with mutable data
108 forAllApiVersions(s1.visit(), [&s1, this](json::Value& json, auto version) {
109 BEAST_EXPECT(s1.val[s1.index(version)] == json);
110 if (BEAST_EXPECT(json.isMember("value")))
111 {
112 BEAST_EXPECT(json["value"].asInt() == kPrimes[version]);
113 }
114 });
115
116 result = 1;
118 std::as_const(s1).visit(),
119 [this](json::Value const& json, unsigned int version, int* result) {
120 BEAST_EXPECT(
123 if (BEAST_EXPECT(json.isMember("value")))
124 {
125 *result *= json["value"].asInt();
126 }
127 },
128 &result);
129
130 BEAST_EXPECT(result == productAllVersions);
131
132 // Several overloads we want to fail
133 static_assert([](auto&& v) {
134 return !requires {
136 std::forward<decltype(v)>(v).visit(), //
137 [](json::Value&, auto) {}); // missing const
138 };
139 }(std::as_const(s1)));
140 static_assert([](auto&& v) {
141 return !requires {
143 std::forward<decltype(v)>(v).visit(), //
144 [](json::Value&) {}); // missing const
145 };
146 }(std::as_const(s1)));
147 static_assert([](auto&& v) {
148 return !requires {
150 std::forward<decltype(v)>(v).visit(), //
151 [] {}); // missing parameters
152 };
153 }(std::as_const(s1)));
154 static_assert([](auto&& v) {
155 return !requires {
157 std::forward<decltype(v)>(v).visit(), //
158 [](auto) {},
159 1); // missing parameters
160 };
161 }(std::as_const(s1)));
162 static_assert([](auto&& v) {
163 return !requires {
165 std::forward<decltype(v)>(v).visit(), //
166 [](auto, auto) {},
167 1); // missing parameters
168 };
169 }(std::as_const(s1)));
170 static_assert([](auto&& v) {
171 return !requires {
173 std::forward<decltype(v)>(v).visit(), //
174 [](auto, auto, char const*) {},
175 1); // parameter type mismatch
176 };
177 }(std::as_const(s1)));
178
179 // Sanity checks
180 static_assert([](auto&& v) {
181 return requires {
183 std::forward<decltype(v)>(v).visit(), //
184 [](auto) {});
185 };
186 }(s1));
187 static_assert([](auto&& v) {
188 return requires {
190 std::forward<decltype(v)>(v).visit(), //
191 [](json::Value const&) {});
192 };
193 }(std::as_const(s1)));
194 static_assert([](auto&& v) {
195 return requires {
197 std::forward<decltype(v)>(v).visit(), //
198 [](auto...) {});
199 };
200 }(s1));
201 static_assert([](auto&& v) {
202 return requires {
204 std::forward<decltype(v)>(v).visit(), //
205 [](json::Value const&, auto...) {});
206 };
207 }(std::as_const(s1)));
208 static_assert([](auto&& v) {
209 return requires {
211 std::forward<decltype(v)>(v).visit(), //
212 [](json::Value&, auto, auto, auto...) {},
213 0,
214 "");
215 };
216 }(s1));
217 static_assert([](auto&& v) {
218 return requires {
220 std::forward<decltype(v)>(v).visit(), //
221 []<unsigned int Version>(
222 json::Value const&,
224 int,
225 char const*) {},
226 0,
227 "");
228 };
229 }(std::as_const(s1)));
230 static_assert([](auto&& v) {
231 return requires {
233 std::forward<decltype(v)>(v).visit(), //
234 [](auto...) {});
235 };
236 }(std::move(s1)));
237 static_assert([](auto&& v) {
238 return requires {
240 std::forward<decltype(v)>(v).visit(), //
241 [](auto...) {});
242 };
243 }(std::move(std::as_const(s1)))); // NOLINT(performance-move-const-arg)
244 }
245
246 {
247 testcase("default copy construction / assignment");
248
249 MultiApiJson<1, 3> x{subject};
250
251 BEAST_EXPECT(x.val.size() == subject.val.size());
252 BEAST_EXPECT(x.val[0] == subject.val[0]);
253 BEAST_EXPECT(x.val[1] == subject.val[1]);
254 BEAST_EXPECT(x.val[2] == subject.val[2]);
255 BEAST_EXPECT(x.val == subject.val);
256 BEAST_EXPECT(&x.val[0] != &subject.val[0]);
257 BEAST_EXPECT(&x.val[1] != &subject.val[1]);
258 BEAST_EXPECT(&x.val[2] != &subject.val[2]);
259
261 BEAST_EXPECT((y.val == std::array<json::Value, 3>{}));
262 y = subject;
263 BEAST_EXPECT(y.val == subject.val);
264 BEAST_EXPECT(&y.val[0] != &subject.val[0]);
265 BEAST_EXPECT(&y.val[1] != &subject.val[1]);
266 BEAST_EXPECT(&y.val[2] != &subject.val[2]);
267
268 y = std::move(x);
269 BEAST_EXPECT(y.val == subject.val);
270 BEAST_EXPECT(&y.val[0] != &subject.val[0]);
271 BEAST_EXPECT(&y.val[1] != &subject.val[1]);
272 BEAST_EXPECT(&y.val[2] != &subject.val[2]);
273 }
274
275 {
276 testcase("set");
277
279 x.set("name1", 42);
280 BEAST_EXPECT(x.val[0].isMember("name1"));
281 BEAST_EXPECT(x.val[1].isMember("name1"));
282 BEAST_EXPECT(x.val[0]["name1"].isInt());
283 BEAST_EXPECT(x.val[1]["name1"].isInt());
284 BEAST_EXPECT(x.val[0]["name1"].asInt() == 42);
285 BEAST_EXPECT(x.val[1]["name1"].asInt() == 42);
286
287 x.set("name2", "bar");
288 BEAST_EXPECT(x.val[0].isMember("name2"));
289 BEAST_EXPECT(x.val[1].isMember("name2"));
290 BEAST_EXPECT(x.val[0]["name2"].isString());
291 BEAST_EXPECT(x.val[1]["name2"].isString());
292 BEAST_EXPECT(x.val[0]["name2"].asString() == "bar");
293 BEAST_EXPECT(x.val[1]["name2"].asString() == "bar");
294
295 // Tests of requires clause - these are expected to match
296 static_assert(
297 [](auto&& v) { return requires { v.set("name", json::ValueType::Null); }; }(x));
298 static_assert([](auto&& v) { return requires { v.set("name", "value"); }; }(x));
299 static_assert([](auto&& v) { return requires { v.set("name", true); }; }(x));
300 static_assert([](auto&& v) { return requires { v.set("name", 42); }; }(x));
301
302 // Tests of requires clause - these are expected NOT to match
303 struct FooT final
304 {
305 };
306 static_assert([](auto&& v) { return !requires { v.set("name", FooT{}); }; }(x));
307 static_assert([](auto&& v) { return !requires { v.set("name", std::nullopt); }; }(x));
308 }
309
310 {
311 testcase("isMember");
312
313 // Well defined behaviour even if we have different types of members
314 BEAST_EXPECT(subject.isMember("foo") == decltype(subject)::IsMemberResult::None);
315
316 {
317 // All variants have element "One", none have element "Two"
319 s1.val[0] = makeJson("One", 12);
320 s1.val[1] = makeJson("One", 42);
321 BEAST_EXPECT(s1.isMember("One") == decltype(s1)::IsMemberResult::All);
322 BEAST_EXPECT(s1.isMember("Two") == decltype(s1)::IsMemberResult::None);
323 }
324
325 {
326 // Some variants have element "One" and some have "Two"
328 s2.val[0] = makeJson("One", 12);
329 s2.val[1] = makeJson("Two", 42);
330 BEAST_EXPECT(s2.isMember("One") == decltype(s2)::IsMemberResult::Some);
331 BEAST_EXPECT(s2.isMember("Two") == decltype(s2)::IsMemberResult::Some);
332 }
333
334 {
335 // Not all variants have element "One", because last one is null
337 s3.val[0] = makeJson("One", 12);
338 s3.val[1] = makeJson("One", 42);
339 BEAST_EXPECT(s3.isMember("One") == decltype(s3)::IsMemberResult::Some);
340 BEAST_EXPECT(s3.isMember("Two") == decltype(s3)::IsMemberResult::None);
341 }
342 }
343
344 {
345 testcase("visitor");
346
348 s1.val[0] = makeJson("value", 2);
349 s1.val[1] = makeJson("value", 3);
350 s1.val[2] = makeJson("value", 5);
351
352 BEAST_EXPECT(not s1.valid(0));
353 BEAST_EXPECT(s1.index(0) == 0);
354
355 BEAST_EXPECT(s1.valid(1));
356 BEAST_EXPECT(s1.index(1) == 0);
357
358 BEAST_EXPECT(not s1.valid(4));
359
360 // Test different overloads
361 static_assert([](auto&& v) {
362 return requires {
363 v.kVisitor(
364 v,
365 std::integral_constant<unsigned, 1>{},
366 [](json::Value&, std::integral_constant<unsigned, 1>) {});
367 };
368 }(s1));
369 BEAST_EXPECT(
370 s1.kVisitor(
371 s1,
372 std::integral_constant<unsigned, 1>{},
373 Overload{
374 [](json::Value& v, std::integral_constant<unsigned, 1>) {
375 return v["value"].asInt();
376 },
377 [](json::Value const&, auto) { return 0; },
378 [](auto, auto) { return 0; }}) == 2);
379
380 static_assert([](auto&& v) {
381 return requires {
382 v.kVisitor(v, std::integral_constant<unsigned, 1>{}, [](json::Value&) {});
383 };
384 }(s1));
385 BEAST_EXPECT(
386 s1.kVisitor(
387 s1,
388 std::integral_constant<unsigned, 1>{},
389 Overload{
390 [](json::Value& v) { return v["value"].asInt(); },
391 [](json::Value const&) { return 0; },
392 [](auto...) { return 0; }}) == 2);
393
394 static_assert([](auto&& v) {
395 return requires {
396 v.kVisitor(
397 v,
398 std::integral_constant<unsigned, 1>{},
399 [](json::Value const&, std::integral_constant<unsigned, 1>) {});
400 };
401 }(std::as_const(s1)));
402 BEAST_EXPECT(
403 s1.kVisitor(
404 std::as_const(s1),
405 std::integral_constant<unsigned, 2>{},
406 Overload{
407 [](json::Value const& v, std::integral_constant<unsigned, 2>) {
408 return v["value"].asInt();
409 },
410 [](json::Value&, auto) { return 0; },
411 [](auto, auto) { return 0; }}) == 3);
412
413 static_assert([](auto&& v) {
414 return requires {
415 v.kVisitor(v, std::integral_constant<unsigned, 1>{}, [](json::Value const&) {});
416 };
417 }(std::as_const(s1)));
418 BEAST_EXPECT(
419 s1.kVisitor(
420 std::as_const(s1),
422 Overload{
423 [](json::Value const& v) { return v["value"].asInt(); },
424 [](json::Value&) { return 0; },
425 [](auto...) { return 0; }}) == 3);
426
427 static_assert([](auto&& v) {
428 return requires { v.kVisitor(v, 1, [](json::Value&, unsigned) {}); };
429 }(s1));
430 BEAST_EXPECT(
431 s1.kVisitor(
432 s1, //
433 3u,
434 Overload{
435 [](json::Value& v, unsigned) { return v["value"].asInt(); },
436 [](json::Value const&, unsigned) { return 0; },
437 [](auto, auto) { return 0; }}) == 5);
438
439 static_assert(
440 [](auto&& v) { return requires { v.kVisitor(v, 1, [](json::Value&) {}); }; }(s1));
441 BEAST_EXPECT(
442 s1.kVisitor(
443 s1, //
444 3,
445 Overload{
446 [](json::Value& v) { return v["value"].asInt(); },
447 [](json::Value const&) { return 0; },
448 [](auto...) { return 0; }}) == 5);
449
450 static_assert([](auto&& v) {
451 return requires { v.kVisitor(v, 1, [](json::Value const&, unsigned) {}); };
452 }(std::as_const(s1)));
453 BEAST_EXPECT(
454 s1.kVisitor(
455 std::as_const(s1), //
456 2u,
457 Overload{
458 [](json::Value const& v, unsigned) { return v["value"].asInt(); },
459 [](json::Value const&, auto) { return 0; },
460 [](auto, auto) { return 0; }}) == 3);
461
462 static_assert([](auto&& v) {
463 return requires { v.kVisitor(v, 1, [](json::Value const&) {}); };
464 }(std::as_const(s1)));
465 BEAST_EXPECT(
466 s1.kVisitor(
467 std::as_const(s1), //
468 2,
469 Overload{
470 [](json::Value const& v) { return v["value"].asInt(); },
471 [](json::Value&) { return 0; },
472 [](auto...) { return 0; }}) == 3);
473
474 // Test type conversions
475 BEAST_EXPECT(
476 s1.kVisitor(
477 s1,
479 [](json::Value& v, unsigned) { return v["value"].asInt(); }) == 2);
480 BEAST_EXPECT(
481 s1.kVisitor(
482 std::as_const(s1),
484 [](json::Value const& v, unsigned) { return v["value"].asInt(); }) == 3);
485 BEAST_EXPECT(
486 s1.kVisitor(
487 s1, // to const
489 [](json::Value const& v, auto) { return v["value"].asInt(); }) == 5);
490 BEAST_EXPECT(
491 s1.kVisitor(
492 s1, // to const
494 [](json::Value const& v) { return v["value"].asInt(); }) == 5);
495 BEAST_EXPECT(
496 s1.kVisitor(
497 s1,
498 3, // to long
499 [](json::Value& v, long) { return v["value"].asInt(); }) == 5);
500 BEAST_EXPECT(
501 s1.kVisitor(
502 std::as_const(s1),
503 1, // to long
504 [](json::Value const& v, long) { return v["value"].asInt(); }) == 2);
505 BEAST_EXPECT(
506 s1.kVisitor(
507 s1, // to const
508 2,
509 [](json::Value const& v, auto) { return v["value"].asInt(); }) == 3);
510 BEAST_EXPECT(
511 s1.kVisitor(
512 s1, // type deduction
513 2,
514 [](auto& v, auto) { return v["value"].asInt(); }) == 3);
515 BEAST_EXPECT(
516 s1.kVisitor(
517 s1, // to const, type deduction
518 2,
519 [](auto const& v, auto) { return v["value"].asInt(); }) == 3);
520 BEAST_EXPECT(
521 s1.kVisitor(
522 s1, // type deduction
523 2,
524 [](auto& v) { return v["value"].asInt(); }) == 3);
525 BEAST_EXPECT(
526 s1.kVisitor(
527 s1, // to const, type deduction
528 2,
529 [](auto const& v) { return v["value"].asInt(); }) == 3);
530
531 // Test passing of additional arguments
532 BEAST_EXPECT(
533 s1.kVisitor(
534 s1,
536 [](json::Value& v, auto ver, auto a1, auto a2) {
537 return ver * a1 * a2 * v["value"].asInt();
538 },
539 5,
540 7) == 2 * 5 * 7 * 3);
541 BEAST_EXPECT(
542 s1.kVisitor(
543 s1,
545 [](json::Value& v, auto ver, auto... args) {
546 return ver * (1 * ... * args) * v["value"].asInt();
547 },
548 5,
549 7) == 2 * 5 * 7 * 3);
550
551 // Several overloads we want to fail
552 static_assert([](auto&& v) {
553 return !requires {
554 v.kVisitor(
555 v,
556 1, //
557 [](json::Value&, auto) {}); // missing const
558 };
559 }(std::as_const(s1)));
560
561 static_assert([](auto&& v) {
562 return !requires {
563 v.kVisitor(
564 decltype(v){}, // cannot bind rvalue
565 1,
566 [](json::Value&, auto) {});
567 };
568 }(s1));
569
570 static_assert([](auto&& v) {
571 return !requires {
572 v.kVisitor(
573 v,
574 1, //
575 [] {}); // missing parameter
576 };
577 }(s1));
578
579 static_assert([](auto&& v) {
580 return !requires {
581 v.kVisitor(
582 v,
583 1, //
584 [](json::Value&, int, int) {}); // too many parameters
585 };
586 }(s1));
587
588 // Want these to be unambiguous
589 static_assert([](auto&& v) { return requires { v.kVisitor(v, 1, [](auto) {}); }; }(s1));
590
591 static_assert(
592 [](auto&& v) { return requires { v.kVisitor(v, 1, [](json::Value&) {}); }; }(s1));
593
594 static_assert([](auto&& v) {
595 return requires { v.kVisitor(v, 1, [](json::Value&, auto...) {}); };
596 }(s1));
597
598 static_assert([](auto&& v) {
599 return requires { v.kVisitor(v, 1, [](json::Value const&) {}); };
600 }(s1));
601
602 static_assert([](auto&& v) {
603 return requires { v.kVisitor(v, 1, [](json::Value const&, auto...) {}); };
604 }(s1));
605
606 static_assert(
607 [](auto&& v) { return requires { v.kVisitor(v, 1, [](auto...) {}); }; }(s1));
608
609 static_assert(
610 [](auto&& v) { return requires { v.kVisitor(v, 1, [](auto, auto...) {}); }; }(s1));
611
612 static_assert([](auto&& v) {
613 return requires { v.kVisitor(v, 1, [](auto, auto, auto...) {}); };
614 }(s1));
615
616 static_assert([](auto&& v) {
617 return requires { v.kVisitor(v, 1, [](auto, auto, auto...) {}, ""); };
618 }(s1));
619
620 static_assert([](auto&& v) {
621 return requires { v.kVisitor(v, 1, [](auto, auto, auto, auto...) {}, ""); };
622 }(s1));
623 }
624
625 {
626 testcase("visit");
627
628 MultiApiJson<1, 3> s1{};
629 s1.val[0] = makeJson("value", 2);
630 s1.val[1] = makeJson("value", 3);
631 s1.val[2] = makeJson("value", 5);
632
633 // Test different overloads
634 static_assert([](auto&& v) {
635 return requires {
636 v.visit(
639 };
640 }(s1));
641 BEAST_EXPECT(
642 s1.visit(
644 Overload{
645 [](json::Value& v, std::integral_constant<unsigned, 1>) {
646 return v["value"].asInt();
647 },
648 [](json::Value const&, auto) { return 0; },
649 [](auto, auto) { return 0; }}) == 2);
650 static_assert([](auto&& v) {
651 return requires {
652 v.visit()(
655 };
656 }(s1));
657 BEAST_EXPECT(
658 s1.visit()(
660 Overload{
661 [](json::Value& v, std::integral_constant<unsigned, 1>) {
662 return v["value"].asInt();
663 },
664 [](json::Value const&, auto) { return 0; },
665 [](auto, auto) { return 0; }}) == 2);
666
667 static_assert([](auto&& v) {
668 return requires {
670 };
671 }(s1));
672 BEAST_EXPECT(
673 s1.visit(
675 Overload{
676 [](json::Value& v) { return v["value"].asInt(); },
677 [](json::Value const&) { return 0; },
678 [](auto...) { return 0; }}) == 2);
679 static_assert([](auto&& v) {
680 return requires {
682 };
683 }(s1));
684 BEAST_EXPECT(
685 s1.visit()(
687 Overload{
688 [](json::Value& v) { return v["value"].asInt(); },
689 [](json::Value const&) { return 0; },
690 [](auto...) { return 0; }}) == 2);
691
692 static_assert([](auto&& v) {
693 return requires {
694 v.visit(
697 };
698 }(std::as_const(s1)));
699 BEAST_EXPECT(
702 Overload{
704 return v["value"].asInt();
705 },
706 [](json::Value&, auto) { return 0; },
707 [](auto, auto) { return 0; }}) == 3);
708 static_assert([](auto&& v) {
709 return requires {
710 v.visit()(
713 };
714 }(std::as_const(s1)));
715 BEAST_EXPECT(
716 std::as_const(s1).visit()(
718 Overload{
720 return v["value"].asInt();
721 },
722 [](json::Value&, auto) { return 0; },
723 [](auto, auto) { return 0; }}) == 3);
724
725 static_assert([](auto&& v) {
726 return requires {
727 v.visit(std::integral_constant<unsigned, 1>{}, [](json::Value const&) {});
728 };
729 }(std::as_const(s1)));
730 BEAST_EXPECT(
733 Overload{
734 [](json::Value const& v) { return v["value"].asInt(); },
735 [](json::Value&) { return 0; },
736 [](auto...) { return 0; }}) == 3);
737 static_assert([](auto&& v) {
738 return requires {
739 v.visit()(std::integral_constant<unsigned, 1>{}, [](json::Value const&) {});
740 };
741 }(std::as_const(s1)));
742 BEAST_EXPECT(
743 std::as_const(s1).visit()(
745 Overload{
746 [](json::Value const& v) { return v["value"].asInt(); },
747 [](json::Value&) { return 0; },
748 [](auto...) { return 0; }}) == 3);
749
750 static_assert([](auto&& v) {
751 return requires { v.visit(1, [](json::Value&, unsigned) {}); };
752 }(s1));
753 BEAST_EXPECT(
754 s1.visit(
755 3u,
756 Overload{
757 [](json::Value& v, unsigned) { return v["value"].asInt(); },
758 [](json::Value const&, unsigned) { return 0; },
759 [](json::Value&, auto) { return 0; },
760 [](auto, auto) { return 0; }}) == 5);
761 static_assert([](auto&& v) {
762 return requires { v.visit()(1, [](json::Value&, unsigned) {}); };
763 }(s1));
764 BEAST_EXPECT(
765 s1.visit()(
766 3u,
767 Overload{
768 [](json::Value& v, unsigned) { return v["value"].asInt(); },
769 [](json::Value const&, unsigned) { return 0; },
770 [](json::Value&, auto) { return 0; },
771 [](auto, auto) { return 0; }}) == 5);
772
773 static_assert(
774 [](auto&& v) { return requires { v.visit(1, [](json::Value&) {}); }; }(s1));
775 BEAST_EXPECT(
776 s1.visit(
777 3,
778 Overload{
779 [](json::Value& v) { return v["value"].asInt(); },
780 [](json::Value const&) { return 0; },
781 [](auto...) { return 0; }}) == 5);
782 static_assert(
783 [](auto&& v) { return requires { v.visit()(1, [](json::Value&) {}); }; }(s1));
784 BEAST_EXPECT(
785 s1.visit()(
786 3,
787 Overload{
788 [](json::Value& v) { return v["value"].asInt(); },
789 [](json::Value const&) { return 0; },
790 [](auto...) { return 0; }}) == 5);
791
792 static_assert([](auto&& v) {
793 return requires { v.visit(1, [](json::Value const&, unsigned) {}); };
794 }(std::as_const(s1)));
795 BEAST_EXPECT(
797 2u,
798 Overload{
799 [](json::Value const& v, unsigned) { return v["value"].asInt(); },
800 [](json::Value const&, auto) { return 0; },
801 [](json::Value&, unsigned) { return 0; },
802 [](auto, auto) { return 0; }}) == 3);
803 static_assert([](auto&& v) {
804 return requires { v.visit()(1, [](json::Value const&, unsigned) {}); };
805 }(std::as_const(s1)));
806 BEAST_EXPECT(
807 std::as_const(s1).visit()(
808 2u,
809 Overload{
810 [](json::Value const& v, unsigned) { return v["value"].asInt(); },
811 [](json::Value const&, auto) { return 0; },
812 [](json::Value&, unsigned) { return 0; },
813 [](auto, auto) { return 0; }}) == 3);
814
815 static_assert([](auto&& v) {
816 return requires { v.visit(1, [](json::Value const&) {}); };
817 }(std::as_const(s1)));
818 BEAST_EXPECT(
820 2,
821 Overload{
822 [](json::Value const& v) { return v["value"].asInt(); },
823 [](json::Value&) { return 0; },
824 [](auto...) { return 0; }}) == 3);
825 static_assert([](auto&& v) {
826 return requires { v.visit()(1, [](json::Value const&) {}); };
827 }(std::as_const(s1)));
828 BEAST_EXPECT(
829 std::as_const(s1).visit()(
830 2,
831 Overload{
832 [](json::Value const& v) { return v["value"].asInt(); },
833 [](json::Value&) { return 0; },
834 [](auto...) { return 0; }}) == 3);
835
836 // Rvalue MultivarJson visitor only binds to regular reference
837 static_assert([](auto&& v) {
838 // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
839 return !requires { std::forward<decltype(v)>(v).visit(1, [](json::Value&&) {}); };
840 }(std::move(s1)));
841 static_assert([](auto&& v) {
842 return !requires {
843 std::forward<decltype(v)>(v).visit(1, [](json::Value const&&) {});
844 };
845 }(std::move(s1)));
846 static_assert([](auto&& v) {
847 return requires { std::forward<decltype(v)>(v).visit(1, [](json::Value&) {}); };
848 }(std::move(s1)));
849 static_assert([](auto&& v) {
850 return requires {
851 std::forward<decltype(v)>(v).visit(1, [](json::Value const&) {});
852 };
853 }(std::move(s1)));
854 static_assert([](auto&& v) {
855 // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
856 return !requires { std::forward<decltype(v)>(v).visit()(1, [](json::Value&&) {}); };
857 }(std::move(s1)));
858 static_assert([](auto&& v) {
859 return !requires {
860 std::forward<decltype(v)>(v).visit()(1, [](json::Value const&&) {});
861 };
862 }(std::move(s1)));
863 static_assert([](auto&& v) {
864 return requires { std::forward<decltype(v)>(v).visit()(1, [](json::Value&) {}); };
865 }(std::move(s1)));
866 static_assert([](auto&& v) {
867 return requires {
868 std::forward<decltype(v)>(v).visit()(1, [](json::Value const&) {});
869 };
870 }(std::move(s1)));
871 static_assert([](auto&& v) {
872 return !requires {
873 std::forward<decltype(v)>(v).visit(1, [](json::Value const&&) {});
874 };
875 }(std::move(std::as_const(s1)))); // NOLINT(performance-move-const-arg)
876 static_assert([](auto&& v) {
877 return requires {
878 std::forward<decltype(v)>(v).visit(1, [](json::Value const&) {});
879 };
880 }(std::move(std::as_const(s1)))); // NOLINT(performance-move-const-arg)
881 static_assert([](auto&& v) {
882 return !requires {
883 std::forward<decltype(v)>(v).visit()(1, [](json::Value const&&) {});
884 };
885 }(std::move(std::as_const(s1)))); // NOLINT(performance-move-const-arg)
886 static_assert([](auto&& v) {
887 return requires {
888 std::forward<decltype(v)>(v).visit()(1, [](json::Value const&) {});
889 };
890 }(std::move(std::as_const(s1)))); // NOLINT(performance-move-const-arg)
891
892 // Missing const
893 static_assert([](auto&& v) {
894 return !requires {
895 std::forward<decltype(v)>(v).visit(1, [](json::Value&, auto) {});
896 };
897 }(std::as_const(s1)));
898 static_assert([](auto&& v) {
899 return !requires {
900 std::forward<decltype(v)>(v).visit()(1, [](json::Value&, auto) {});
901 };
902 }(std::as_const(s1)));
903
904 // Missing parameter
905 static_assert([](auto&& v) {
906 return !requires { std::forward<decltype(v)>(v).visit(1, [] {}); };
907 }(s1));
908 static_assert([](auto&& v) {
909 return !requires { std::forward<decltype(v)>(v).visit()(1, [] {}); };
910 }(s1));
911
912 // Sanity checks
913 static_assert([](auto&& v) {
914 return requires { std::forward<decltype(v)>(v).visit(1, [](auto...) {}); };
915 }(std::as_const(s1)));
916 static_assert([](auto&& v) {
917 return requires { std::forward<decltype(v)>(v).visit()(1, [](auto...) {}); };
918 }(std::as_const(s1)));
919 }
920 }
921};
922
924
925} // namespace xrpl::test
T as_const(T... args)
A testsuite class.
Definition suite.h:52
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
UInt size() const
Number of values in array or object.
Int asInt() const
T forward(T... args)
T is_same_v
JSON (JavaScript Object Notation).
Definition json_errors.h:5
@ Object
object value (collection of name/value pairs).
Definition json_value.h:33
@ Null
'null' value
Definition json_value.h:26
static constexpr auto kApiMaximumValidVersion
Definition ApiVersion.h:37
static constexpr auto kApiMinimumSupportedVersion
Definition ApiVersion.h:32
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
void forAllApiVersions(Fn const &fn, Args &&... args)
Definition ApiVersion.h:159
void forApiVersions(Fn const &fn, Args &&... args)
Definition ApiVersion.h:138
detail::MultiApiJson< rpc::kApiMinimumSupportedVersion, rpc::kApiMaximumValidVersion > MultiApiJson
T size(T... args)
void set(char const *key, auto const &v)
std::array< json::Value, kSize > val
static constexpr auto valid(unsigned int v) noexcept -> bool
static constexpr auto index(unsigned int v) noexcept -> std::size_t
static constexpr std::size_t kSize
static auto makeJson(char const *key, int val)
void run() override
Runs the suite.
T visit(T... args)