49 static_assert(
sizeof(subject) ==
sizeof(subject.
val));
53 BEAST_EXPECT(subject.
val.
size() == 3);
56 subject.
val[0] = obj1;
57 subject.
val[1] = obj2;
60 testcase(
"forApiVersions, forAllApiVersions");
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,
73 int productAllVersions = 1;
78 BEAST_EXPECT(index == s1.
index(i));
79 BEAST_EXPECT(s1.
valid(i));
81 productAllVersions *= kPrimes[i];
83 BEAST_EXPECT(!s1.
valid(0));
85 BEAST_EXPECT(!s1.
valid(
96 if (BEAST_EXPECT(
json.isMember(
"value")))
98 *result *=
json[
"value"].asInt();
109 BEAST_EXPECT(s1.val[s1.index(version)] == json);
110 if (BEAST_EXPECT(json.isMember(
"value")))
112 BEAST_EXPECT(json[
"value"].asInt() == kPrimes[version]);
123 if (BEAST_EXPECT(
json.isMember(
"value")))
125 *result *=
json[
"value"].asInt();
130 BEAST_EXPECT(result == productAllVersions);
133 static_assert([](
auto&& v) {
140 static_assert([](
auto&& v) {
147 static_assert([](
auto&& v) {
154 static_assert([](
auto&& v) {
162 static_assert([](
auto&& v) {
170 static_assert([](
auto&& v) {
174 [](
auto,
auto,
char const*) {},
180 static_assert([](
auto&& v) {
187 static_assert([](
auto&& v) {
194 static_assert([](
auto&& v) {
201 static_assert([](
auto&& v) {
208 static_assert([](
auto&& v) {
217 static_assert([](
auto&& v) {
221 []<
unsigned int Version>(
230 static_assert([](
auto&& v) {
237 static_assert([](
auto&& v) {
247 testcase(
"default copy construction / assignment");
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]);
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]);
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]);
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);
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");
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));
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));
314 BEAST_EXPECT(subject.isMember(
"foo") ==
decltype(subject)::IsMemberResult::None);
321 BEAST_EXPECT(s1.isMember(
"One") ==
decltype(s1)::IsMemberResult::All);
322 BEAST_EXPECT(s1.isMember(
"Two") ==
decltype(s1)::IsMemberResult::None);
330 BEAST_EXPECT(s2.isMember(
"One") ==
decltype(s2)::IsMemberResult::Some);
331 BEAST_EXPECT(s2.isMember(
"Two") ==
decltype(s2)::IsMemberResult::Some);
339 BEAST_EXPECT(s3.isMember(
"One") ==
decltype(s3)::IsMemberResult::Some);
340 BEAST_EXPECT(s3.isMember(
"Two") ==
decltype(s3)::IsMemberResult::None);
352 BEAST_EXPECT(not s1.valid(0));
353 BEAST_EXPECT(s1.index(0) == 0);
355 BEAST_EXPECT(s1.valid(1));
356 BEAST_EXPECT(s1.index(1) == 0);
358 BEAST_EXPECT(not s1.valid(4));
361 static_assert([](
auto&& v) {
365 std::integral_constant<unsigned, 1>{},
366 [](json::Value&, std::integral_constant<unsigned, 1>) {});
372 std::integral_constant<unsigned, 1>{},
374 [](json::Value& v, std::integral_constant<unsigned, 1>) {
375 return v[
"value"].asInt();
377 [](json::Value
const&,
auto) { return 0; },
378 [](
auto,
auto) { return 0; }}) == 2);
380 static_assert([](
auto&& v) {
382 v.kVisitor(v, std::integral_constant<unsigned, 1>{}, [](json::Value&) {});
388 std::integral_constant<unsigned, 1>{},
390 [](json::Value& v) { return v[
"value"].asInt(); },
391 [](json::Value
const&) { return 0; },
392 [](
auto...) { return 0; }}) == 2);
394 static_assert([](
auto&& v) {
398 std::integral_constant<unsigned, 1>{},
399 [](json::Value
const&, std::integral_constant<unsigned, 1>) {});
405 std::integral_constant<unsigned, 2>{},
407 [](json::Value const& v, std::integral_constant<unsigned, 2>) {
408 return v[
"value"].asInt();
410 [](json::Value&,
auto) { return 0; },
411 [](
auto,
auto) { return 0; }}) == 3);
413 static_assert([](
auto&& v) {
423 [](json::Value const& v) { return v[
"value"].asInt(); },
425 [](
auto...) { return 0; }}) == 3);
427 static_assert([](
auto&& v) {
428 return requires { v.kVisitor(v, 1, [](
json::Value&,
unsigned) {}); };
435 [](json::Value& v, unsigned) { return v[
"value"].asInt(); },
437 [](
auto,
auto) { return 0; }}) == 5);
440 [](
auto&& v) {
return requires { v.kVisitor(v, 1, [](
json::Value&) {}); }; }(s1));
446 [](json::Value& v) { return v[
"value"].asInt(); },
448 [](
auto...) { return 0; }}) == 5);
450 static_assert([](
auto&& v) {
451 return requires { v.kVisitor(v, 1, [](
json::Value const&,
unsigned) {}); };
458 [](json::Value const& v, unsigned) { return v[
"value"].asInt(); },
460 [](
auto,
auto) { return 0; }}) == 3);
462 static_assert([](
auto&& v) {
463 return requires { v.kVisitor(v, 1, [](
json::Value const&) {}); };
470 [](json::Value const& v) { return v[
"value"].asInt(); },
472 [](
auto...) { return 0; }}) == 3);
479 [](
json::Value& v,
unsigned) { return v[
"value"].asInt(); }) == 2);
484 [](
json::Value const& v,
unsigned) { return v[
"value"].asInt(); }) == 3);
489 [](
json::Value const& v,
auto) { return v[
"value"].asInt(); }) == 5);
494 [](
json::Value const& v) { return v[
"value"].asInt(); }) == 5);
499 [](
json::Value& v,
long) { return v[
"value"].asInt(); }) == 5);
504 [](
json::Value const& v,
long) { return v[
"value"].asInt(); }) == 2);
509 [](
json::Value const& v,
auto) { return v[
"value"].asInt(); }) == 3);
514 [](
auto& v,
auto) { return v[
"value"].asInt(); }) == 3);
519 [](
auto const& v,
auto) { return v[
"value"].asInt(); }) == 3);
524 [](
auto& v) { return v[
"value"].asInt(); }) == 3);
529 [](
auto const& v) { return v[
"value"].asInt(); }) == 3);
537 return ver * a1 * a2 * v[
"value"].asInt();
540 7) == 2 * 5 * 7 * 3);
546 return ver * (1 * ... * args) * v[
"value"].asInt();
549 7) == 2 * 5 * 7 * 3);
552 static_assert([](
auto&& v) {
561 static_assert([](
auto&& v) {
570 static_assert([](
auto&& v) {
579 static_assert([](
auto&& v) {
589 static_assert([](
auto&& v) {
return requires { v.kVisitor(v, 1, [](
auto) {}); }; }(s1));
592 [](
auto&& v) {
return requires { v.kVisitor(v, 1, [](
json::Value&) {}); }; }(s1));
594 static_assert([](
auto&& v) {
595 return requires { v.kVisitor(v, 1, [](
json::Value&,
auto...) {}); };
598 static_assert([](
auto&& v) {
599 return requires { v.kVisitor(v, 1, [](
json::Value const&) {}); };
602 static_assert([](
auto&& v) {
603 return requires { v.kVisitor(v, 1, [](
json::Value const&,
auto...) {}); };
607 [](
auto&& v) {
return requires { v.kVisitor(v, 1, [](
auto...) {}); }; }(s1));
610 [](
auto&& v) {
return requires { v.kVisitor(v, 1, [](
auto,
auto...) {}); }; }(s1));
612 static_assert([](
auto&& v) {
613 return requires { v.kVisitor(v, 1, [](
auto,
auto,
auto...) {}); };
616 static_assert([](
auto&& v) {
617 return requires { v.kVisitor(v, 1, [](
auto,
auto,
auto...) {},
""); };
620 static_assert([](
auto&& v) {
621 return requires { v.kVisitor(v, 1, [](
auto,
auto,
auto,
auto...) {},
""); };
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);
634 static_assert([](
auto&& v) {
645 [](json::Value& v, std::integral_constant<unsigned, 1>) {
646 return v[
"value"].asInt();
649 [](
auto,
auto) { return 0; }}) == 2);
650 static_assert([](
auto&& v) {
661 [](json::Value& v, std::integral_constant<unsigned, 1>) {
662 return v[
"value"].asInt();
665 [](
auto,
auto) { return 0; }}) == 2);
667 static_assert([](
auto&& v) {
676 [](json::Value& v) { return v[
"value"].asInt(); },
678 [](
auto...) { return 0; }}) == 2);
679 static_assert([](
auto&& v) {
688 [](json::Value& v) { return v[
"value"].asInt(); },
690 [](
auto...) { return 0; }}) == 2);
692 static_assert([](
auto&& v) {
704 return v[
"value"].
asInt();
707 [](
auto,
auto) {
return 0; }}) == 3);
708 static_assert([](
auto&& v) {
720 return v[
"value"].
asInt();
723 [](
auto,
auto) {
return 0; }}) == 3);
725 static_assert([](
auto&& v) {
736 [](
auto...) {
return 0; }}) == 3);
737 static_assert([](
auto&& v) {
748 [](
auto...) {
return 0; }}) == 3);
750 static_assert([](
auto&& v) {
751 return requires { v.visit(1, [](
json::Value&,
unsigned) {}); };
757 [](json::Value& v, unsigned) { return v[
"value"].asInt(); },
760 [](
auto,
auto) { return 0; }}) == 5);
761 static_assert([](
auto&& v) {
762 return requires { v.visit()(1, [](
json::Value&, unsigned) {}); };
768 [](json::Value& v, unsigned) { return v[
"value"].asInt(); },
771 [](
auto,
auto) { return 0; }}) == 5);
774 [](
auto&& v) {
return requires { v.visit(1, [](
json::Value&) {}); }; }(s1));
779 [](json::Value& v) { return v[
"value"].asInt(); },
781 [](
auto...) { return 0; }}) == 5);
783 [](
auto&& v) {
return requires { v.visit()(1, [](
json::Value&) {}); }; }(s1));
788 [](json::Value& v) { return v[
"value"].asInt(); },
790 [](
auto...) { return 0; }}) == 5);
792 static_assert([](
auto&& v) {
793 return requires { v.visit(1, [](
json::Value const&,
unsigned) {}); };
802 [](
auto,
auto) {
return 0; }}) == 3);
803 static_assert([](
auto&& v) {
804 return requires { v.visit()(1, [](
json::Value const&, unsigned) {}); };
813 [](
auto,
auto) {
return 0; }}) == 3);
815 static_assert([](
auto&& v) {
816 return requires { v.visit(1, [](
json::Value const&) {}); };
824 [](
auto...) {
return 0; }}) == 3);
825 static_assert([](
auto&& v) {
826 return requires { v.visit()(1, [](
json::Value const&) {}); };
834 [](
auto...) {
return 0; }}) == 3);
837 static_assert([](
auto&& v) {
841 static_assert([](
auto&& v) {
846 static_assert([](
auto&& v) {
849 static_assert([](
auto&& v) {
854 static_assert([](
auto&& v) {
858 static_assert([](
auto&& v) {
863 static_assert([](
auto&& v) {
866 static_assert([](
auto&& v) {
871 static_assert([](
auto&& v) {
876 static_assert([](
auto&& v) {
881 static_assert([](
auto&& v) {
886 static_assert([](
auto&& v) {
893 static_assert([](
auto&& v) {
898 static_assert([](
auto&& v) {
905 static_assert([](
auto&& v) {
908 static_assert([](
auto&& v) {
913 static_assert([](
auto&& v) {
916 static_assert([](
auto&& v) {