rippled
Validations_test.cpp
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright (c) 2012-2017 Ripple Labs Inc.
5 
6  Permission to use, copy, modify, and/or distribute this software for any
7  purpose with or without fee is hereby granted, provided that the above
8  copyright notice and this permission notice appear in all copies.
9 
10  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 //==============================================================================
19 
20 #include <ripple/basics/tagged_integer.h>
21 #include <ripple/beast/clock/manual_clock.h>
22 #include <ripple/beast/unit_test.h>
23 #include <ripple/consensus/Validations.h>
24 #include <test/csf/Validation.h>
25 
26 #include <memory>
27 #include <tuple>
28 #include <type_traits>
29 #include <vector>
30 
31 namespace ripple {
32 namespace test {
33 namespace csf {
34 class Validations_test : public beast::unit_test::suite
35 {
36  using clock_type = beast::abstract_clock<std::chrono::steady_clock> const;
37 
38  // Helper to convert steady_clock to a reasonable NetClock
39  // This allows a single manual clock in the unit tests
40  static NetClock::time_point
41  toNetClock(clock_type const& c)
42  {
43  // We don't care about the actual epochs, but do want the
44  // generated NetClock time to be well past its epoch to ensure
45  // any subtractions are positive
46  using namespace std::chrono;
47  return NetClock::time_point(duration_cast<NetClock::duration>(
48  c.now().time_since_epoch() + 86400s));
49  }
50 
51  // Represents a node that can issue validations
52  class Node
53  {
54  clock_type const& c_;
55  PeerID nodeID_;
56  bool trusted_ = true;
57  std::size_t signIdx_{1};
58  std::optional<std::uint32_t> loadFee_;
59 
60  public:
61  Node(PeerID nodeID, clock_type const& c) : c_(c), nodeID_(nodeID)
62  {
63  }
64 
65  void
66  untrust()
67  {
68  trusted_ = false;
69  }
70 
71  void
72  trust()
73  {
74  trusted_ = true;
75  }
76 
77  void
78  setLoadFee(std::uint32_t fee)
79  {
80  loadFee_ = fee;
81  }
82 
83  PeerID
84  nodeID() const
85  {
86  return nodeID_;
87  }
88 
89  void
90  advanceKey()
91  {
92  signIdx_++;
93  }
94 
95  PeerKey
96  currKey() const
97  {
98  return std::make_pair(nodeID_, signIdx_);
99  }
100 
101  PeerKey
102  masterKey() const
103  {
104  return std::make_pair(nodeID_, 0);
105  }
106  NetClock::time_point
107  now() const
108  {
109  return toNetClock(c_);
110  }
111 
112  // Issue a new validation with given sequence number and id and
113  // with signing and seen times offset from the common clock
114  Validation
115  validate(
116  Ledger::ID id,
117  Ledger::Seq seq,
118  NetClock::duration signOffset,
119  NetClock::duration seenOffset,
120  bool full) const
121  {
122  Validation v{
123  id,
124  seq,
125  now() + signOffset,
126  now() + seenOffset,
127  currKey(),
128  nodeID_,
129  full,
130  loadFee_};
131  if (trusted_)
132  v.setTrusted();
133  return v;
134  }
135 
136  Validation
137  validate(
138  Ledger ledger,
139  NetClock::duration signOffset,
140  NetClock::duration seenOffset) const
141  {
142  return validate(
143  ledger.id(), ledger.seq(), signOffset, seenOffset, true);
144  }
145 
146  Validation
147  validate(Ledger ledger) const
148  {
149  return validate(
150  ledger.id(),
151  ledger.seq(),
152  NetClock::duration{0},
153  NetClock::duration{0},
154  true);
155  }
156 
157  Validation
158  partial(Ledger ledger) const
159  {
160  return validate(
161  ledger.id(),
162  ledger.seq(),
163  NetClock::duration{0},
164  NetClock::duration{0},
165  false);
166  }
167  };
168 
169  // Generic Validations adaptor
170  class Adaptor
171  {
172  clock_type& c_;
173  LedgerOracle& oracle_;
174 
175  public:
176  // Non-locking mutex to avoid locks in generic Validations
177  struct Mutex
178  {
179  void
180  lock()
181  {
182  }
183 
184  void
185  unlock()
186  {
187  }
188  };
189 
190  using Validation = csf::Validation;
191  using Ledger = csf::Ledger;
192 
193  Adaptor(clock_type& c, LedgerOracle& o) : c_{c}, oracle_{o}
194  {
195  }
196 
197  NetClock::time_point
198  now() const
199  {
200  return toNetClock(c_);
201  }
202 
203  std::optional<Ledger>
204  acquire(Ledger::ID const& id)
205  {
206  return oracle_.lookup(id);
207  }
208  };
209 
210  // Specialize generic Validations using the above types
211  using TestValidations = Validations<Adaptor>;
212 
213  // Gather the dependencies of TestValidations in a single class and provide
214  // accessors for simplifying test logic
215  class TestHarness
216  {
217  ValidationParms p_;
218  beast::manual_clock<std::chrono::steady_clock> clock_;
219  TestValidations tv_;
220  PeerID nextNodeId_{0};
221 
222  public:
223  explicit TestHarness(LedgerOracle& o) : tv_(p_, clock_, clock_, o)
224  {
225  }
226 
227  ValStatus
228  add(Validation const& v)
229  {
230  return tv_.add(v.nodeID(), v);
231  }
232 
233  TestValidations&
234  vals()
235  {
236  return tv_;
237  }
238 
239  Node
240  makeNode()
241  {
242  return Node(nextNodeId_++, clock_);
243  }
244 
245  ValidationParms
246  parms() const
247  {
248  return p_;
249  }
250 
251  auto&
252  clock()
253  {
254  return clock_;
255  }
256  };
257 
258  Ledger const genesisLedger{Ledger::MakeGenesis{}};
259 
260  void
261  testAddValidation()
262  {
263  using namespace std::chrono_literals;
264 
265  testcase("Add validation");
266  LedgerHistoryHelper h;
267  Ledger ledgerA = h["a"];
268  Ledger ledgerAB = h["ab"];
269  Ledger ledgerAZ = h["az"];
270  Ledger ledgerABC = h["abc"];
271  Ledger ledgerABCD = h["abcd"];
272  Ledger ledgerABCDE = h["abcde"];
273 
274  {
275  TestHarness harness(h.oracle);
276  Node n = harness.makeNode();
277 
278  auto const v = n.validate(ledgerA);
279 
280  // Add a current validation
281  BEAST_EXPECT(ValStatus::current == harness.add(v));
282 
283  // Re-adding violates the increasing seq requirement for full
284  // validations
285  BEAST_EXPECT(ValStatus::badSeq == harness.add(v));
286 
287  harness.clock().advance(1s);
288 
289  BEAST_EXPECT(
290  ValStatus::current == harness.add(n.validate(ledgerAB)));
291 
292  // Test the node changing signing key
293 
294  // Confirm old ledger on hand, but not new ledger
295  BEAST_EXPECT(
296  harness.vals().numTrustedForLedger(ledgerAB.id()) == 1);
297  BEAST_EXPECT(
298  harness.vals().numTrustedForLedger(ledgerABC.id()) == 0);
299 
300  // Rotate signing keys
301  n.advanceKey();
302 
303  harness.clock().advance(1s);
304 
305  // Cannot re-do the same full validation sequence
306  BEAST_EXPECT(
307  ValStatus::conflicting == harness.add(n.validate(ledgerAB)));
308  // Cannot send the same partial validation sequence
309  BEAST_EXPECT(
310  ValStatus::conflicting == harness.add(n.partial(ledgerAB)));
311 
312  // Now trusts the newest ledger too
313  harness.clock().advance(1s);
314  BEAST_EXPECT(
315  ValStatus::current == harness.add(n.validate(ledgerABC)));
316  BEAST_EXPECT(
317  harness.vals().numTrustedForLedger(ledgerAB.id()) == 1);
318  BEAST_EXPECT(
319  harness.vals().numTrustedForLedger(ledgerABC.id()) == 1);
320 
321  // Processing validations out of order should ignore the older
322  // validation
323  harness.clock().advance(2s);
324  auto const valABCDE = n.validate(ledgerABCDE);
325 
326  harness.clock().advance(4s);
327  auto const valABCD = n.validate(ledgerABCD);
328 
329  BEAST_EXPECT(ValStatus::current == harness.add(valABCD));
330 
331  BEAST_EXPECT(ValStatus::stale == harness.add(valABCDE));
332  }
333 
334  {
335  // Process validations out of order with shifted times
336 
337  TestHarness harness(h.oracle);
338  Node n = harness.makeNode();
339 
340  // Establish a new current validation
341  BEAST_EXPECT(
342  ValStatus::current == harness.add(n.validate(ledgerA)));
343 
344  // Process a validation that has "later" seq but early sign time
345  BEAST_EXPECT(
346  ValStatus::stale ==
347  harness.add(n.validate(ledgerAB, -1s, -1s)));
348 
349  // Process a validation that has a later seq and later sign
350  // time
351  BEAST_EXPECT(
352  ValStatus::current ==
353  harness.add(n.validate(ledgerABC, 1s, 1s)));
354  }
355 
356  {
357  // Test stale on arrival validations
358  TestHarness harness(h.oracle);
359  Node n = harness.makeNode();
360 
361  BEAST_EXPECT(
362  ValStatus::stale ==
363  harness.add(n.validate(
364  ledgerA, -harness.parms().validationCURRENT_EARLY, 0s)));
365 
366  BEAST_EXPECT(
367  ValStatus::stale ==
368  harness.add(n.validate(
369  ledgerA, harness.parms().validationCURRENT_WALL, 0s)));
370 
371  BEAST_EXPECT(
372  ValStatus::stale ==
373  harness.add(n.validate(
374  ledgerA, 0s, harness.parms().validationCURRENT_LOCAL)));
375  }
376 
377  {
378  // Test that full or partials cannot be sent for older sequence
379  // numbers, unless time-out has happened
380  for (bool doFull : {true, false})
381  {
382  TestHarness harness(h.oracle);
383  Node n = harness.makeNode();
384 
385  auto process = [&](Ledger& lgr) {
386  if (doFull)
387  return harness.add(n.validate(lgr));
388  return harness.add(n.partial(lgr));
389  };
390 
391  BEAST_EXPECT(ValStatus::current == process(ledgerABC));
392  harness.clock().advance(1s);
393  BEAST_EXPECT(ledgerAB.seq() < ledgerABC.seq());
394  BEAST_EXPECT(ValStatus::badSeq == process(ledgerAB));
395 
396  // If we advance far enough for AB to expire, we can fully
397  // validate or partially validate that sequence number again
398  BEAST_EXPECT(ValStatus::conflicting == process(ledgerAZ));
399  harness.clock().advance(
400  harness.parms().validationSET_EXPIRES + 1ms);
401  BEAST_EXPECT(ValStatus::current == process(ledgerAZ));
402  }
403  }
404  }
405 
406  void
407  testOnStale()
408  {
409  testcase("Stale validation");
410  // Verify validation becomes stale based solely on time passing, but
411  // use different functions to trigger the check for staleness
412 
413  LedgerHistoryHelper h;
414  Ledger ledgerA = h["a"];
415  Ledger ledgerAB = h["ab"];
416 
417  using Trigger = std::function<void(TestValidations&)>;
418 
419  std::vector<Trigger> triggers = {
420  [&](TestValidations& vals) { vals.currentTrusted(); },
421  [&](TestValidations& vals) { vals.getCurrentNodeIDs(); },
422  [&](TestValidations& vals) { vals.getPreferred(genesisLedger); },
423  [&](TestValidations& vals) {
424  vals.getNodesAfter(ledgerA, ledgerA.id());
425  }};
426  for (Trigger trigger : triggers)
427  {
428  TestHarness harness(h.oracle);
429  Node n = harness.makeNode();
430 
431  BEAST_EXPECT(
432  ValStatus::current == harness.add(n.validate(ledgerAB)));
433  trigger(harness.vals());
434  BEAST_EXPECT(
435  harness.vals().getNodesAfter(ledgerA, ledgerA.id()) == 1);
436  BEAST_EXPECT(
437  harness.vals().getPreferred(genesisLedger) ==
438  std::make_pair(ledgerAB.seq(), ledgerAB.id()));
439  harness.clock().advance(harness.parms().validationCURRENT_LOCAL);
440 
441  // trigger check for stale
442  trigger(harness.vals());
443 
444  BEAST_EXPECT(
445  harness.vals().getNodesAfter(ledgerA, ledgerA.id()) == 0);
446  BEAST_EXPECT(
447  harness.vals().getPreferred(genesisLedger) == std::nullopt);
448  }
449  }
450 
451  void
452  testGetNodesAfter()
453  {
454  // Test getting number of nodes working on a validation descending
455  // a prescribed one. This count should only be for trusted nodes, but
456  // includes partial and full validations
457 
458  using namespace std::chrono_literals;
459  testcase("Get nodes after");
460 
461  LedgerHistoryHelper h;
462  Ledger ledgerA = h["a"];
463  Ledger ledgerAB = h["ab"];
464  Ledger ledgerABC = h["abc"];
465  Ledger ledgerAD = h["ad"];
466 
467  TestHarness harness(h.oracle);
468  Node a = harness.makeNode(), b = harness.makeNode(),
469  c = harness.makeNode(), d = harness.makeNode();
470  c.untrust();
471 
472  // first round a,b,c agree, d has is partial
473  BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerA)));
474  BEAST_EXPECT(ValStatus::current == harness.add(b.validate(ledgerA)));
475  BEAST_EXPECT(ValStatus::current == harness.add(c.validate(ledgerA)));
476  BEAST_EXPECT(ValStatus::current == harness.add(d.partial(ledgerA)));
477 
478  for (Ledger const& ledger : {ledgerA, ledgerAB, ledgerABC, ledgerAD})
479  BEAST_EXPECT(
480  harness.vals().getNodesAfter(ledger, ledger.id()) == 0);
481 
482  harness.clock().advance(5s);
483 
484  BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerAB)));
485  BEAST_EXPECT(ValStatus::current == harness.add(b.validate(ledgerABC)));
486  BEAST_EXPECT(ValStatus::current == harness.add(c.validate(ledgerAB)));
487  BEAST_EXPECT(ValStatus::current == harness.add(d.partial(ledgerABC)));
488 
489  BEAST_EXPECT(harness.vals().getNodesAfter(ledgerA, ledgerA.id()) == 3);
490  BEAST_EXPECT(
491  harness.vals().getNodesAfter(ledgerAB, ledgerAB.id()) == 2);
492  BEAST_EXPECT(
493  harness.vals().getNodesAfter(ledgerABC, ledgerABC.id()) == 0);
494  BEAST_EXPECT(
495  harness.vals().getNodesAfter(ledgerAD, ledgerAD.id()) == 0);
496 
497  // If given a ledger inconsistent with the id, is still able to check
498  // using slower method
499  BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAD, ledgerA.id()) == 1);
500  BEAST_EXPECT(
501  harness.vals().getNodesAfter(ledgerAD, ledgerAB.id()) == 2);
502  }
503 
504  void
505  testCurrentTrusted()
506  {
507  using namespace std::chrono_literals;
508  testcase("Current trusted validations");
509 
510  LedgerHistoryHelper h;
511  Ledger ledgerA = h["a"];
512  Ledger ledgerB = h["b"];
513  Ledger ledgerAC = h["ac"];
514 
515  TestHarness harness(h.oracle);
516  Node a = harness.makeNode(), b = harness.makeNode();
517  b.untrust();
518 
519  BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerA)));
520  BEAST_EXPECT(ValStatus::current == harness.add(b.validate(ledgerB)));
521 
522  // Only a is trusted
523  BEAST_EXPECT(harness.vals().currentTrusted().size() == 1);
524  BEAST_EXPECT(
525  harness.vals().currentTrusted()[0].ledgerID() == ledgerA.id());
526  BEAST_EXPECT(harness.vals().currentTrusted()[0].seq() == ledgerA.seq());
527 
528  harness.clock().advance(3s);
529 
530  for (auto const& node : {a, b})
531  BEAST_EXPECT(
532  ValStatus::current == harness.add(node.validate(ledgerAC)));
533 
534  // New validation for a
535  BEAST_EXPECT(harness.vals().currentTrusted().size() == 1);
536  BEAST_EXPECT(
537  harness.vals().currentTrusted()[0].ledgerID() == ledgerAC.id());
538  BEAST_EXPECT(
539  harness.vals().currentTrusted()[0].seq() == ledgerAC.seq());
540 
541  // Pass enough time for it to go stale
542  harness.clock().advance(harness.parms().validationCURRENT_LOCAL);
543  BEAST_EXPECT(harness.vals().currentTrusted().empty());
544  }
545 
546  void
547  testGetCurrentPublicKeys()
548  {
549  using namespace std::chrono_literals;
550  testcase("Current public keys");
551 
552  LedgerHistoryHelper h;
553  Ledger ledgerA = h["a"];
554  Ledger ledgerAC = h["ac"];
555 
556  TestHarness harness(h.oracle);
557  Node a = harness.makeNode(), b = harness.makeNode();
558  b.untrust();
559 
560  for (auto const& node : {a, b})
561  BEAST_EXPECT(
562  ValStatus::current == harness.add(node.validate(ledgerA)));
563 
564  {
565  hash_set<PeerID> const expectedKeys = {a.nodeID(), b.nodeID()};
566  BEAST_EXPECT(harness.vals().getCurrentNodeIDs() == expectedKeys);
567  }
568 
569  harness.clock().advance(3s);
570 
571  // Change keys and issue partials
572  a.advanceKey();
573  b.advanceKey();
574 
575  for (auto const& node : {a, b})
576  BEAST_EXPECT(
577  ValStatus::current == harness.add(node.partial(ledgerAC)));
578 
579  {
580  hash_set<PeerID> const expectedKeys = {a.nodeID(), b.nodeID()};
581  BEAST_EXPECT(harness.vals().getCurrentNodeIDs() == expectedKeys);
582  }
583 
584  // Pass enough time for them to go stale
585  harness.clock().advance(harness.parms().validationCURRENT_LOCAL);
586  BEAST_EXPECT(harness.vals().getCurrentNodeIDs().empty());
587  }
588 
589  void
590  testTrustedByLedgerFunctions()
591  {
592  // Test the Validations functions that calculate a value by ledger ID
593  using namespace std::chrono_literals;
594  testcase("By ledger functions");
595 
596  // Several Validations functions return a set of values associated
597  // with trusted ledgers sharing the same ledger ID. The tests below
598  // exercise this logic by saving the set of trusted Validations, and
599  // verifying that the Validations member functions all calculate the
600  // proper transformation of the available ledgers.
601 
602  LedgerHistoryHelper h;
603  TestHarness harness(h.oracle);
604 
605  Node a = harness.makeNode(), b = harness.makeNode(),
606  c = harness.makeNode(), d = harness.makeNode(),
607  e = harness.makeNode();
608 
609  c.untrust();
610  // Mix of load fees
611  a.setLoadFee(12);
612  b.setLoadFee(1);
613  c.setLoadFee(12);
614  e.setLoadFee(12);
615 
616  hash_map<Ledger::ID, std::vector<Validation>> trustedValidations;
617 
618  //----------------------------------------------------------------------
619  // checkers
620  auto sorted = [](auto vec) {
621  std::sort(vec.begin(), vec.end());
622  return vec;
623  };
624  auto compare = [&]() {
625  for (auto& it : trustedValidations)
626  {
627  auto const& id = it.first;
628  auto const& expectedValidations = it.second;
629 
630  BEAST_EXPECT(
631  harness.vals().numTrustedForLedger(id) ==
632  expectedValidations.size());
633  BEAST_EXPECT(
634  sorted(harness.vals().getTrustedForLedger(id)) ==
635  sorted(expectedValidations));
636 
637  std::uint32_t baseFee = 0;
638  std::vector<uint32_t> expectedFees;
639  for (auto const& val : expectedValidations)
640  {
641  expectedFees.push_back(val.loadFee().value_or(baseFee));
642  }
643 
644  BEAST_EXPECT(
645  sorted(harness.vals().fees(id, baseFee)) ==
646  sorted(expectedFees));
647  }
648  };
649 
650  //----------------------------------------------------------------------
651  Ledger ledgerA = h["a"];
652  Ledger ledgerB = h["b"];
653  Ledger ledgerAC = h["ac"];
654 
655  // Add a dummy ID to cover unknown ledger identifiers
656  trustedValidations[Ledger::ID{100}] = {};
657 
658  // first round a,b,c agree
659  for (auto const& node : {a, b, c})
660  {
661  auto const val = node.validate(ledgerA);
662  BEAST_EXPECT(ValStatus::current == harness.add(val));
663  if (val.trusted())
664  trustedValidations[val.ledgerID()].emplace_back(val);
665  }
666  // d disagrees
667  {
668  auto const val = d.validate(ledgerB);
669  BEAST_EXPECT(ValStatus::current == harness.add(val));
670  trustedValidations[val.ledgerID()].emplace_back(val);
671  }
672  // e only issues partials
673  {
674  BEAST_EXPECT(ValStatus::current == harness.add(e.partial(ledgerA)));
675  }
676 
677  harness.clock().advance(5s);
678  // second round, a,b,c move to ledger 2
679  for (auto const& node : {a, b, c})
680  {
681  auto const val = node.validate(ledgerAC);
682  BEAST_EXPECT(ValStatus::current == harness.add(val));
683  if (val.trusted())
684  trustedValidations[val.ledgerID()].emplace_back(val);
685  }
686  // d now thinks ledger 1, but cannot re-issue a previously used seq
687  // and attempting it should generate a conflict.
688  {
689  BEAST_EXPECT(
690  ValStatus::conflicting == harness.add(d.partial(ledgerA)));
691  }
692  // e only issues partials
693  {
694  BEAST_EXPECT(
695  ValStatus::current == harness.add(e.partial(ledgerAC)));
696  }
697 
698  compare();
699  }
700 
701  void
702  testExpire()
703  {
704  // Verify expiring clears out validations stored by ledger
705  testcase("Expire validations");
706  LedgerHistoryHelper h;
707  TestHarness harness(h.oracle);
708  Node a = harness.makeNode();
709 
710  Ledger ledgerA = h["a"];
711  BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerA)));
712  BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()));
713 
714  // Keep the validation from expire
715  harness.clock().advance(harness.parms().validationSET_EXPIRES);
716  harness.vals().setSeqToKeep(ledgerA.seq());
717  harness.vals().expire();
718  BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()));
719 
720  // Allow the validation to expire
721  harness.clock().advance(harness.parms().validationSET_EXPIRES);
722  harness.vals().setSeqToKeep(++ledgerA.seq());
723  harness.vals().expire();
724  BEAST_EXPECT(!harness.vals().numTrustedForLedger(ledgerA.id()));
725  }
726 
727  void
728  testFlush()
729  {
730  // Test final flush of validations
731  using namespace std::chrono_literals;
732  testcase("Flush validations");
733 
734  LedgerHistoryHelper h;
735  TestHarness harness(h.oracle);
736  Node a = harness.makeNode(), b = harness.makeNode(),
737  c = harness.makeNode();
738  c.untrust();
739 
740  Ledger ledgerA = h["a"];
741  Ledger ledgerAB = h["ab"];
742 
743  hash_map<PeerID, Validation> expected;
744  for (auto const& node : {a, b, c})
745  {
746  auto const val = node.validate(ledgerA);
747  BEAST_EXPECT(ValStatus::current == harness.add(val));
748  expected.emplace(node.nodeID(), val);
749  }
750 
751  // Send in a new validation for a, saving the new one into the expected
752  // map after setting the proper prior ledger ID it replaced
753  harness.clock().advance(1s);
754  auto newVal = a.validate(ledgerAB);
755  BEAST_EXPECT(ValStatus::current == harness.add(newVal));
756  expected.find(a.nodeID())->second = newVal;
757  }
758 
759  void
760  testGetPreferredLedger()
761  {
762  using namespace std::chrono_literals;
763  testcase("Preferred Ledger");
764 
765  LedgerHistoryHelper h;
766  TestHarness harness(h.oracle);
767  Node a = harness.makeNode(), b = harness.makeNode(),
768  c = harness.makeNode(), d = harness.makeNode();
769  c.untrust();
770 
771  Ledger ledgerA = h["a"];
772  Ledger ledgerB = h["b"];
773  Ledger ledgerAC = h["ac"];
774  Ledger ledgerACD = h["acd"];
775 
776  using Seq = Ledger::Seq;
777  using ID = Ledger::ID;
778 
779  auto pref = [](Ledger ledger) {
780  return std::make_pair(ledger.seq(), ledger.id());
781  };
782 
783  // Empty (no ledgers)
784  BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == std::nullopt);
785 
786  // Single ledger
787  BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerB)));
788  BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerB));
789  BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerB));
790 
791  // Minimum valid sequence
792  BEAST_EXPECT(
793  harness.vals().getPreferred(ledgerA, Seq{10}) == ledgerA.id());
794 
795  // Untrusted doesn't impact preferred ledger
796  // (ledgerB has tie-break over ledgerA)
797  BEAST_EXPECT(ValStatus::current == harness.add(b.validate(ledgerA)));
798  BEAST_EXPECT(ValStatus::current == harness.add(c.validate(ledgerA)));
799  BEAST_EXPECT(ledgerB.id() > ledgerA.id());
800  BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerB));
801  BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerB));
802 
803  // Partial does break ties
804  BEAST_EXPECT(ValStatus::current == harness.add(d.partial(ledgerA)));
805  BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
806  BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerA));
807 
808  harness.clock().advance(5s);
809 
810  // Parent of preferred-> stick with ledger
811  for (auto const& node : {a, b, c, d})
812  BEAST_EXPECT(
813  ValStatus::current == harness.add(node.validate(ledgerAC)));
814  // Parent of preferred stays put
815  BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
816  // Earlier different chain, switch
817  BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerAC));
818  // Later on chain, stays where it is
819  BEAST_EXPECT(harness.vals().getPreferred(ledgerACD) == pref(ledgerACD));
820 
821  // Any later grandchild or different chain is preferred
822  harness.clock().advance(5s);
823  for (auto const& node : {a, b, c, d})
824  BEAST_EXPECT(
825  ValStatus::current == harness.add(node.validate(ledgerACD)));
826  for (auto const& ledger : {ledgerA, ledgerB, ledgerACD})
827  BEAST_EXPECT(
828  harness.vals().getPreferred(ledger) == pref(ledgerACD));
829  }
830 
831  void
832  testGetPreferredLCL()
833  {
834  using namespace std::chrono_literals;
835  testcase("Get preferred LCL");
836 
837  LedgerHistoryHelper h;
838  TestHarness harness(h.oracle);
839  Node a = harness.makeNode();
840 
841  Ledger ledgerA = h["a"];
842  Ledger ledgerB = h["b"];
843  Ledger ledgerC = h["c"];
844 
845  using ID = Ledger::ID;
846  using Seq = Ledger::Seq;
847 
848  hash_map<ID, std::uint32_t> peerCounts;
849 
850  // No trusted validations or counts sticks with current ledger
851  BEAST_EXPECT(
852  harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) ==
853  ledgerA.id());
854 
855  ++peerCounts[ledgerB.id()];
856 
857  // No trusted validations, rely on peer counts
858  BEAST_EXPECT(
859  harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) ==
860  ledgerB.id());
861 
862  ++peerCounts[ledgerC.id()];
863  // No trusted validations, tied peers goes with larger ID
864  BEAST_EXPECT(ledgerC.id() > ledgerB.id());
865 
866  BEAST_EXPECT(
867  harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) ==
868  ledgerC.id());
869 
870  peerCounts[ledgerC.id()] += 1000;
871 
872  // Single trusted always wins over peer counts
873  BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerA)));
874  BEAST_EXPECT(
875  harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) ==
876  ledgerA.id());
877  BEAST_EXPECT(
878  harness.vals().getPreferredLCL(ledgerB, Seq{0}, peerCounts) ==
879  ledgerA.id());
880  BEAST_EXPECT(
881  harness.vals().getPreferredLCL(ledgerC, Seq{0}, peerCounts) ==
882  ledgerA.id());
883 
884  // Stick with current ledger if trusted validation ledger has too old
885  // of a sequence
886  BEAST_EXPECT(
887  harness.vals().getPreferredLCL(ledgerB, Seq{2}, peerCounts) ==
888  ledgerB.id());
889  }
890 
891  void
892  testAcquireValidatedLedger()
893  {
894  using namespace std::chrono_literals;
895  testcase("Acquire validated ledger");
896 
897  LedgerHistoryHelper h;
898  TestHarness harness(h.oracle);
899  Node a = harness.makeNode();
900  Node b = harness.makeNode();
901 
902  using ID = Ledger::ID;
903  using Seq = Ledger::Seq;
904 
905  // Validate the ledger before it is actually available
906  Validation val = a.validate(ID{2}, Seq{2}, 0s, 0s, true);
907 
908  BEAST_EXPECT(ValStatus::current == harness.add(val));
909  // Validation is available
910  BEAST_EXPECT(harness.vals().numTrustedForLedger(ID{2}) == 1);
911  // but ledger based data is not
912  BEAST_EXPECT(harness.vals().getNodesAfter(genesisLedger, ID{0}) == 0);
913  // Initial preferred branch falls back to the ledger we are trying to
914  // acquire
915  BEAST_EXPECT(
916  harness.vals().getPreferred(genesisLedger) ==
917  std::make_pair(Seq{2}, ID{2}));
918 
919  // After adding another unavailable validation, the preferred ledger
920  // breaks ties via higher ID
921  BEAST_EXPECT(
922  ValStatus::current ==
923  harness.add(b.validate(ID{3}, Seq{2}, 0s, 0s, true)));
924  BEAST_EXPECT(
925  harness.vals().getPreferred(genesisLedger) ==
926  std::make_pair(Seq{2}, ID{3}));
927 
928  // Create the ledger
929  Ledger ledgerAB = h["ab"];
930  // Now it should be available
931  BEAST_EXPECT(harness.vals().getNodesAfter(genesisLedger, ID{0}) == 1);
932 
933  // Create a validation that is not available
934  harness.clock().advance(5s);
935  Validation val2 = a.validate(ID{4}, Seq{4}, 0s, 0s, true);
936  BEAST_EXPECT(ValStatus::current == harness.add(val2));
937  BEAST_EXPECT(harness.vals().numTrustedForLedger(ID{4}) == 1);
938  BEAST_EXPECT(
939  harness.vals().getPreferred(genesisLedger) ==
940  std::make_pair(ledgerAB.seq(), ledgerAB.id()));
941 
942  // Another node requesting that ledger still doesn't change things
943  Validation val3 = b.validate(ID{4}, Seq{4}, 0s, 0s, true);
944  BEAST_EXPECT(ValStatus::current == harness.add(val3));
945  BEAST_EXPECT(harness.vals().numTrustedForLedger(ID{4}) == 2);
946  BEAST_EXPECT(
947  harness.vals().getPreferred(genesisLedger) ==
948  std::make_pair(ledgerAB.seq(), ledgerAB.id()));
949 
950  // Switch to validation that is available
951  harness.clock().advance(5s);
952  Ledger ledgerABCDE = h["abcde"];
953  BEAST_EXPECT(ValStatus::current == harness.add(a.partial(ledgerABCDE)));
954  BEAST_EXPECT(ValStatus::current == harness.add(b.partial(ledgerABCDE)));
955  BEAST_EXPECT(
956  harness.vals().getPreferred(genesisLedger) ==
957  std::make_pair(ledgerABCDE.seq(), ledgerABCDE.id()));
958  }
959 
960  void
961  testNumTrustedForLedger()
962  {
963  testcase("NumTrustedForLedger");
964  LedgerHistoryHelper h;
965  TestHarness harness(h.oracle);
966  Node a = harness.makeNode();
967  Node b = harness.makeNode();
968  Ledger ledgerA = h["a"];
969 
970  BEAST_EXPECT(ValStatus::current == harness.add(a.partial(ledgerA)));
971  BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 0);
972 
973  BEAST_EXPECT(ValStatus::current == harness.add(b.validate(ledgerA)));
974  BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 1);
975  }
976 
977  void
978  testSeqEnforcer()
979  {
980  testcase("SeqEnforcer");
981  using Seq = Ledger::Seq;
982  using namespace std::chrono;
983 
984  beast::manual_clock<steady_clock> clock;
985  SeqEnforcer<Seq> enforcer;
986 
987  ValidationParms p;
988 
989  BEAST_EXPECT(enforcer(clock.now(), Seq{1}, p));
990  BEAST_EXPECT(enforcer(clock.now(), Seq{10}, p));
991  BEAST_EXPECT(!enforcer(clock.now(), Seq{5}, p));
992  BEAST_EXPECT(!enforcer(clock.now(), Seq{9}, p));
993  clock.advance(p.validationSET_EXPIRES - 1ms);
994  BEAST_EXPECT(!enforcer(clock.now(), Seq{1}, p));
995  clock.advance(2ms);
996  BEAST_EXPECT(enforcer(clock.now(), Seq{1}, p));
997  }
998 
999  void
1000  testTrustChanged()
1001  {
1002  testcase("TrustChanged");
1003  using namespace std::chrono;
1004 
1005  auto checker = [this](
1006  TestValidations& vals,
1007  hash_set<PeerID> const& listed,
1008  std::vector<Validation> const& trustedVals) {
1009  Ledger::ID testID = trustedVals.empty() ? this->genesisLedger.id()
1010  : trustedVals[0].ledgerID();
1011  BEAST_EXPECT(vals.currentTrusted() == trustedVals);
1012  BEAST_EXPECT(vals.getCurrentNodeIDs() == listed);
1013  BEAST_EXPECT(
1014  vals.getNodesAfter(this->genesisLedger, genesisLedger.id()) ==
1015  trustedVals.size());
1016  if (trustedVals.empty())
1017  BEAST_EXPECT(
1018  vals.getPreferred(this->genesisLedger) == std::nullopt);
1019  else
1020  BEAST_EXPECT(
1021  vals.getPreferred(this->genesisLedger)->second == testID);
1022  BEAST_EXPECT(vals.getTrustedForLedger(testID) == trustedVals);
1023  BEAST_EXPECT(
1024  vals.numTrustedForLedger(testID) == trustedVals.size());
1025  };
1026 
1027  {
1028  // Trusted to untrusted
1029  LedgerHistoryHelper h;
1030  TestHarness harness(h.oracle);
1031  Node a = harness.makeNode();
1032  Ledger ledgerAB = h["ab"];
1033  Validation v = a.validate(ledgerAB);
1034  BEAST_EXPECT(ValStatus::current == harness.add(v));
1035 
1036  hash_set<PeerID> listed({a.nodeID()});
1037  std::vector<Validation> trustedVals({v});
1038  checker(harness.vals(), listed, trustedVals);
1039 
1040  trustedVals.clear();
1041  harness.vals().trustChanged({}, {a.nodeID()});
1042  checker(harness.vals(), listed, trustedVals);
1043  }
1044 
1045  {
1046  // Untrusted to trusted
1047  LedgerHistoryHelper h;
1048  TestHarness harness(h.oracle);
1049  Node a = harness.makeNode();
1050  a.untrust();
1051  Ledger ledgerAB = h["ab"];
1052  Validation v = a.validate(ledgerAB);
1053  BEAST_EXPECT(ValStatus::current == harness.add(v));
1054 
1055  hash_set<PeerID> listed({a.nodeID()});
1056  std::vector<Validation> trustedVals;
1057  checker(harness.vals(), listed, trustedVals);
1058 
1059  trustedVals.push_back(v);
1060  harness.vals().trustChanged({a.nodeID()}, {});
1061  checker(harness.vals(), listed, trustedVals);
1062  }
1063 
1064  {
1065  // Trusted but not acquired -> untrusted
1066  LedgerHistoryHelper h;
1067  TestHarness harness(h.oracle);
1068  Node a = harness.makeNode();
1069  Validation v =
1070  a.validate(Ledger::ID{2}, Ledger::Seq{2}, 0s, 0s, true);
1071  BEAST_EXPECT(ValStatus::current == harness.add(v));
1072 
1073  hash_set<PeerID> listed({a.nodeID()});
1074  std::vector<Validation> trustedVals({v});
1075  auto& vals = harness.vals();
1076  BEAST_EXPECT(vals.currentTrusted() == trustedVals);
1077  BEAST_EXPECT(
1078  vals.getPreferred(genesisLedger)->second == v.ledgerID());
1079  BEAST_EXPECT(
1080  vals.getNodesAfter(genesisLedger, genesisLedger.id()) == 0);
1081 
1082  trustedVals.clear();
1083  harness.vals().trustChanged({}, {a.nodeID()});
1084  // make acquiring ledger available
1085  h["ab"];
1086  BEAST_EXPECT(vals.currentTrusted() == trustedVals);
1087  BEAST_EXPECT(vals.getPreferred(genesisLedger) == std::nullopt);
1088  BEAST_EXPECT(
1089  vals.getNodesAfter(genesisLedger, genesisLedger.id()) == 0);
1090  }
1091  }
1092 
1093  void
1094  run() override
1095  {
1096  testAddValidation();
1097  testOnStale();
1098  testGetNodesAfter();
1099  testCurrentTrusted();
1100  testGetCurrentPublicKeys();
1101  testTrustedByLedgerFunctions();
1102  testExpire();
1103  testFlush();
1104  testGetPreferredLedger();
1105  testGetPreferredLCL();
1106  testAcquireValidatedLedger();
1107  testNumTrustedForLedger();
1108  testSeqEnforcer();
1109  testTrustChanged();
1110  }
1111 };
1112 
1113 BEAST_DEFINE_TESTSUITE(Validations, consensus, ripple);
1114 } // namespace csf
1115 } // namespace test
1116 } // namespace ripple
ripple::Validations::expire
void expire()
Expire old validation sets.
Definition: Validations.h:717
ripple::test::csf::Validations_test::TestHarness::parms
ValidationParms parms() const
Definition: Validations_test.cpp:246
ripple::test::csf::Validations_test::TestHarness
Definition: Validations_test.cpp:215
ripple::test::csf::Validations_test::Adaptor::Mutex
Definition: Validations_test.cpp:177
ripple::test::csf::Validations_test::testOnStale
void testOnStale()
Definition: Validations_test.cpp:407
ripple::test::csf::Validations_test::Node::now
NetClock::time_point now() const
Definition: Validations_test.cpp:107
ripple::test::csf::Validations_test::testCurrentTrusted
void testCurrentTrusted()
Definition: Validations_test.cpp:505
ripple::test::csf::Validations_test::Node::Node
Node(PeerID nodeID, clock_type const &c)
Definition: Validations_test.cpp:61
ripple::test::csf::Validations_test::TestHarness::clock_
beast::manual_clock< std::chrono::steady_clock > clock_
Definition: Validations_test.cpp:218
ripple::SeqEnforcer
Enforce validation increasing sequence requirement.
Definition: Validations.h:96
ripple::test::csf::Validations_test::testFlush
void testFlush()
Definition: Validations_test.cpp:728
ripple::test::csf::Validations_test::Node::validate
Validation validate(Ledger ledger) const
Definition: Validations_test.cpp:147
ripple::test::csf::Validations_test::Node::masterKey
PeerKey masterKey() const
Definition: Validations_test.cpp:102
std::unordered_set
STL class.
std::pair< PeerID, std::uint32_t >
ripple::Validations::fees
std::vector< std::uint32_t > fees(ID const &ledgerID, std::uint32_t baseFee)
Returns fees reported by trusted full validators in the given ledger.
Definition: Validations.h:1041
ripple::test::csf::Validations_test::Adaptor::acquire
std::optional< Ledger > acquire(Ledger::ID const &id)
Definition: Validations_test.cpp:204
vector
std::unordered_map::find
T find(T... args)
ripple::Validations::trustChanged
void trustChanged(hash_set< NodeID > const &added, hash_set< NodeID > const &removed)
Update trust status of validations.
Definition: Validations.h:755
ripple::test::csf::Validations_test::TestHarness::makeNode
Node makeNode()
Definition: Validations_test.cpp:240
ripple::test::csf::Validations_test::genesisLedger
const Ledger genesisLedger
Definition: Validations_test.cpp:258
ripple::Validations::getPreferredLCL
ID getPreferredLCL(Ledger const &lcl, Seq minSeq, hash_map< ID, std::uint32_t > const &peerCounts)
Determine the preferred last closed ledger for the next consensus round.
Definition: Validations.h:896
std::chrono::duration
ripple::test::csf::Validation::nodeID
PeerID const & nodeID() const
Definition: Validation.h:118
std::unordered_map::emplace
T emplace(T... args)
ripple::ValStatus
ValStatus
Status of validation we received.
Definition: Validations.h:166
ripple::ValidationParms::validationCURRENT_EARLY
std::chrono::seconds validationCURRENT_EARLY
Duration pre-close in which validations are acceptable.
Definition: Validations.h:68
ripple::test::csf::Validations_test::TestHarness::add
ValStatus add(Validation const &v)
Definition: Validations_test.cpp:228
ripple::Validations::setSeqToKeep
void setSeqToKeep(Seq const &s)
Set the smallest sequence number of validations to keep from expire.
Definition: Validations.h:705
ripple::test::csf::Validations_test::Node::untrust
void untrust()
Definition: Validations_test.cpp:66
ripple::test::csf::Validations_test::Node::loadFee_
std::optional< std::uint32_t > loadFee_
Definition: Validations_test.cpp:58
tuple
ripple::test::csf::Ledger
A ledger is a set of observed transactions and a sequence number identifying the ledger.
Definition: ledgers.h:58
ripple::test::csf::Ledger::seq
Seq seq() const
Definition: ledgers.h:173
std::function
ripple::test::csf::Validations_test::testGetNodesAfter
void testGetNodesAfter()
Definition: Validations_test.cpp:452
std::sort
T sort(T... args)
ripple::test::csf::Validations_test::Node
Definition: Validations_test.cpp:52
ripple::test::csf::Ledger::MakeGenesis
Definition: ledgers.h:69
ripple::test::csf::Validations_test::clock_type
beast::abstract_clock< std::chrono::steady_clock > const clock_type
Definition: Validations_test.cpp:36
ripple::test::csf::LedgerHistoryHelper
Helper for writing unit tests with controlled ledger histories.
Definition: ledgers.h:323
std::vector::push_back
T push_back(T... args)
ripple::ValStatus::badSeq
@ badSeq
A validation violates the increasing seq requirement.
ripple::test::csf::LedgerOracle::lookup
std::optional< Ledger > lookup(Ledger::ID const &id) const
Find the ledger with the given ID.
Definition: ledgers.cpp:129
ripple::test::csf::Validations_test::Node::nodeID
PeerID nodeID() const
Definition: Validations_test.cpp:84
ripple::test::csf::Validations_test::testTrustChanged
void testTrustChanged()
Definition: Validations_test.cpp:1000
ripple::test::csf::Validations_test::Adaptor::c_
clock_type & c_
Definition: Validations_test.cpp:172
ripple::test::csf::Validations_test::TestHarness::TestHarness
TestHarness(LedgerOracle &o)
Definition: Validations_test.cpp:223
ripple::test::csf::Validations_test::TestHarness::vals
TestValidations & vals()
Definition: Validations_test.cpp:234
ripple::Validations::add
ValStatus add(NodeID const &nodeID, Validation const &val)
Add a new validation.
Definition: Validations.h:615
ripple::test::csf::Validations_test::Node::partial
Validation partial(Ledger ledger) const
Definition: Validations_test.cpp:158
ripple::test::csf::Validations_test::TestHarness::clock
auto & clock()
Definition: Validations_test.cpp:252
ripple::compare
int compare(base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
Definition: base_uint.h:530
ripple::test::csf::Validations_test::Node::setLoadFee
void setLoadFee(std::uint32_t fee)
Definition: Validations_test.cpp:78
ripple::Validations::getNodesAfter
std::size_t getNodesAfter(Ledger const &ledger, ID const &ledgerID)
Count the number of current trusted validators working on a ledger after the specified one.
Definition: Validations.h:934
ripple::Validations::numTrustedForLedger
std::size_t numTrustedForLedger(ID const &ledgerID)
Count the number of trusted full validations for the given ledger.
Definition: Validations.h:997
ripple::test::csf::LedgerOracle
Oracle maintaining unique ledgers for a simulation.
Definition: ledgers.h:244
ripple::test::csf::LedgerHistoryHelper::oracle
LedgerOracle oracle
Definition: ledgers.h:325
ripple::test::csf::Validations_test::Node::advanceKey
void advanceKey()
Definition: Validations_test.cpp:90
std::chrono::time_point
ripple::ValStatus::stale
@ stale
Not current or was older than current from this node.
ripple::test::csf::Validations_test::testGetCurrentPublicKeys
void testGetCurrentPublicKeys()
Definition: Validations_test.cpp:547
ripple::ValStatus::current
@ current
This was a new validation and was added.
ripple::ValidationParms::validationCURRENT_LOCAL
std::chrono::seconds validationCURRENT_LOCAL
Duration a validation remains current after first observed.
Definition: Validations.h:61
std::uint32_t
ripple::test::csf::Validations_test::Node::c_
clock_type const & c_
Definition: Validations_test.cpp:54
ripple::ValidationParms::validationCURRENT_WALL
std::chrono::seconds validationCURRENT_WALL
The number of seconds a validation remains current after its ledger's close time.
Definition: Validations.h:53
ripple::test::csf::Validations_test::Node::validate
Validation validate(Ledger ledger, NetClock::duration signOffset, NetClock::duration seenOffset) const
Definition: Validations_test.cpp:137
ripple::Validations::getTrustedForLedger
std::vector< WrappedValidationType > getTrustedForLedger(ID const &ledgerID)
Get trusted full validations for a specific ledger.
Definition: Validations.h:1018
beast::abstract_clock< std::chrono::steady_clock >
memory
ripple::test::jtx::fee
Set the fee on a JTx.
Definition: fee.h:35
ripple::test::csf::Validations_test::testTrustedByLedgerFunctions
void testTrustedByLedgerFunctions()
Definition: Validations_test.cpp:590
ripple::test::csf::BEAST_DEFINE_TESTSUITE
BEAST_DEFINE_TESTSUITE(Validations, consensus, ripple)
ripple::test::csf::Validations_test::TestHarness::nextNodeId_
PeerID nextNodeId_
Definition: Validations_test.cpp:220
ripple::ValStatus::conflicting
@ conflicting
Multiple validations by a validator for different ledgers.
ripple::test::jtx::seq
Set the sequence number on a JTx.
Definition: seq.h:33
ripple::test::csf::Ledger::id
ID id() const
Definition: ledgers.h:167
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::test::csf::Validations_test::TestHarness::tv_
TestValidations tv_
Definition: Validations_test.cpp:219
ripple::test::csf::Validations_test::Node::nodeID_
PeerID nodeID_
Definition: Validations_test.cpp:55
ripple::test::csf::Validations_test::testNumTrustedForLedger
void testNumTrustedForLedger()
Definition: Validations_test.cpp:961
ripple::test::csf::Validation
Validation of a specific ledger by a specific Peer.
Definition: Validation.h:47
ripple::ValidationParms::validationSET_EXPIRES
std::chrono::seconds validationSET_EXPIRES
Duration a set of validations for a given ledger hash remain valid.
Definition: Validations.h:76
ripple::test::csf::Ledger::ID
tagged_integer< std::uint32_t, IdTag > ID
Definition: ledgers.h:67
ripple::test::csf::Validations_test::run
void run() override
Definition: Validations_test.cpp:1094
ripple::test::csf::Validations_test::Adaptor
Definition: Validations_test.cpp:170
ripple::test::csf::Validations_test::Node::signIdx_
std::size_t signIdx_
Definition: Validations_test.cpp:57
ripple::test::csf::Ledger::Seq
tagged_integer< std::uint32_t, SeqTag > Seq
Definition: ledgers.h:64
ripple::test::csf::Validations_test::testSeqEnforcer
void testSeqEnforcer()
Definition: Validations_test.cpp:978
ripple::test::csf::Validation::ledgerID
Ledger::ID ledgerID() const
Definition: Validation.h:88
ripple::Validations::getPreferred
std::optional< std::pair< Seq, ID > > getPreferred(Ledger const &curr)
Return the sequence number and ID of the preferred working ledger.
Definition: Validations.h:810
ripple::Validations
Maintains current and recent ledger validations.
Definition: Application.h:98
std::optional< std::uint32_t >
ripple::test::csf::Validations_test::Node::validate
Validation validate(Ledger::ID id, Ledger::Seq seq, NetClock::duration signOffset, NetClock::duration seenOffset, bool full) const
Definition: Validations_test.cpp:115
ripple::test::csf::Validations_test::Adaptor::Adaptor
Adaptor(clock_type &c, LedgerOracle &o)
Definition: Validations_test.cpp:193
std::size_t
std::make_pair
T make_pair(T... args)
ripple::test::csf::Validations_test::testExpire
void testExpire()
Definition: Validations_test.cpp:702
ripple::test::csf::Validations_test::Adaptor::now
NetClock::time_point now() const
Definition: Validations_test.cpp:198
ripple::test::csf::Validations_test
Definition: Validations_test.cpp:34
ripple::test::csf::Validations_test::Node::trusted_
bool trusted_
Definition: Validations_test.cpp:56
ripple::Validations::getCurrentNodeIDs
auto getCurrentNodeIDs() -> hash_set< NodeID >
Get the set of node ids associated with current validations.
Definition: Validations.h:979
ripple::test::csf::Validations_test::TestHarness::p_
ValidationParms p_
Definition: Validations_test.cpp:217
ripple::tagged_integer< std::uint32_t, PeerIDTag >
ripple::test::csf::Validations_test::testGetPreferredLedger
void testGetPreferredLedger()
Definition: Validations_test.cpp:760
beast::manual_clock< std::chrono::steady_clock >
ripple::test::csf::Validations_test::Adaptor::Mutex::unlock
void unlock()
Definition: Validations_test.cpp:185
ripple::test::csf::Validations_test::testAcquireValidatedLedger
void testAcquireValidatedLedger()
Definition: Validations_test.cpp:892
ripple::test::csf::Validations_test::testAddValidation
void testAddValidation()
Definition: Validations_test.cpp:261
ripple::ValidationParms
Timing parameters to control validation staleness and expiration.
Definition: Validations.h:43
ripple::test::csf::Validations_test::Node::trust
void trust()
Definition: Validations_test.cpp:72
std::unordered_map
STL class.
ripple::NetClock::time_point
std::chrono::time_point< NetClock > time_point
Definition: chrono.h:56
ripple::test::csf::Validations_test::Adaptor::oracle_
LedgerOracle & oracle_
Definition: Validations_test.cpp:173
type_traits
ripple::test::csf::Validations_test::testGetPreferredLCL
void testGetPreferredLCL()
Definition: Validations_test.cpp:832
ripple::Validations::currentTrusted
std::vector< WrappedValidationType > currentTrusted()
Get the currently trusted full validations.
Definition: Validations.h:960
ripple::test::csf::Validations_test::toNetClock
static NetClock::time_point toNetClock(clock_type const &c)
Definition: Validations_test.cpp:41
ripple::test::csf::Validations_test::Node::currKey
PeerKey currKey() const
Definition: Validations_test.cpp:96
std::chrono
ripple::test::csf::Validations_test::Adaptor::Mutex::lock
void lock()
Definition: Validations_test.cpp:180
Generated by   doxygen 1.8.17