Inside Bitcoin

501    scenario.Check(peer, {}, 0, 0, 0, "o5");
502}
503
504/** Add to scenario a test that verifies behavior related to both txid and wtxid with the same
505 *  hash being announced.
506 *
507 *  config is an integer in [0, 4) inclusive, and selects the variant of the test used.
508*/
509void TxRequestTest::BuildWtxidTest(Scenario& scenario, int config)
510{
511    scenario.SetTestName(strprintf("Wtxid(config=%i)", config));
512
513    auto peerT = scenario.NewPeer();
514    auto peerW = scenario.NewPeer();
515    auto txhash = scenario.NewTxHash();
516    auto txid{Txid::FromUint256(txhash)};
517    auto wtxid{Wtxid::FromUint256(txhash)};
518
519    auto reqtimeT = m_rng.randbool() ? MIN_TIME : scenario.Now() + RandomTime8s();
520    auto reqtimeW = m_rng.randbool() ? MIN_TIME : scenario.Now() + RandomTime8s();
521
522    // Announce txid first or wtxid first.
523    if (config & 1) {
524        scenario.ReceivedInv(peerT, txid, config & 2, reqtimeT);
525        if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
526        scenario.ReceivedInv(peerW, wtxid, !(config & 2), reqtimeW);
527    } else {
528        scenario.ReceivedInv(peerW, wtxid, !(config & 2), reqtimeW);
529        if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
530        scenario.ReceivedInv(peerT, txid, config & 2, reqtimeT);
531    }
532
533    // Let time pass if needed, and check that the preferred announcement (txid or wtxid)
534    // is correctly to-be-requested (and with the correct wtxidness).
535    auto max_reqtime = std::max(reqtimeT, reqtimeW);
536    if (max_reqtime > scenario.Now()) scenario.AdvanceTime(max_reqtime - scenario.Now());
537    if (config & 2) {
538        scenario.Check(peerT, {txid}, 1, 0, 0, "w1");
539        scenario.Check(peerW, {}, 1, 0, 0, "w2");
540    } else {
541        scenario.Check(peerT, {}, 1, 0, 0, "w3");
542        scenario.Check(peerW, {wtxid}, 1, 0, 0, "w4");
543    }
544
545    // Let the preferred announcement be requested. It's not going to be delivered.
546    auto expiry = RandomTime8s();
547    if (config & 2) {
548        scenario.RequestedTx(peerT, txid.ToUint256(), scenario.Now() + expiry);
549        scenario.Check(peerT, {}, 0, 1, 0, "w5");
550        scenario.Check(peerW, {}, 1, 0, 0, "w6");
551    } else {
552        scenario.RequestedTx(peerW, wtxid.ToUint256(), scenario.Now() + expiry);
553        scenario.Check(peerT, {}, 1, 0, 0, "w7");
554        scenario.Check(peerW, {}, 0, 1, 0, "w8");
555    }
556
557    // After reaching expiration time of the preferred announcement, verify that the
558    // remaining one is requestable
559    scenario.AdvanceTime(expiry);
560    if (config & 2) {
561        scenario.Check(peerT, {}, 0, 0, 1, "w9");
562        scenario.Check(peerW, {wtxid}, 1, 0, 0, "w10");
563        scenario.CheckExpired(peerT, txid);
564    } else {
565        scenario.Check(peerT, {txid}, 1, 0, 0, "w11");
566        scenario.Check(peerW, {}, 0, 0, 1, "w12");
567        scenario.CheckExpired(peerW, wtxid);
568    }
569
570    // If a good transaction with either that hash as wtxid or txid arrives, both
571    // announcements are gone.
572    if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
573    scenario.ForgetTxHash(txhash);
574    scenario.Check(peerT, {}, 0, 0, 0, "w13");
575    scenario.Check(peerW, {}, 0, 0, 0, "w14");
576}
577
578/** Add to scenario a test that exercises clocks that go backwards. */
579void TxRequestTest::BuildTimeBackwardsTest(Scenario& scenario)
580{
581    auto peer1 = scenario.NewPeer();
582    auto peer2 = scenario.NewPeer();
583    auto gtxid = scenario.NewGTxid({{peer1, peer2}});
584
585    // Announce from peer2.
586    auto reqtime = scenario.Now() + RandomTime8s();
587    scenario.ReceivedInv(peer2, gtxid, true, reqtime);
588    scenario.Check(peer2, {}, 1, 0, 0, "r1");
589    scenario.AdvanceTime(reqtime - scenario.Now());
590    scenario.Check(peer2, {gtxid}, 1, 0, 0, "r2");
591    // Check that if the clock goes backwards by 1us, the transaction would stop being requested.
592    scenario.Check(peer2, {}, 1, 0, 0, "r3", -MICROSECOND);
593    // But it reverts to being requested if time goes forward again.
594    scenario.Check(peer2, {gtxid}, 1, 0, 0, "r4");
595
596    // Announce from peer1.
597    if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
598    scenario.ReceivedInv(peer1, gtxid, true, MAX_TIME);
599    scenario.Check(peer2, {gtxid}, 1, 0, 0, "r5");
600    scenario.Check(peer1, {}, 1, 0, 0, "r6");
601
602    // Request from peer1.
603    if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
604    auto expiry = scenario.Now() + RandomTime8s();
605    scenario.RequestedTx(peer1, gtxid.ToUint256(), expiry);
606    scenario.Check(peer1, {}, 0, 1, 0, "r7");
607    scenario.Check(peer2, {}, 1, 0, 0, "r8");
608
609    // Expiration passes.
610    scenario.AdvanceTime(expiry - scenario.Now());
611    scenario.Check(peer1, {}, 0, 0, 1, "r9");
612    scenario.Check(peer2, {gtxid}, 1, 0, 0, "r10"); // Request goes back to peer2.
613    scenario.CheckExpired(peer1, gtxid);
614    scenario.Check(peer1, {}, 0, 0, 1, "r11", -MICROSECOND); // Going back does not unexpire.
615    scenario.Check(peer2, {gtxid}, 1, 0, 0, "r12", -MICROSECOND);
616
617    // Peer2 goes offline, meaning no viable announcements remain.
618    if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
619    scenario.DisconnectedPeer(peer2);
620    scenario.Check(peer1, {}, 0, 0, 0, "r13");
621    scenario.Check(peer2, {}, 0, 0, 0, "r14");
622}
623
624/** Add to scenario a test that involves RequestedTx() calls for txhashes not returned by GetRequestable. */
625void TxRequestTest::BuildWeirdRequestsTest(Scenario& scenario)
626{
627    auto peer1 = scenario.NewPeer();
628    auto peer2 = scenario.NewPeer();
629    auto gtxid1 = scenario.NewGTxid({{peer1, peer2}});
630    auto gtxid2 = scenario.NewGTxid({{peer2, peer1}});
631
632    // Announce gtxid1 by peer1.
633    scenario.ReceivedInv(peer1, gtxid1, true, MIN_TIME);
634    scenario.Check(peer1, {gtxid1}, 1, 0, 0, "q1");
635
636    // Announce gtxid2 by peer2.
637    if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
638    scenario.ReceivedInv(peer2, gtxid2, true, MIN_TIME);
639    scenario.Check(peer1, {gtxid1}, 1, 0, 0, "q2");
640    scenario.Check(peer2, {gtxid2}, 1, 0, 0, "q3");
641
642    // We request gtxid2 from *peer1* - no effect.
643    if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
644    scenario.RequestedTx(peer1, gtxid2.ToUint256(), MAX_TIME);
645    scenario.Check(peer1, {gtxid1}, 1, 0, 0, "q4");
646    scenario.Check(peer2, {gtxid2}, 1, 0, 0, "q5");
647
648    // Now request gtxid1 from peer1 - marks it as REQUESTED.
649    if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
650    auto expiryA = scenario.Now() + RandomTime8s();
651    scenario.RequestedTx(peer1, gtxid1.ToUint256(), expiryA);
652    scenario.Check(peer1, {}, 0, 1, 0, "q6");
653    scenario.Check(peer2, {gtxid2}, 1, 0, 0, "q7");
654
655    // Request it a second time - nothing happens, as it's already REQUESTED.
656    auto expiryB = expiryA + RandomTime8s();
657    scenario.RequestedTx(peer1, gtxid1.ToUint256(), expiryB);
658    scenario.Check(peer1, {}, 0, 1, 0, "q8");
659    scenario.Check(peer2, {gtxid2}, 1, 0, 0, "q9");
660
661    // Also announce gtxid1 from peer2 now, so that the txhash isn't forgotten when the peer1 request expires.
662    scenario.ReceivedInv(peer2, gtxid1, true, MIN_TIME);
663    scenario.Check(peer1, {}, 0, 1, 0, "q10");
664    scenario.Check(peer2, {gtxid2}, 2, 0, 0, "q11");
665
666    // When reaching expiryA, it expires (not expiryB, which is later).
667    scenario.AdvanceTime(expiryA - scenario.Now());
668    scenario.Check(peer1, {}, 0, 0, 1, "q12");
669    scenario.Check(peer2, {gtxid2, gtxid1}, 2, 0, 0, "q13");
670    scenario.CheckExpired(peer1, gtxid1);
671
672    // Requesting it yet again from peer1 doesn't do anything, as it's already COMPLETED.
673    if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
674    scenario.RequestedTx(peer1, gtxid1.ToUint256(), MAX_TIME);
675    scenario.Check(peer1, {}, 0, 0, 1, "q14");
676    scenario.Check(peer2, {gtxid2, gtxid1}, 2, 0, 0, "q15");
677
678    // Now announce gtxid2 from peer1.
679    if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
680    scenario.ReceivedInv(peer1, gtxid2, true, MIN_TIME);
681    scenario.Check(peer1, {}, 1, 0, 1, "q16");
682    scenario.Check(peer2, {gtxid2, gtxid1}, 2, 0, 0, "q17");
683
684    // And request it from peer1 (weird as peer2 has the preference).
685    if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
686    scenario.RequestedTx(peer1, gtxid2.ToUint256(), MAX_TIME);
687    scenario.Check(peer1, {}, 0, 1, 1, "q18");
688    scenario.Check(peer2, {gtxid1}, 2, 0, 0, "q19");
689
690    // If peer2 now (normally) requests gtxid2, the existing request by peer1 becomes COMPLETED.
691    if (m_rng.randbool()) scenario.AdvanceTime(RandomTime8s());
692    scenario.RequestedTx(peer2, gtxid2.ToUint256(), MAX_TIME);
693    scenario.Check(peer1, {}, 0, 0, 2, "q20");
694    scenario.Check(peer2, {gtxid1}, 1, 1, 0, "q21");
695
696    // If peer2 goes offline, no viable announcements remain.
697    scenario.DisconnectedPeer(peer2);
698    scenario.Check(peer1, {}, 0, 0, 0, "q22");
699    scenario.Check(peer2, {}, 0, 0, 0, "q23");
700}
701
702void TxRequestTest::TestInterleavedScenarios()
703{
704    // Create a list of functions which add tests to scenarios.
705    std::vector<std::function<void(Scenario&)>> builders;
706    // Add instances of every test, for every configuration.
707    for (int n = 0; n < 64; ++n) {
708        builders.emplace_back([this, n](Scenario& scenario) { BuildWtxidTest(scenario, n); });
709        builders.emplace_back([this, n](Scenario& scenario) { BuildRequestOrderTest(scenario, n & 3); });
710        builders.emplace_back([this, n](Scenario& scenario) { BuildSingleTest(scenario, n & 31); });
711        builders.emplace_back([this, n](Scenario& scenario) { BuildPriorityTest(scenario, n & 31); });
712        builders.emplace_back([this, n](Scenario& scenario) { BuildBigPriorityTest(scenario, (n & 7) + 1); });
713        builders.emplace_back([this](Scenario& scenario) { BuildTimeBackwardsTest(scenario); });
714        builders.emplace_back([this](Scenario& scenario) { BuildWeirdRequestsTest(scenario); });
715    }
716    // Randomly shuffle all those functions.
717    std::shuffle(builders.begin(), builders.end(), m_rng);
718
719    Runner runner;
720    auto starttime = RandomTime1y();
721    // Construct many scenarios, and run (up to) 10 randomly-chosen tests consecutively in each.
722    while (builders.size()) {
723        // Introduce some variation in the start time of each scenario, so they don't all start off
724        // concurrently, but get a more random interleaving.
725        auto scenario_start = starttime + RandomTime8s() + RandomTime8s() + RandomTime8s();
726        Scenario scenario(m_rng, runner, scenario_start);
727        for (int j = 0; builders.size() && j < 10; ++j) {
728            builders.back()(scenario);
729            builders.pop_back();
730        }
731    }
732    // Sort all the actions from all those scenarios chronologically, resulting in the actions from
733    // distinct scenarios to become interleaved. Use stable_sort so that actions from one scenario
734    // aren't reordered w.r.t. each other.
735    std::stable_sort(runner.actions.begin(), runner.actions.end(), [](const Action& a1, const Action& a2) {
736        return a1.first < a2.first;
737    });
738
739    // Run all actions from all scenarios, in order.
740    for (auto& action : runner.actions) {
741        action.second();
742    }
743
744    BOOST_CHECK_EQUAL(runner.txrequest.Size(), 0U);
745    BOOST_CHECK(runner.expired.empty());
746}
747
748}  // namespace
749
750BOOST_FIXTURE_TEST_SUITE(txrequest_tests, TxRequestTest)