ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-06-06 18:26:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: Set ColumnLimit to 120 in clang-format (#6288)

Browse Source 
This change updates the ColumnLimit from 80 to 120, and applies clang-format to reformat the code.
This commit is contained in:
Ayaz Salikhov
2026-01-28 18:09:50 +00:00
committed by GitHub
parent 92046785d1
commit 5f638f5553
1016 changed files with 26918 additions and 66660 deletions
Download Patch File Download Diff File Expand all files Collapse all files

440
src/test/protocol/MultiApiJson_test.cpp
View File

@@ -46,13 +46,10 @@ struct MultiApiJson_test : beast::unit_test::suite
MultiApiJson<1, 3> subject{};
static_assert(sizeof(subject) == sizeof(subject.val));
static_assert(subject.size == subject.val.size());
static_assert(
std::is_same_v<decltype(subject.val), std::array<Json::Value, 3>>);
static_assert(std::is_same_v<decltype(subject.val), std::array<Json::Value, 3>>);
BEAST_EXPECT(subject.val.size() == 3);
BEAST_EXPECT(
(subject.val ==
std::array<Json::Value, 3>{jsonNull, jsonNull, jsonNull}));
BEAST_EXPECT((subject.val == std::array<Json::Value, 3>{jsonNull, jsonNull, jsonNull}));
subject.val[0] = obj1;
subject.val[1] = obj2;
@@ -61,21 +58,15 @@ struct MultiApiJson_test : beast::unit_test::suite
testcase("forApiVersions, forAllApiVersions");
// Some static data for test inputs
static int const primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23,
29, 31, 37, 41, 43, 47, 53, 59, 61,
67, 71, 73, 79, 83, 89, 97};
static int const primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
static_assert(std::size(primes) > RPC::apiMaximumValidVersion);
MultiApiJson<1, 3> s1{};
static_assert(
s1.size ==
RPC::apiMaximumValidVersion + 1 -
RPC::apiMinimumSupportedVersion);
static_assert(s1.size == RPC::apiMaximumValidVersion + 1 - RPC::apiMinimumSupportedVersion);
int productAllVersions = 1;
for (unsigned i = RPC::apiMinimumSupportedVersion;
i <= RPC::apiMaximumValidVersion;
++i)
for (unsigned i = RPC::apiMinimumSupportedVersion; i <= RPC::apiMaximumValidVersion; ++i)
{
auto const index = i - RPC::apiMinimumSupportedVersion;
BEAST_EXPECT(index == s1.index(i));
@@ -85,25 +76,15 @@ struct MultiApiJson_test : beast::unit_test::suite
}
BEAST_EXPECT(!s1.valid(0));
BEAST_EXPECT(!s1.valid(RPC::apiMaximumValidVersion + 1));
BEAST_EXPECT(
!s1.valid(std::numeric_limits<
decltype(RPC::apiMaximumValidVersion.value)>::max()));
BEAST_EXPECT(!s1.valid(std::numeric_limits<decltype(RPC::apiMaximumValidVersion.value)>::max()));
int result = 1;
static_assert(
RPC::apiMinimumSupportedVersion + 1 <=
RPC::apiMaximumValidVersion);
forApiVersions<
RPC::apiMinimumSupportedVersion,
RPC::apiMinimumSupportedVersion + 1>(
static_assert(RPC::apiMinimumSupportedVersion + 1 <= RPC::apiMaximumValidVersion);
forApiVersions<RPC::apiMinimumSupportedVersion, RPC::apiMinimumSupportedVersion + 1>(
std::as_const(s1).visit(),
[this](
Json::Value const& json,
unsigned int version,
int* result) {
[this](Json::Value const& json, unsigned int version, int* result) {
BEAST_EXPECT(
version >= RPC::apiMinimumSupportedVersion &&
version <= RPC::apiMinimumSupportedVersion + 1);
version >= RPC::apiMinimumSupportedVersion && version <= RPC::apiMinimumSupportedVersion + 1);
if (BEAST_EXPECT(json.isMember("value")))
{
*result *= json["value"].asInt();
@@ -111,30 +92,22 @@ struct MultiApiJson_test : beast::unit_test::suite
},
&result);
BEAST_EXPECT(
result ==
primes[RPC::apiMinimumSupportedVersion] *
primes[RPC::apiMinimumSupportedVersion + 1]);
result == primes[RPC::apiMinimumSupportedVersion] * primes[RPC::apiMinimumSupportedVersion + 1]);
// Check all the values with mutable data
forAllApiVersions(
s1.visit(), [&s1, this](Json::Value& json, auto version) {
BEAST_EXPECT(s1.val[s1.index(version)] == json);
if (BEAST_EXPECT(json.isMember("value")))
{
BEAST_EXPECT(json["value"].asInt() == primes[version]);
}
});
forAllApiVersions(s1.visit(), [&s1, this](Json::Value& json, auto version) {
BEAST_EXPECT(s1.val[s1.index(version)] == json);
if (BEAST_EXPECT(json.isMember("value")))
{
BEAST_EXPECT(json["value"].asInt() == primes[version]);
}
});
result = 1;
forAllApiVersions(
std::as_const(s1).visit(),
[this](
Json::Value const& json,
unsigned int version,
int* result) {
BEAST_EXPECT(
version >= RPC::apiMinimumSupportedVersion &&
version <= RPC::apiMaximumValidVersion);
[this](Json::Value const& json, unsigned int version, int* result) {
BEAST_EXPECT(version >= RPC::apiMinimumSupportedVersion && version <= RPC::apiMaximumValidVersion);
if (BEAST_EXPECT(json.isMember("value")))
{
*result *= json["value"].asInt();
@@ -163,7 +136,7 @@ struct MultiApiJson_test : beast::unit_test::suite
return !requires {
forAllApiVersions(
std::forward<decltype(v)>(v).visit(), //
[]() {}); // missing parameters
[]() {}); // missing parameters
};
}(std::as_const(s1)));
static_assert([](auto&& v) {
@@ -234,10 +207,7 @@ struct MultiApiJson_test : beast::unit_test::suite
forAllApiVersions(
std::forward<decltype(v)>(v).visit(), //
[]<unsigned int Version>(
Json::Value const&,
std::integral_constant<unsigned int, Version>,
int,
char const*) {},
Json::Value const&, std::integral_constant<unsigned int, Version>, int, char const*) {},
0,
"");
};
@@ -308,27 +278,17 @@ struct MultiApiJson_test : beast::unit_test::suite
BEAST_EXPECT(x.val[1]["name2"].asString() == "bar");
// Tests of requires clause - these are expected to match
static_assert([](auto&& v) {
return requires { v.set("name", Json::nullValue); };
}(x));
static_assert([](auto&& v) {
return requires { v.set("name", "value"); };
}(x));
static_assert(
[](auto&& v) { return requires { v.set("name", true); }; }(x));
static_assert(
[](auto&& v) { return requires { v.set("name", 42); }; }(x));
static_assert([](auto&& v) { return requires { v.set("name", Json::nullValue); }; }(x));
static_assert([](auto&& v) { return requires { v.set("name", "value"); }; }(x));
static_assert([](auto&& v) { return requires { v.set("name", true); }; }(x));
static_assert([](auto&& v) { return requires { v.set("name", 42); }; }(x));
// Tests of requires clause - these are expected NOT to match
struct foo_t final
{
};
static_assert([](auto&& v) {
return !requires { v.set("name", foo_t{}); };
}(x));
static_assert([](auto&& v) {
return !requires { v.set("name", std::nullopt); };
}(x));
static_assert([](auto&& v) { return !requires { v.set("name", foo_t{}); }; }(x));
static_assert([](auto&& v) { return !requires { v.set("name", std::nullopt); }; }(x));
}
{
@@ -387,8 +347,7 @@ struct MultiApiJson_test : beast::unit_test::suite
v.visitor(
v,
std::integral_constant<unsigned, 1>{},
[](Json::Value&, std::integral_constant<unsigned, 1>) {
});
[](Json::Value&, std::integral_constant<unsigned, 1>) {});
};
}(s1));
BEAST_EXPECT(
@@ -396,20 +355,12 @@ struct MultiApiJson_test : beast::unit_test::suite
s1,
std::integral_constant<unsigned, 1>{},
Overload{
[](Json::Value& v,
std::integral_constant<unsigned, 1>) {
return v["value"].asInt();
},
[](Json::Value& v, std::integral_constant<unsigned, 1>) { return v["value"].asInt(); },
[](Json::Value const&, auto) { return 0; },
[](auto, auto) { return 0; }}) == 2);
static_assert([](auto&& v) {
return requires {
v.visitor(
v,
std::integral_constant<unsigned, 1>{},
[](Json::Value&) {});
};
return requires { v.visitor(v, std::integral_constant<unsigned, 1>{}, [](Json::Value&) {}); };
}(s1));
BEAST_EXPECT(
s1.visitor(
@@ -425,8 +376,7 @@ struct MultiApiJson_test : beast::unit_test::suite
v.visitor(
v,
std::integral_constant<unsigned, 1>{},
[](Json::Value const&,
std::integral_constant<unsigned, 1>) {});
[](Json::Value const&, std::integral_constant<unsigned, 1>) {});
};
}(std::as_const(s1)));
BEAST_EXPECT(
@@ -434,20 +384,12 @@ struct MultiApiJson_test : beast::unit_test::suite
std::as_const(s1),
std::integral_constant<unsigned, 2>{},
Overload{
[](Json::Value const& v,
std::integral_constant<unsigned, 2>) {
return v["value"].asInt();
},
[](Json::Value const& v, std::integral_constant<unsigned, 2>) { return v["value"].asInt(); },
[](Json::Value&, auto) { return 0; },
[](auto, auto) { return 0; }}) == 3);
static_assert([](auto&& v) {
return requires {
v.visitor(
v,
std::integral_constant<unsigned, 1>{},
[](Json::Value const&) {});
};
return requires { v.visitor(v, std::integral_constant<unsigned, 1>{}, [](Json::Value const&) {}); };
}(std::as_const(s1)));
BEAST_EXPECT(
s1.visitor(
@@ -458,25 +400,17 @@ struct MultiApiJson_test : beast::unit_test::suite
[](Json::Value&) { return 0; },
[](auto...) { return 0; }}) == 3);
static_assert([](auto&& v) {
return requires {
v.visitor(v, 1, [](Json::Value&, unsigned) {});
};
}(s1));
static_assert([](auto&& v) { return requires { v.visitor(v, 1, [](Json::Value&, unsigned) {}); }; }(s1));
BEAST_EXPECT(
s1.visitor(
s1, //
3u,
Overload{
[](Json::Value& v, unsigned) {
return v["value"].asInt();
},
[](Json::Value& v, unsigned) { return v["value"].asInt(); },
[](Json::Value const&, unsigned) { return 0; },
[](auto, auto) { return 0; }}) == 5);
static_assert([](auto&& v) {
return requires { v.visitor(v, 1, [](Json::Value&) {}); };
}(s1));
static_assert([](auto&& v) { return requires { v.visitor(v, 1, [](Json::Value&) {}); }; }(s1));
BEAST_EXPECT(
s1.visitor(
s1, //
@@ -487,24 +421,19 @@ struct MultiApiJson_test : beast::unit_test::suite
[](auto...) { return 0; }}) == 5);
static_assert([](auto&& v) {
return requires {
v.visitor(v, 1, [](Json::Value const&, unsigned) {});
};
return requires { v.visitor(v, 1, [](Json::Value const&, unsigned) {}); };
}(std::as_const(s1)));
BEAST_EXPECT(
s1.visitor(
std::as_const(s1), //
2u,
Overload{
[](Json::Value const& v, unsigned) {
return v["value"].asInt();
},
[](Json::Value const& v, unsigned) { return v["value"].asInt(); },
[](Json::Value const&, auto) { return 0; },
[](auto, auto) { return 0; }}) == 3);
static_assert([](auto&& v) {
return requires { v.visitor(v, 1, [](Json::Value const&) {}); };
}(std::as_const(s1)));
static_assert(
[](auto&& v) { return requires { v.visitor(v, 1, [](Json::Value const&) {}); }; }(std::as_const(s1)));
BEAST_EXPECT(
s1.visitor(
std::as_const(s1), //
@@ -519,49 +448,37 @@ struct MultiApiJson_test : beast::unit_test::suite
s1.visitor(
s1,
std::integral_constant<unsigned, 1>{}, // to unsigned
[](Json::Value& v, unsigned) {
return v["value"].asInt();
}) == 2);
[](Json::Value& v, unsigned) { return v["value"].asInt(); }) == 2);
BEAST_EXPECT(
s1.visitor(
std::as_const(s1),
std::integral_constant<unsigned, 2>{}, // to unsigned
[](Json::Value const& v, unsigned) {
return v["value"].asInt();
}) == 3);
[](Json::Value const& v, unsigned) { return v["value"].asInt(); }) == 3);
BEAST_EXPECT(
s1.visitor(
s1, // to const
std::integral_constant<unsigned, 3>{},
[](Json::Value const& v, auto) {
return v["value"].asInt();
}) == 5);
[](Json::Value const& v, auto) { return v["value"].asInt(); }) == 5);
BEAST_EXPECT(
s1.visitor(
s1, // to const
std::integral_constant<unsigned, 3>{},
[](Json::Value const& v) { return v["value"].asInt(); }) ==
5);
[](Json::Value const& v) { return v["value"].asInt(); }) == 5);
BEAST_EXPECT(
s1.visitor(
s1,
3, // to long
[](Json::Value& v, long) { return v["value"].asInt(); }) ==
5);
[](Json::Value& v, long) { return v["value"].asInt(); }) == 5);
BEAST_EXPECT(
s1.visitor(
std::as_const(s1),
1, // to long
[](Json::Value const& v, long) {
return v["value"].asInt();
}) == 2);
[](Json::Value const& v, long) { return v["value"].asInt(); }) == 2);
BEAST_EXPECT(
s1.visitor(
s1, // to const
2,
[](Json::Value const& v, auto) {
return v["value"].asInt();
}) == 3);
[](Json::Value const& v, auto) { return v["value"].asInt(); }) == 3);
BEAST_EXPECT(
s1.visitor(
s1, // type deduction
@@ -571,8 +488,7 @@ struct MultiApiJson_test : beast::unit_test::suite
s1.visitor(
s1, // to const, type deduction
2,
[](auto const& v, auto) { return v["value"].asInt(); }) ==
3);
[](auto const& v, auto) { return v["value"].asInt(); }) == 3);
BEAST_EXPECT(
s1.visitor(
s1, // type deduction
@@ -589,18 +505,14 @@ struct MultiApiJson_test : beast::unit_test::suite
s1.visitor(
s1,
std::integral_constant<unsigned, 2>{},
[](Json::Value& v, auto ver, auto a1, auto a2) {
return ver * a1 * a2 * v["value"].asInt();
},
[](Json::Value& v, auto ver, auto a1, auto a2) { return ver * a1 * a2 * v["value"].asInt(); },
5,
7) == 2 * 5 * 7 * 3);
BEAST_EXPECT(
s1.visitor(
s1,
std::integral_constant<unsigned, 2>{},
[](Json::Value& v, auto ver, auto... args) {
return ver * (1 * ... * args) * v["value"].asInt();
},
[](Json::Value& v, auto ver, auto... args) { return ver * (1 * ... * args) * v["value"].asInt(); },
5,
7) == 2 * 5 * 7 * 3);
@@ -642,55 +554,27 @@ struct MultiApiJson_test : beast::unit_test::suite
}(s1));
// Want these to be unambiguous
static_assert([](auto&& v) {
return requires { v.visitor(v, 1, [](auto) {}); };
}(s1));
static_assert([](auto&& v) { return requires { v.visitor(v, 1, [](auto) {}); }; }(s1));
static_assert([](auto&& v) {
return requires { v.visitor(v, 1, [](Json::Value&) {}); };
}(s1));
static_assert([](auto&& v) { return requires { v.visitor(v, 1, [](Json::Value&) {}); }; }(s1));
static_assert([](auto&& v) {
return requires {
v.visitor(v, 1, [](Json::Value&, auto...) {});
};
}(s1));
static_assert([](auto&& v) { return requires { v.visitor(v, 1, [](Json::Value&, auto...) {}); }; }(s1));
static_assert([](auto&& v) {
return requires { v.visitor(v, 1, [](Json::Value const&) {}); };
}(s1));
static_assert([](auto&& v) { return requires { v.visitor(v, 1, [](Json::Value const&) {}); }; }(s1));
static_assert([](auto&& v) {
return requires {
v.visitor(v, 1, [](Json::Value const&, auto...) {});
};
}(s1));
static_assert(
[](auto&& v) { return requires { v.visitor(v, 1, [](Json::Value const&, auto...) {}); }; }(s1));
static_assert([](auto&& v) {
return requires { v.visitor(v, 1, [](auto...) {}); };
}(s1));
static_assert([](auto&& v) { return requires { v.visitor(v, 1, [](auto...) {}); }; }(s1));
static_assert([](auto&& v) {
return requires { v.visitor(v, 1, [](auto, auto...) {}); };
}(s1));
static_assert([](auto&& v) { return requires { v.visitor(v, 1, [](auto, auto...) {}); }; }(s1));
static_assert([](auto&& v) {
return requires {
v.visitor(v, 1, [](auto, auto, auto...) {});
};
}(s1));
static_assert([](auto&& v) { return requires { v.visitor(v, 1, [](auto, auto, auto...) {}); }; }(s1));
static_assert([](auto&& v) {
return requires {
v.visitor(v, 1, [](auto, auto, auto...) {}, "");
};
}(s1));
static_assert([](auto&& v) { return requires { v.visitor(v, 1, [](auto, auto, auto...) {}, ""); }; }(s1));
static_assert([](auto&& v) {
return requires {
v.visitor(v, 1, [](auto, auto, auto, auto...) {}, "");
};
}(s1));
static_assert(
[](auto&& v) { return requires { v.visitor(v, 1, [](auto, auto, auto, auto...) {}, ""); }; }(s1));
}
{
@@ -706,45 +590,33 @@ struct MultiApiJson_test : beast::unit_test::suite
return requires {
v.visit(
std::integral_constant<unsigned, 1>{},
[](Json::Value&, std::integral_constant<unsigned, 1>) {
});
[](Json::Value&, std::integral_constant<unsigned, 1>) {});
};
}(s1));
BEAST_EXPECT(
s1.visit(
std::integral_constant<unsigned, 1>{},
Overload{
[](Json::Value& v,
std::integral_constant<unsigned, 1>) {
return v["value"].asInt();
},
[](Json::Value& v, std::integral_constant<unsigned, 1>) { return v["value"].asInt(); },
[](Json::Value const&, auto) { return 0; },
[](auto, auto) { return 0; }}) == 2);
static_assert([](auto&& v) {
return requires {
v.visit()(
std::integral_constant<unsigned, 1>{},
[](Json::Value&, std::integral_constant<unsigned, 1>) {
});
[](Json::Value&, std::integral_constant<unsigned, 1>) {});
};
}(s1));
BEAST_EXPECT(
s1.visit()(
std::integral_constant<unsigned, 1>{},
Overload{
[](Json::Value& v,
std::integral_constant<unsigned, 1>) {
return v["value"].asInt();
},
[](Json::Value& v, std::integral_constant<unsigned, 1>) { return v["value"].asInt(); },
[](Json::Value const&, auto) { return 0; },
[](auto, auto) { return 0; }}) == 2);
static_assert([](auto&& v) {
return requires {
v.visit(
std::integral_constant<unsigned, 1>{},
[](Json::Value&) {});
};
return requires { v.visit(std::integral_constant<unsigned, 1>{}, [](Json::Value&) {}); };
}(s1));
BEAST_EXPECT(
s1.visit(
@@ -754,11 +626,7 @@ struct MultiApiJson_test : beast::unit_test::suite
[](Json::Value const&) { return 0; },
[](auto...) { return 0; }}) == 2);
static_assert([](auto&& v) {
return requires {
v.visit()(
std::integral_constant<unsigned, 1>{},
[](Json::Value&) {});
};
return requires { v.visit()(std::integral_constant<unsigned, 1>{}, [](Json::Value&) {}); };
}(s1));
BEAST_EXPECT(
s1.visit()(
@@ -772,45 +640,33 @@ struct MultiApiJson_test : beast::unit_test::suite
return requires {
v.visit(
std::integral_constant<unsigned, 1>{},
[](Json::Value const&,
std::integral_constant<unsigned, 1>) {});
[](Json::Value const&, std::integral_constant<unsigned, 1>) {});
};
}(std::as_const(s1)));
BEAST_EXPECT(
std::as_const(s1).visit(
std::integral_constant<unsigned, 2>{},
Overload{
[](Json::Value const& v,
std::integral_constant<unsigned, 2>) {
return v["value"].asInt();
},
[](Json::Value const& v, std::integral_constant<unsigned, 2>) { return v["value"].asInt(); },
[](Json::Value&, auto) { return 0; },
[](auto, auto) { return 0; }}) == 3);
static_assert([](auto&& v) {
return requires {
v.visit()(
std::integral_constant<unsigned, 1>{},
[](Json::Value const&,
std::integral_constant<unsigned, 1>) {});
[](Json::Value const&, std::integral_constant<unsigned, 1>) {});
};
}(std::as_const(s1)));
BEAST_EXPECT(
std::as_const(s1).visit()(
std::integral_constant<unsigned, 2>{},
Overload{
[](Json::Value const& v,
std::integral_constant<unsigned, 2>) {
return v["value"].asInt();
},
[](Json::Value const& v, std::integral_constant<unsigned, 2>) { return v["value"].asInt(); },
[](Json::Value&, auto) { return 0; },
[](auto, auto) { return 0; }}) == 3);
static_assert([](auto&& v) {
return requires {
v.visit(
std::integral_constant<unsigned, 1>{},
[](Json::Value const&) {});
};
return requires { v.visit(std::integral_constant<unsigned, 1>{}, [](Json::Value const&) {}); };
}(std::as_const(s1)));
BEAST_EXPECT(
std::as_const(s1).visit(
@@ -820,11 +676,7 @@ struct MultiApiJson_test : beast::unit_test::suite
[](Json::Value&) { return 0; },
[](auto...) { return 0; }}) == 3);
static_assert([](auto&& v) {
return requires {
v.visit()(
std::integral_constant<unsigned, 1>{},
[](Json::Value const&) {});
};
return requires { v.visit()(std::integral_constant<unsigned, 1>{}, [](Json::Value const&) {}); };
}(std::as_const(s1)));
BEAST_EXPECT(
std::as_const(s1).visit()(
@@ -834,38 +686,26 @@ struct MultiApiJson_test : beast::unit_test::suite
[](Json::Value&) { return 0; },
[](auto...) { return 0; }}) == 3);
static_assert([](auto&& v) {
return requires { v.visit(1, [](Json::Value&, unsigned) {}); };
}(s1));
static_assert([](auto&& v) { return requires { v.visit(1, [](Json::Value&, unsigned) {}); }; }(s1));
BEAST_EXPECT(
s1.visit(
3u,
Overload{
[](Json::Value& v, unsigned) {
return v["value"].asInt();
},
[](Json::Value& v, unsigned) { return v["value"].asInt(); },
[](Json::Value const&, unsigned) { return 0; },
[](Json::Value&, auto) { return 0; },
[](auto, auto) { return 0; }}) == 5);
static_assert([](auto&& v) {
return requires {
v.visit()(1, [](Json::Value&, unsigned) {});
};
}(s1));
static_assert([](auto&& v) { return requires { v.visit()(1, [](Json::Value&, unsigned) {}); }; }(s1));
BEAST_EXPECT(
s1.visit()(
3u,
Overload{
[](Json::Value& v, unsigned) {
return v["value"].asInt();
},
[](Json::Value& v, unsigned) { return v["value"].asInt(); },
[](Json::Value const&, unsigned) { return 0; },
[](Json::Value&, auto) { return 0; },
[](auto, auto) { return 0; }}) == 5);
static_assert([](auto&& v) {
return requires { v.visit(1, [](Json::Value&) {}); };
}(s1));
static_assert([](auto&& v) { return requires { v.visit(1, [](Json::Value&) {}); }; }(s1));
BEAST_EXPECT(
s1.visit(
3,
@@ -873,9 +713,7 @@ struct MultiApiJson_test : beast::unit_test::suite
[](Json::Value& v) { return v["value"].asInt(); },
[](Json::Value const&) { return 0; },
[](auto...) { return 0; }}) == 5);
static_assert([](auto&& v) {
return requires { v.visit()(1, [](Json::Value&) {}); };
}(s1));
static_assert([](auto&& v) { return requires { v.visit()(1, [](Json::Value&) {}); }; }(s1));
BEAST_EXPECT(
s1.visit()(
3,
@@ -885,39 +723,30 @@ struct MultiApiJson_test : beast::unit_test::suite
[](auto...) { return 0; }}) == 5);
static_assert([](auto&& v) {
return requires {
v.visit(1, [](Json::Value const&, unsigned) {});
};
return requires { v.visit(1, [](Json::Value const&, unsigned) {}); };
}(std::as_const(s1)));
BEAST_EXPECT(
std::as_const(s1).visit(
2u,
Overload{
[](Json::Value const& v, unsigned) {
return v["value"].asInt();
},
[](Json::Value const& v, unsigned) { return v["value"].asInt(); },
[](Json::Value const&, auto) { return 0; },
[](Json::Value&, unsigned) { return 0; },
[](auto, auto) { return 0; }}) == 3);
static_assert([](auto&& v) {
return requires {
v.visit()(1, [](Json::Value const&, unsigned) {});
};
return requires { v.visit()(1, [](Json::Value const&, unsigned) {}); };
}(std::as_const(s1)));
BEAST_EXPECT(
std::as_const(s1).visit()(
2u,
Overload{
[](Json::Value const& v, unsigned) {
return v["value"].asInt();
},
[](Json::Value const& v, unsigned) { return v["value"].asInt(); },
[](Json::Value const&, auto) { return 0; },
[](Json::Value&, unsigned) { return 0; },
[](auto, auto) { return 0; }}) == 3);
static_assert([](auto&& v) {
return requires { v.visit(1, [](Json::Value const&) {}); };
}(std::as_const(s1)));
static_assert(
[](auto&& v) { return requires { v.visit(1, [](Json::Value const&) {}); }; }(std::as_const(s1)));
BEAST_EXPECT(
std::as_const(s1).visit(
2,
@@ -925,9 +754,8 @@ struct MultiApiJson_test : beast::unit_test::suite
[](Json::Value const& v) { return v["value"].asInt(); },
[](Json::Value&) { return 0; },
[](auto...) { return 0; }}) == 3);
static_assert([](auto&& v) {
return requires { v.visit()(1, [](Json::Value const&) {}); };
}(std::as_const(s1)));
static_assert(
[](auto&& v) { return requires { v.visit()(1, [](Json::Value const&) {}); }; }(std::as_const(s1)));
BEAST_EXPECT(
std::as_const(s1).visit()(
2,
@@ -938,112 +766,60 @@ struct MultiApiJson_test : beast::unit_test::suite
// Rvalue MultivarJson visitor only binds to regular reference
static_assert([](auto&& v) {
return !requires {
std::forward<decltype(v)>(v).visit(1, [](Json::Value&&) {});
};
return !requires { std::forward<decltype(v)>(v).visit(1, [](Json::Value&&) {}); };
}(std::move(s1)));
static_assert([](auto&& v) {
return !requires {
std::forward<decltype(v)>(v).visit(
1, [](Json::Value const&&) {});
};
return !requires { std::forward<decltype(v)>(v).visit(1, [](Json::Value const&&) {}); };
}(std::move(s1)));
static_assert([](auto&& v) {
return requires {
std::forward<decltype(v)>(v).visit(1, [](Json::Value&) {});
};
return requires { std::forward<decltype(v)>(v).visit(1, [](Json::Value&) {}); };
}(std::move(s1)));
static_assert([](auto&& v) {
return requires {
std::forward<decltype(v)>(v).visit(
1, [](Json::Value const&) {});
};
return requires { std::forward<decltype(v)>(v).visit(1, [](Json::Value const&) {}); };
}(std::move(s1)));
static_assert([](auto&& v) {
return !requires {
std::forward<decltype(v)>(v).visit()(
1, [](Json::Value&&) {});
};
return !requires { std::forward<decltype(v)>(v).visit()(1, [](Json::Value&&) {}); };
}(std::move(s1)));
static_assert([](auto&& v) {
return !requires {
std::forward<decltype(v)>(v).visit()(
1, [](Json::Value const&&) {});
};
return !requires { std::forward<decltype(v)>(v).visit()(1, [](Json::Value const&&) {}); };
}(std::move(s1)));
static_assert([](auto&& v) {
return requires {
std::forward<decltype(v)>(v).visit()(
1, [](Json::Value&) {});
};
return requires { std::forward<decltype(v)>(v).visit()(1, [](Json::Value&) {}); };
}(std::move(s1)));
static_assert([](auto&& v) {
return requires {
std::forward<decltype(v)>(v).visit()(
1, [](Json::Value const&) {});
};
return requires { std::forward<decltype(v)>(v).visit()(1, [](Json::Value const&) {}); };
}(std::move(s1)));
static_assert([](auto&& v) {
return !requires {
std::forward<decltype(v)>(v).visit(
1, [](Json::Value const&&) {});
};
return !requires { std::forward<decltype(v)>(v).visit(1, [](Json::Value const&&) {}); };
}(std::move(std::as_const(s1))));
static_assert([](auto&& v) {
return requires {
std::forward<decltype(v)>(v).visit(
1, [](Json::Value const&) {});
};
return requires { std::forward<decltype(v)>(v).visit(1, [](Json::Value const&) {}); };
}(std::move(std::as_const(s1))));
static_assert([](auto&& v) {
return !requires {
std::forward<decltype(v)>(v).visit()(
1, [](Json::Value const&&) {});
};
return !requires { std::forward<decltype(v)>(v).visit()(1, [](Json::Value const&&) {}); };
}(std::move(std::as_const(s1))));
static_assert([](auto&& v) {
return requires {
std::forward<decltype(v)>(v).visit()(
1, [](Json::Value const&) {});
};
return requires { std::forward<decltype(v)>(v).visit()(1, [](Json::Value const&) {}); };
}(std::move(std::as_const(s1))));
// Missing const
static_assert([](auto&& v) {
return !requires {
std::forward<decltype(v)>(v).visit(
1, [](Json::Value&, auto) {});
};
return !requires { std::forward<decltype(v)>(v).visit(1, [](Json::Value&, auto) {}); };
}(std::as_const(s1)));
static_assert([](auto&& v) {
return !requires {
std::forward<decltype(v)>(v).visit()(
1, [](Json::Value&, auto) {});
};
return !requires { std::forward<decltype(v)>(v).visit()(1, [](Json::Value&, auto) {}); };
}(std::as_const(s1)));
// Missing parameter
static_assert([](auto&& v) {
return !requires {
std::forward<decltype(v)>(v).visit(1, []() {});
};
}(s1));
static_assert([](auto&& v) {
return !requires {
std::forward<decltype(v)>(v).visit()(1, []() {});
};
}(s1));
static_assert([](auto&& v) { return !requires { std::forward<decltype(v)>(v).visit(1, []() {}); }; }(s1));
static_assert([](auto&& v) { return !requires { std::forward<decltype(v)>(v).visit()(1, []() {}); }; }(s1));
// Sanity checks
static_assert([](auto&& v) {
return requires {
std::forward<decltype(v)>(v).visit(1, [](auto...) {});
};
return requires { std::forward<decltype(v)>(v).visit(1, [](auto...) {}); };
}(std::as_const(s1)));
static_assert([](auto&& v) {
return requires {
std::forward<decltype(v)>(v).visit()(1, [](auto...) {});
};
return requires { std::forward<decltype(v)>(v).visit()(1, [](auto...) {}); };
}(std::as_const(s1)));
}
}