ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-06-05 09:46:53 +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

168
src/test/rpc/ValidatorRPC_test.cpp
View File

@@ -51,17 +51,14 @@ public:
Env env{*this, isAdmin ? envconfig() : envconfig(no_admin)};
auto const jrr = env.rpc("server_info")[jss::result];
BEAST_EXPECT(jrr[jss::status] == "success");
BEAST_EXPECT(
jrr[jss::info].isMember(jss::validator_list) == isAdmin);
BEAST_EXPECT(jrr[jss::info].isMember(jss::validator_list) == isAdmin);
}
{
Env env{*this, isAdmin ? envconfig() : envconfig(no_admin)};
auto const jrr = env.rpc("server_state")[jss::result];
BEAST_EXPECT(jrr[jss::status] == "success");
BEAST_EXPECT(
jrr[jss::state].isMember(jss::validator_list_expires) ==
isAdmin);
BEAST_EXPECT(jrr[jss::state].isMember(jss::validator_list_expires) == isAdmin);
}
}
}
@@ -86,9 +83,7 @@ public:
// Server info reports maximum expiration since not dynamic
{
auto const jrr = env.rpc("server_info")[jss::result];
BEAST_EXPECT(
jrr[jss::info][jss::validator_list][jss::expiration] ==
"never");
BEAST_EXPECT(jrr[jss::info][jss::validator_list][jss::expiration] == "never");
}
{
auto const jrr = env.rpc("server_state")[jss::result];
@@ -101,8 +96,7 @@ public:
auto const jrr = env.rpc("validators")[jss::result];
BEAST_EXPECT(jrr[jss::validator_list][jss::expiration] == "never");
BEAST_EXPECT(jrr[jss::validation_quorum].asUInt() == keys.size());
BEAST_EXPECT(
jrr[jss::trusted_validator_keys].size() == keys.size());
BEAST_EXPECT(jrr[jss::trusted_validator_keys].size() == keys.size());
BEAST_EXPECT(jrr[jss::publisher_lists].size() == 0);
BEAST_EXPECT(jrr[jss::local_static_keys].size() == keys.size());
for (auto const& jKey : jrr[jss::local_static_keys])
@@ -136,12 +130,10 @@ public:
BEAST_EXPECT(jrrnUnlSize == 2);
for (std::uint32_t x = 0; x < jrrnUnlSize; ++x)
{
auto parsedKey = parseBase58<PublicKey>(
TokenType::NodePublic, jrrnUnl[x].asString());
auto parsedKey = parseBase58<PublicKey>(TokenType::NodePublic, jrrnUnl[x].asString());
BEAST_EXPECT(parsedKey);
if (parsedKey)
BEAST_EXPECT(
disabledKeys.find(*parsedKey) != disabledKeys.end());
BEAST_EXPECT(disabledKeys.find(*parsedKey) != disabledKeys.end());
}
disabledKeys.clear();
@@ -156,14 +148,11 @@ public:
{
using namespace test::jtx;
auto toStr = [](PublicKey const& publicKey) {
return toBase58(TokenType::NodePublic, publicKey);
};
auto toStr = [](PublicKey const& publicKey) { return toBase58(TokenType::NodePublic, publicKey); };
// Validator keys that will be in the published list
std::vector<Validator> validators = {
TrustedPublisherServer::randomValidator(),
TrustedPublisherServer::randomValidator()};
TrustedPublisherServer::randomValidator(), TrustedPublisherServer::randomValidator()};
std::set<std::string> expectedKeys;
for (auto const& val : validators)
expectedKeys.insert(toStr(val.masterPublic));
@@ -175,28 +164,20 @@ public:
NetClock::time_point const validFrom2{validUntil - 60s};
NetClock::time_point const validUntil2{validFrom2 + 3600s};
auto server = make_TrustedPublisherServer(
worker.get_io_context(),
validators,
validUntil,
{{validFrom2, validUntil2}},
false,
1,
false);
worker.get_io_context(), validators, validUntil, {{validFrom2, validUntil2}}, false, 1, false);
//----------------------------------------------------------------------
// Publisher list site unavailable v1
{
// Publisher site information
using namespace std::string_literals;
std::string siteURI =
"http://"s + getEnvLocalhostAddr() + ":1234/validators";
std::string siteURI = "http://"s + getEnvLocalhostAddr() + ":1234/validators";
Env env{
*this,
envconfig([&](std::unique_ptr<Config> cfg) {
cfg->section(SECTION_VALIDATOR_LIST_SITES).append(siteURI);
cfg->section(SECTION_VALIDATOR_LIST_KEYS)
.append(strHex(server->publisherPublic()));
cfg->section(SECTION_VALIDATOR_LIST_KEYS).append(strHex(server->publisherPublic()));
return cfg;
}),
};
@@ -206,24 +187,18 @@ public:
{
auto const jrr = env.rpc("server_info")[jss::result];
BEAST_EXPECT(
jrr[jss::info][jss::validator_list][jss::expiration] ==
"unknown");
BEAST_EXPECT(jrr[jss::info][jss::validator_list][jss::expiration] == "unknown");
}
{
auto const jrr = env.rpc("server_state")[jss::result];
BEAST_EXPECT(
jrr[jss::state][jss::validator_list_expires].asInt() == 0);
BEAST_EXPECT(jrr[jss::state][jss::validator_list_expires].asInt() == 0);
}
{
auto const jrr = env.rpc("validators")[jss::result];
BEAST_EXPECT(
jrr[jss::validation_quorum].asUInt() ==
std::numeric_limits<std::uint32_t>::max());
BEAST_EXPECT(jrr[jss::validation_quorum].asUInt() == std::numeric_limits<std::uint32_t>::max());
BEAST_EXPECT(jrr[jss::local_static_keys].size() == 0);
BEAST_EXPECT(jrr[jss::trusted_validator_keys].size() == 0);
BEAST_EXPECT(
jrr[jss::validator_list][jss::expiration] == "unknown");
BEAST_EXPECT(jrr[jss::validator_list][jss::expiration] == "unknown");
if (BEAST_EXPECT(jrr[jss::publisher_lists].size() == 1))
{
@@ -233,9 +208,7 @@ public:
BEAST_EXPECT(!jp.isMember(jss::seq));
BEAST_EXPECT(!jp.isMember(jss::expiration));
BEAST_EXPECT(!jp.isMember(jss::version));
BEAST_EXPECT(
jp[jss::pubkey_publisher] ==
strHex(server->publisherPublic()));
BEAST_EXPECT(jp[jss::pubkey_publisher] == strHex(server->publisherPublic()));
}
BEAST_EXPECT(jrr[jss::signing_keys].size() == 0);
}
@@ -255,15 +228,13 @@ public:
{
// Publisher site information
using namespace std::string_literals;
std::string siteURI =
"http://"s + getEnvLocalhostAddr() + ":1234/validators2";
std::string siteURI = "http://"s + getEnvLocalhostAddr() + ":1234/validators2";
Env env{
*this,
envconfig([&](std::unique_ptr<Config> cfg) {
cfg->section(SECTION_VALIDATOR_LIST_SITES).append(siteURI);
cfg->section(SECTION_VALIDATOR_LIST_KEYS)
.append(strHex(server->publisherPublic()));
cfg->section(SECTION_VALIDATOR_LIST_KEYS).append(strHex(server->publisherPublic()));
return cfg;
}),
};
@@ -273,24 +244,18 @@ public:
{
auto const jrr = env.rpc("server_info")[jss::result];
BEAST_EXPECT(
jrr[jss::info][jss::validator_list][jss::expiration] ==
"unknown");
BEAST_EXPECT(jrr[jss::info][jss::validator_list][jss::expiration] == "unknown");
}
{
auto const jrr = env.rpc("server_state")[jss::result];
BEAST_EXPECT(
jrr[jss::state][jss::validator_list_expires].asInt() == 0);
BEAST_EXPECT(jrr[jss::state][jss::validator_list_expires].asInt() == 0);
}
{
auto const jrr = env.rpc("validators")[jss::result];
BEAST_EXPECT(
jrr[jss::validation_quorum].asUInt() ==
std::numeric_limits<std::uint32_t>::max());
BEAST_EXPECT(jrr[jss::validation_quorum].asUInt() == std::numeric_limits<std::uint32_t>::max());
BEAST_EXPECT(jrr[jss::local_static_keys].size() == 0);
BEAST_EXPECT(jrr[jss::trusted_validator_keys].size() == 0);
BEAST_EXPECT(
jrr[jss::validator_list][jss::expiration] == "unknown");
BEAST_EXPECT(jrr[jss::validator_list][jss::expiration] == "unknown");
if (BEAST_EXPECT(jrr[jss::publisher_lists].size() == 1))
{
@@ -300,9 +265,7 @@ public:
BEAST_EXPECT(!jp.isMember(jss::seq));
BEAST_EXPECT(!jp.isMember(jss::expiration));
BEAST_EXPECT(!jp.isMember(jss::version));
BEAST_EXPECT(
jp[jss::pubkey_publisher] ==
strHex(server->publisherPublic()));
BEAST_EXPECT(jp[jss::pubkey_publisher] == strHex(server->publisherPublic()));
}
BEAST_EXPECT(jrr[jss::signing_keys].size() == 0);
}
@@ -331,8 +294,7 @@ public:
*this,
envconfig([&](std::unique_ptr<Config> cfg) {
cfg->section(SECTION_VALIDATOR_LIST_SITES).append(siteURI);
cfg->section(SECTION_VALIDATOR_LIST_KEYS)
.append(strHex(server->publisherPublic()));
cfg->section(SECTION_VALIDATOR_LIST_KEYS).append(strHex(server->publisherPublic()));
return cfg;
}),
};
@@ -344,35 +306,24 @@ public:
startKeys.insert(calcNodeID(val.masterPublic));
env.app().validators().updateTrusted(
startKeys,
env.timeKeeper().now(),
env.app().getOPs(),
env.app().overlay(),
env.app().getHashRouter());
startKeys, env.timeKeeper().now(), env.app().getOPs(), env.app().overlay(), env.app().getHashRouter());
{
auto const jrr = env.rpc("server_info")[jss::result];
BEAST_EXPECT(
jrr[jss::info][jss::validator_list][jss::expiration] ==
to_string(validUntil));
BEAST_EXPECT(jrr[jss::info][jss::validator_list][jss::expiration] == to_string(validUntil));
}
{
auto const jrr = env.rpc("server_state")[jss::result];
BEAST_EXPECT(
jrr[jss::state][jss::validator_list_expires].asUInt() ==
validUntil.time_since_epoch().count());
jrr[jss::state][jss::validator_list_expires].asUInt() == validUntil.time_since_epoch().count());
}
{
auto const jrr = env.rpc("validators")[jss::result];
BEAST_EXPECT(jrr[jss::validation_quorum].asUInt() == 2);
BEAST_EXPECT(
jrr[jss::validator_list][jss::expiration] ==
to_string(validUntil));
BEAST_EXPECT(jrr[jss::validator_list][jss::expiration] == to_string(validUntil));
BEAST_EXPECT(jrr[jss::local_static_keys].size() == 0);
BEAST_EXPECT(
jrr[jss::trusted_validator_keys].size() ==
expectedKeys.size());
BEAST_EXPECT(jrr[jss::trusted_validator_keys].size() == expectedKeys.size());
for (auto const& jKey : jrr[jss::trusted_validator_keys])
{
BEAST_EXPECT(expectedKeys.count(jKey.asString()) == 1);
@@ -393,9 +344,7 @@ public:
BEAST_EXPECT(foundKeys == expectedKeys);
}
BEAST_EXPECT(jp[jss::seq].asUInt() == 1);
BEAST_EXPECT(
jp[jss::pubkey_publisher] ==
strHex(server->publisherPublic()));
BEAST_EXPECT(jp[jss::pubkey_publisher] == strHex(server->publisherPublic()));
BEAST_EXPECT(jp[jss::expiration] == to_string(validUntil));
BEAST_EXPECT(jp[jss::version] == 1);
}
@@ -404,9 +353,7 @@ public:
for (auto const& val : validators)
{
BEAST_EXPECT(jsk.isMember(toStr(val.masterPublic)));
BEAST_EXPECT(
jsk[toStr(val.masterPublic)] ==
toStr(val.signingPublic));
BEAST_EXPECT(jsk[toStr(val.masterPublic)] == toStr(val.signingPublic));
}
}
{
@@ -433,8 +380,7 @@ public:
*this,
envconfig([&](std::unique_ptr<Config> cfg) {
cfg->section(SECTION_VALIDATOR_LIST_SITES).append(siteURI);
cfg->section(SECTION_VALIDATOR_LIST_KEYS)
.append(strHex(server->publisherPublic()));
cfg->section(SECTION_VALIDATOR_LIST_KEYS).append(strHex(server->publisherPublic()));
return cfg;
}),
};
@@ -446,35 +392,24 @@ public:
startKeys.insert(calcNodeID(val.masterPublic));
env.app().validators().updateTrusted(
startKeys,
env.timeKeeper().now(),
env.app().getOPs(),
env.app().overlay(),
env.app().getHashRouter());
startKeys, env.timeKeeper().now(), env.app().getOPs(), env.app().overlay(), env.app().getHashRouter());
{
auto const jrr = env.rpc("server_info")[jss::result];
BEAST_EXPECT(
jrr[jss::info][jss::validator_list][jss::expiration] ==
to_string(validUntil2));
BEAST_EXPECT(jrr[jss::info][jss::validator_list][jss::expiration] == to_string(validUntil2));
}
{
auto const jrr = env.rpc("server_state")[jss::result];
BEAST_EXPECT(
jrr[jss::state][jss::validator_list_expires].asUInt() ==
validUntil2.time_since_epoch().count());
jrr[jss::state][jss::validator_list_expires].asUInt() == validUntil2.time_since_epoch().count());
}
{
auto const jrr = env.rpc("validators")[jss::result];
BEAST_EXPECT(jrr[jss::validation_quorum].asUInt() == 2);
BEAST_EXPECT(
jrr[jss::validator_list][jss::expiration] ==
to_string(validUntil2));
BEAST_EXPECT(jrr[jss::validator_list][jss::expiration] == to_string(validUntil2));
BEAST_EXPECT(jrr[jss::local_static_keys].size() == 0);
BEAST_EXPECT(
jrr[jss::trusted_validator_keys].size() ==
expectedKeys.size());
BEAST_EXPECT(jrr[jss::trusted_validator_keys].size() == expectedKeys.size());
for (auto const& jKey : jrr[jss::trusted_validator_keys])
{
BEAST_EXPECT(expectedKeys.count(jKey.asString()) == 1);
@@ -495,13 +430,10 @@ public:
BEAST_EXPECT(foundKeys == expectedKeys);
}
BEAST_EXPECT(jp[jss::seq].asUInt() == 1);
BEAST_EXPECT(
jp[jss::pubkey_publisher] ==
strHex(server->publisherPublic()));
BEAST_EXPECT(jp[jss::pubkey_publisher] == strHex(server->publisherPublic()));
BEAST_EXPECT(jp[jss::expiration] == to_string(validUntil));
BEAST_EXPECT(jp[jss::version] == 2);
if (BEAST_EXPECT(jp.isMember(jss::remaining)) &&
BEAST_EXPECT(jp[jss::remaining].isArray()) &&
if (BEAST_EXPECT(jp.isMember(jss::remaining)) && BEAST_EXPECT(jp[jss::remaining].isArray()) &&
BEAST_EXPECT(jp[jss::remaining].size() == 1))
{
auto const& r = jp[jss::remaining][0u];
@@ -516,10 +448,8 @@ public:
BEAST_EXPECT(foundKeys == expectedKeys);
}
BEAST_EXPECT(r[jss::seq].asUInt() == 2);
BEAST_EXPECT(
r[jss::effective] == to_string(validFrom2));
BEAST_EXPECT(
r[jss::expiration] == to_string(validUntil2));
BEAST_EXPECT(r[jss::effective] == to_string(validFrom2));
BEAST_EXPECT(r[jss::expiration] == to_string(validUntil2));
}
}
auto jsk = jrr[jss::signing_keys];
@@ -527,9 +457,7 @@ public:
for (auto const& val : validators)
{
BEAST_EXPECT(jsk.isMember(toStr(val.masterPublic)));
BEAST_EXPECT(
jsk[toStr(val.masterPublic)] ==
toStr(val.signingPublic));
BEAST_EXPECT(jsk[toStr(val.masterPublic)] == toStr(val.signingPublic));
}
}
{
@@ -554,15 +482,9 @@ public:
using namespace test::jtx;
Env env{*this};
auto result = env.rpc("validation_create");
BEAST_EXPECT(
result.isMember(jss::result) &&
result[jss::result][jss::status] == "success");
result = env.rpc(
"validation_create",
"BAWL MAN JADE MOON DOVE GEM SON NOW HAD ADEN GLOW TIRE");
BEAST_EXPECT(
result.isMember(jss::result) &&
result[jss::result][jss::status] == "success");
BEAST_EXPECT(result.isMember(jss::result) && result[jss::result][jss::status] == "success");
result = env.rpc("validation_create", "BAWL MAN JADE MOON DOVE GEM SON NOW HAD ADEN GLOW TIRE");
BEAST_EXPECT(result.isMember(jss::result) && result[jss::result][jss::status] == "success");
}
void