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

chore: Enable clang-tidy misc checks (#6655)

Browse Source
This commit is contained in:
Alex Kremer
2026-03-31 18:29:45 +01:00
committed by GitHub
parent c3fae847f3
commit 2502befb42
469 changed files with 3915 additions and 3965 deletions
Download Patch File Download Diff File Expand all files Collapse all files

172
src/test/consensus/Validations_test.cpp
View File

@@ -233,12 +233,12 @@ class Validations_test : public beast::unit_test::suite
testcase("Add validation");
LedgerHistoryHelper h;
Ledger ledgerA = h["a"];
Ledger const ledgerA = h["a"];
Ledger ledgerAB = h["ab"];
Ledger ledgerAZ = h["az"];
Ledger ledgerABC = h["abc"];
Ledger ledgerABCD = h["abcd"];
Ledger ledgerABCDE = h["abcde"];
Ledger const ledgerABCD = h["abcd"];
Ledger const ledgerABCDE = h["abcde"];
{
TestHarness harness(h.oracle);
@@ -296,7 +296,7 @@ class Validations_test : public beast::unit_test::suite
// Process validations out of order with shifted times
TestHarness harness(h.oracle);
Node n = harness.makeNode();
Node const n = harness.makeNode();
// Establish a new current validation
BEAST_EXPECT(ValStatus::current == harness.add(n.validate(ledgerA)));
@@ -312,7 +312,7 @@ class Validations_test : public beast::unit_test::suite
{
// Test stale on arrival validations
TestHarness harness(h.oracle);
Node n = harness.makeNode();
Node const n = harness.makeNode();
BEAST_EXPECT(
ValStatus::stale ==
@@ -364,11 +364,11 @@ class Validations_test : public beast::unit_test::suite
LedgerHistoryHelper h;
Ledger ledgerA = h["a"];
Ledger ledgerAB = h["ab"];
Ledger const ledgerAB = h["ab"];
using Trigger = std::function<void(TestValidations&)>;
std::vector<Trigger> triggers = {
std::vector<Trigger> const triggers = {
[&](TestValidations& vals) { vals.currentTrusted(); },
[&](TestValidations& vals) { vals.getCurrentNodeIDs(); },
[&](TestValidations& vals) { vals.getPreferred(genesisLedger); },
@@ -376,7 +376,7 @@ class Validations_test : public beast::unit_test::suite
for (Trigger const& trigger : triggers)
{
TestHarness harness(h.oracle);
Node n = harness.makeNode();
Node const n = harness.makeNode();
BEAST_EXPECT(ValStatus::current == harness.add(n.validate(ledgerAB)));
trigger(harness.vals());
@@ -405,39 +405,41 @@ class Validations_test : public beast::unit_test::suite
testcase("Get nodes after");
LedgerHistoryHelper h;
Ledger ledgerA = h["a"];
Ledger ledgerAB = h["ab"];
Ledger ledgerABC = h["abc"];
Ledger ledgerAD = h["ad"];
Ledger const ledgerA = h["a"];
Ledger const ledgerAB = h["ab"];
Ledger const ledgerABC = h["abc"];
Ledger const ledgerAD = h["ad"];
TestHarness harness(h.oracle);
Node a = harness.makeNode(), b = harness.makeNode(), c = harness.makeNode(),
d = harness.makeNode();
c.untrust();
Node const trustedNode1 = harness.makeNode();
Node const trustedNode2 = harness.makeNode();
Node const trustedNode3 = harness.makeNode();
Node notTrustedNode = harness.makeNode();
notTrustedNode.untrust();
// first round a,b,c agree, d has is partial
BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerA)));
BEAST_EXPECT(ValStatus::current == harness.add(b.validate(ledgerA)));
BEAST_EXPECT(ValStatus::current == harness.add(c.validate(ledgerA)));
BEAST_EXPECT(ValStatus::current == harness.add(d.partial(ledgerA)));
BEAST_EXPECT(ValStatus::current == harness.add(trustedNode1.validate(ledgerA)));
BEAST_EXPECT(ValStatus::current == harness.add(trustedNode2.validate(ledgerA)));
BEAST_EXPECT(ValStatus::current == harness.add(notTrustedNode.validate(ledgerA)));
BEAST_EXPECT(ValStatus::current == harness.add(trustedNode3.partial(ledgerA)));
for (Ledger const& ledger : {ledgerA, ledgerAB, ledgerABC, ledgerAD})
BEAST_EXPECT(harness.vals().getNodesAfter(ledger, ledger.id()) == 0);
harness.clock().advance(5s);
BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerAB)));
BEAST_EXPECT(ValStatus::current == harness.add(b.validate(ledgerABC)));
BEAST_EXPECT(ValStatus::current == harness.add(c.validate(ledgerAB)));
BEAST_EXPECT(ValStatus::current == harness.add(d.partial(ledgerABC)));
BEAST_EXPECT(ValStatus::current == harness.add(trustedNode1.validate(ledgerAB)));
BEAST_EXPECT(ValStatus::current == harness.add(trustedNode2.validate(ledgerABC)));
BEAST_EXPECT(ValStatus::current == harness.add(notTrustedNode.validate(ledgerAB)));
BEAST_EXPECT(ValStatus::current == harness.add(trustedNode3.partial(ledgerABC)));
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerA, ledgerA.id()) == 3);
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAB, ledgerAB.id()) == 2);
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerABC, ledgerABC.id()) == 0);
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAD, ledgerAD.id()) == 0);
// If given a ledger inconsistent with the id, is still able to check
// using slower method
// If given a ledger inconsistent with the id, is still able to check using slower method
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAD, ledgerA.id()) == 1);
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAD, ledgerAB.id()) == 2);
}
@@ -449,12 +451,13 @@ class Validations_test : public beast::unit_test::suite
testcase("Current trusted validations");
LedgerHistoryHelper h;
Ledger ledgerA = h["a"];
Ledger ledgerB = h["b"];
Ledger ledgerAC = h["ac"];
Ledger const ledgerA = h["a"];
Ledger const ledgerB = h["b"];
Ledger const ledgerAC = h["ac"];
TestHarness harness(h.oracle);
Node a = harness.makeNode(), b = harness.makeNode();
Node const a = harness.makeNode();
Node b = harness.makeNode();
b.untrust();
BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerA)));
@@ -487,8 +490,8 @@ class Validations_test : public beast::unit_test::suite
testcase("Current public keys");
LedgerHistoryHelper h;
Ledger ledgerA = h["a"];
Ledger ledgerAC = h["ac"];
Ledger const ledgerA = h["a"];
Ledger const ledgerAC = h["ac"];
TestHarness harness(h.oracle);
Node a = harness.makeNode(), b = harness.makeNode();
@@ -567,7 +570,7 @@ class Validations_test : public beast::unit_test::suite
sorted(harness.vals().getTrustedForLedger(id, seq)) ==
sorted(expectedValidations));
std::uint32_t baseFee = 0;
std::uint32_t const baseFee = 0;
std::vector<uint32_t> expectedFees;
expectedFees.reserve(expectedValidations.size());
for (auto const& val : expectedValidations)
@@ -580,9 +583,9 @@ class Validations_test : public beast::unit_test::suite
};
//----------------------------------------------------------------------
Ledger ledgerA = h["a"];
Ledger ledgerB = h["b"];
Ledger ledgerAC = h["ac"];
Ledger const ledgerA = h["a"];
Ledger const ledgerB = h["b"];
Ledger const ledgerAC = h["ac"];
// Add a dummy ID to cover unknown ledger identifiers
trustedValidations[{Ledger::ID{100}, Ledger::Seq{100}}] = {};
@@ -689,14 +692,16 @@ class Validations_test : public beast::unit_test::suite
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node a = harness.makeNode(), b = harness.makeNode(), c = harness.makeNode();
c.untrust();
Node const trustedNode1 = harness.makeNode();
Node const trustedNode2 = harness.makeNode();
Node notTrustedNode = harness.makeNode();
notTrustedNode.untrust();
Ledger ledgerA = h["a"];
Ledger ledgerAB = h["ab"];
Ledger const ledgerA = h["a"];
Ledger const ledgerAB = h["ab"];
hash_map<PeerID, Validation> expected;
for (auto const& node : {a, b, c})
for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode})
{
auto const val = node.validate(ledgerA);
BEAST_EXPECT(ValStatus::current == harness.add(val));
@@ -706,9 +711,9 @@ class Validations_test : public beast::unit_test::suite
// Send in a new validation for a, saving the new one into the expected
// map after setting the proper prior ledger ID it replaced
harness.clock().advance(1s);
auto newVal = a.validate(ledgerAB);
auto newVal = trustedNode1.validate(ledgerAB);
BEAST_EXPECT(ValStatus::current == harness.add(newVal));
expected.find(a.nodeID())->second = newVal;
expected.find(trustedNode1.nodeID())->second = newVal;
}
void
@@ -719,14 +724,17 @@ class Validations_test : public beast::unit_test::suite
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node a = harness.makeNode(), b = harness.makeNode(), c = harness.makeNode(),
d = harness.makeNode();
c.untrust();
Node const trustedNode1 = harness.makeNode();
Node const trustedNode2 = harness.makeNode();
Node const trustedNode3 = harness.makeNode();
Ledger ledgerA = h["a"];
Ledger ledgerB = h["b"];
Ledger ledgerAC = h["ac"];
Ledger ledgerACD = h["acd"];
Node notTrustedNode = harness.makeNode();
notTrustedNode.untrust();
Ledger const ledgerA = h["a"];
Ledger const ledgerB = h["b"];
Ledger const ledgerAC = h["ac"];
Ledger const ledgerACD = h["acd"];
using Seq = Ledger::Seq;
@@ -736,7 +744,7 @@ class Validations_test : public beast::unit_test::suite
BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == std::nullopt);
// Single ledger
BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerB)));
BEAST_EXPECT(ValStatus::current == harness.add(trustedNode1.validate(ledgerB)));
BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerB));
BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerB));
@@ -745,21 +753,21 @@ class Validations_test : public beast::unit_test::suite
// Untrusted doesn't impact preferred ledger
// (ledgerB has tie-break over ledgerA)
BEAST_EXPECT(ValStatus::current == harness.add(b.validate(ledgerA)));
BEAST_EXPECT(ValStatus::current == harness.add(c.validate(ledgerA)));
BEAST_EXPECT(ValStatus::current == harness.add(trustedNode2.validate(ledgerA)));
BEAST_EXPECT(ValStatus::current == harness.add(notTrustedNode.validate(ledgerA)));
BEAST_EXPECT(ledgerB.id() > ledgerA.id());
BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerB));
BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerB));
// Partial does break ties
BEAST_EXPECT(ValStatus::current == harness.add(d.partial(ledgerA)));
BEAST_EXPECT(ValStatus::current == harness.add(trustedNode3.partial(ledgerA)));
BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerA));
harness.clock().advance(5s);
// Parent of preferred-> stick with ledger
for (auto const& node : {a, b, c, d})
for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode, trustedNode3})
BEAST_EXPECT(ValStatus::current == harness.add(node.validate(ledgerAC)));
// Parent of preferred stays put
BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
@@ -770,7 +778,7 @@ class Validations_test : public beast::unit_test::suite
// Any later grandchild or different chain is preferred
harness.clock().advance(5s);
for (auto const& node : {a, b, c, d})
for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode, trustedNode3})
BEAST_EXPECT(ValStatus::current == harness.add(node.validate(ledgerACD)));
for (auto const& ledger : {ledgerA, ledgerB, ledgerACD})
BEAST_EXPECT(harness.vals().getPreferred(ledger) == pref(ledgerACD));
@@ -784,11 +792,11 @@ class Validations_test : public beast::unit_test::suite
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node a = harness.makeNode();
Node const a = harness.makeNode();
Ledger ledgerA = h["a"];
Ledger ledgerB = h["b"];
Ledger ledgerC = h["c"];
Ledger const ledgerA = h["a"];
Ledger const ledgerB = h["b"];
Ledger const ledgerC = h["c"];
using ID = Ledger::ID;
using Seq = Ledger::Seq;
@@ -830,14 +838,14 @@ class Validations_test : public beast::unit_test::suite
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node a = harness.makeNode();
Node b = harness.makeNode();
Node const a = harness.makeNode();
Node const b = harness.makeNode();
using ID = Ledger::ID;
using Seq = Ledger::Seq;
// Validate the ledger before it is actually available
Validation val = a.validate(ID{2}, Seq{2}, 0s, 0s, true);
Validation const val = a.validate(ID{2}, Seq{2}, 0s, 0s, true);
BEAST_EXPECT(ValStatus::current == harness.add(val));
// Validation is available
@@ -854,13 +862,13 @@ class Validations_test : public beast::unit_test::suite
BEAST_EXPECT(harness.vals().getPreferred(genesisLedger) == std::make_pair(Seq{2}, ID{3}));
// Create the ledger
Ledger ledgerAB = h["ab"];
Ledger const ledgerAB = h["ab"];
// Now it should be available
BEAST_EXPECT(harness.vals().getNodesAfter(genesisLedger, ID{0}) == 1);
// Create a validation that is not available
harness.clock().advance(5s);
Validation val2 = a.validate(ID{4}, Seq{4}, 0s, 0s, true);
Validation const val2 = a.validate(ID{4}, Seq{4}, 0s, 0s, true);
BEAST_EXPECT(ValStatus::current == harness.add(val2));
BEAST_EXPECT(harness.vals().numTrustedForLedger(ID{4}) == 1);
BEAST_EXPECT(
@@ -868,7 +876,7 @@ class Validations_test : public beast::unit_test::suite
std::make_pair(ledgerAB.seq(), ledgerAB.id()));
// Another node requesting that ledger still doesn't change things
Validation val3 = b.validate(ID{4}, Seq{4}, 0s, 0s, true);
Validation const val3 = b.validate(ID{4}, Seq{4}, 0s, 0s, true);
BEAST_EXPECT(ValStatus::current == harness.add(val3));
BEAST_EXPECT(harness.vals().numTrustedForLedger(ID{4}) == 2);
BEAST_EXPECT(
@@ -877,7 +885,7 @@ class Validations_test : public beast::unit_test::suite
// Switch to validation that is available
harness.clock().advance(5s);
Ledger ledgerABCDE = h["abcde"];
Ledger const ledgerABCDE = h["abcde"];
BEAST_EXPECT(ValStatus::current == harness.add(a.partial(ledgerABCDE)));
BEAST_EXPECT(ValStatus::current == harness.add(b.partial(ledgerABCDE)));
BEAST_EXPECT(
@@ -891,9 +899,9 @@ class Validations_test : public beast::unit_test::suite
testcase("NumTrustedForLedger");
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node a = harness.makeNode();
Node b = harness.makeNode();
Ledger ledgerA = h["a"];
Node const a = harness.makeNode();
Node const b = harness.makeNode();
Ledger const ledgerA = h["a"];
BEAST_EXPECT(ValStatus::current == harness.add(a.partial(ledgerA)));
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 0);
@@ -912,7 +920,7 @@ class Validations_test : public beast::unit_test::suite
beast::manual_clock<steady_clock> clock;
SeqEnforcer<Seq> enforcer;
ValidationParms p;
ValidationParms const p;
BEAST_EXPECT(enforcer(clock.now(), Seq{1}, p));
BEAST_EXPECT(enforcer(clock.now(), Seq{10}, p));
@@ -934,9 +942,9 @@ class Validations_test : public beast::unit_test::suite
TestValidations& vals,
hash_set<PeerID> const& listed,
std::vector<Validation> const& trustedVals) {
Ledger::ID testID =
Ledger::ID const testID =
trustedVals.empty() ? this->genesisLedger.id() : trustedVals[0].ledgerID();
Ledger::Seq testSeq =
Ledger::Seq const testSeq =
trustedVals.empty() ? this->genesisLedger.seq() : trustedVals[0].seq();
BEAST_EXPECT(vals.currentTrusted() == trustedVals);
BEAST_EXPECT(vals.getCurrentNodeIDs() == listed);
@@ -958,12 +966,12 @@ class Validations_test : public beast::unit_test::suite
// Trusted to untrusted
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node a = harness.makeNode();
Ledger ledgerAB = h["ab"];
Validation v = a.validate(ledgerAB);
Node const a = harness.makeNode();
Ledger const ledgerAB = h["ab"];
Validation const v = a.validate(ledgerAB);
BEAST_EXPECT(ValStatus::current == harness.add(v));
hash_set<PeerID> listed({a.nodeID()});
hash_set<PeerID> const listed({a.nodeID()});
std::vector<Validation> trustedVals({v});
checker(harness.vals(), listed, trustedVals);
@@ -978,11 +986,11 @@ class Validations_test : public beast::unit_test::suite
TestHarness harness(h.oracle);
Node a = harness.makeNode();
a.untrust();
Ledger ledgerAB = h["ab"];
Validation v = a.validate(ledgerAB);
Ledger const ledgerAB = h["ab"];
Validation const v = a.validate(ledgerAB);
BEAST_EXPECT(ValStatus::current == harness.add(v));
hash_set<PeerID> listed({a.nodeID()});
hash_set<PeerID> const listed({a.nodeID()});
std::vector<Validation> trustedVals;
checker(harness.vals(), listed, trustedVals);
@@ -995,11 +1003,11 @@ class Validations_test : public beast::unit_test::suite
// Trusted but not acquired -> untrusted
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node a = harness.makeNode();
Validation v = a.validate(Ledger::ID{2}, Ledger::Seq{2}, 0s, 0s, true);
Node const a = harness.makeNode();
Validation const v = a.validate(Ledger::ID{2}, Ledger::Seq{2}, 0s, 0s, true);
BEAST_EXPECT(ValStatus::current == harness.add(v));
hash_set<PeerID> listed({a.nodeID()});
hash_set<PeerID> const listed({a.nodeID()});
std::vector<Validation> trustedVals({v});
auto& vals = harness.vals();
BEAST_EXPECT(vals.currentTrusted() == trustedVals);