SHAMapSync_test.cpp

#include <test/shamap/common.h>
#include <test/unit_test/SuiteJournal.h>
 
#include <xrpl/basics/random.h>
#include <xrpl/beast/unit_test.h>
#include <xrpl/beast/xor_shift_engine.h>
#include <xrpl/shamap/SHAMap.h>
#include <xrpl/shamap/SHAMapItem.h>
 
namespace ripple {
namespace tests {
 
class SHAMapSync_test : public beast::unit_test::suite
{
public:
    beast::xor_shift_engine eng_;
 
    boost::intrusive_ptr<SHAMapItem>
    makeRandomAS()
    {
        Serializer s;
 
        for (int d = 0; d < 3; ++d)
            s.add32(rand_int<std::uint32_t>(eng_));
        return make_shamapitem(s.getSHA512Half(), s.slice());
    }
 
    bool
    confuseMap(SHAMap& map, int count)
    {
        // add a bunch of random states to a map, then remove them
        // map should be the same
        SHAMapHash beforeHash = map.getHash();
 
        std::list<uint256> items;
 
        for (int i = 0; i < count; ++i)
        {
            auto item = makeRandomAS();
            items.push_back(item->key());
 
            if (!map.addItem(SHAMapNodeType::tnACCOUNT_STATE, item))
            {
                log << "Unable to add item to map\n";
                return false;
            }
        }
 
        for (auto const& item : items)
        {
            if (!map.delItem(item))
            {
                log << "Unable to remove item from map\n";
                return false;
            }
        }
 
        if (beforeHash != map.getHash())
        {
            log << "Hashes do not match " << beforeHash << " " << map.getHash()
                << std::endl;
            return false;
        }
 
        return true;
    }
 
    void
    run() override
    {
        using namespace beast::severities;
        test::SuiteJournal journal("SHAMapSync_test", *this);
 
        TestNodeFamily f(journal), f2(journal);
        SHAMap source(SHAMapType::FREE, f);
        SHAMap destination(SHAMapType::FREE, f2);
 
        int items = 10000;
        for (int i = 0; i < items; ++i)
        {
            source.addItem(SHAMapNodeType::tnACCOUNT_STATE, makeRandomAS());
            if (i % 100 == 0)
                source.invariants();
        }
 
        source.invariants();
        BEAST_EXPECT(confuseMap(source, 500));
        source.invariants();
 
        source.setImmutable();
 
        int count = 0;
        source.visitLeaves([&count](auto const& item) { ++count; });
        BEAST_EXPECT(count == items);
 
        std::vector<SHAMapMissingNode> missingNodes;
        source.walkMap(missingNodes, 2048);
        BEAST_EXPECT(missingNodes.empty());
 
        std::vector<SHAMapNodeID> nodeIDs, gotNodeIDs;
        std::vector<Blob> gotNodes;
        std::vector<uint256> hashes;
 
        destination.setSynching();
 
        {
            std::vector<std::pair<SHAMapNodeID, Blob>> a;
 
            BEAST_EXPECT(source.getNodeFat(
                SHAMapNodeID(), a, rand_bool(eng_), rand_int(eng_, 2)));
 
            unexpected(a.size() < 1, "NodeSize");
 
            BEAST_EXPECT(
                destination
                    .addRootNode(
                        source.getHash(), makeSlice(a[0].second), nullptr)
                    .isGood());
        }
 
        do
        {
            f.clock().advance(std::chrono::seconds(1));
 
            // get the list of nodes we know we need
            auto nodesMissing = destination.getMissingNodes(2048, nullptr);
 
            if (nodesMissing.empty())
                break;
 
            // get as many nodes as possible based on this information
            std::vector<std::pair<SHAMapNodeID, Blob>> b;
 
            for (auto& it : nodesMissing)
            {
                // Don't use BEAST_EXPECT here b/c it will be called a
                // non-deterministic number of times and the number of tests run
                // should be deterministic
                if (!source.getNodeFat(
                        it.first, b, rand_bool(eng_), rand_int(eng_, 2)))
                    fail("", __FILE__, __LINE__);
            }
 
            // Don't use BEAST_EXPECT here b/c it will be called a
            // non-deterministic number of times and the number of tests run
            // should be deterministic
            if (b.empty())
                fail("", __FILE__, __LINE__);
 
            for (std::size_t i = 0; i < b.size(); ++i)
            {
                // Don't use BEAST_EXPECT here b/c it will be called a
                // non-deterministic number of times and the number of tests run
                // should be deterministic
                if (!destination
                         .addKnownNode(
                             b[i].first, makeSlice(b[i].second), nullptr)
                         .isUseful())
                    fail("", __FILE__, __LINE__);
            }
        } while (true);
 
        destination.clearSynching();
 
        BEAST_EXPECT(source.deepCompare(destination));
 
        destination.invariants();
    }
};
 
BEAST_DEFINE_TESTSUITE(SHAMapSync, shamap, ripple);
 
}  // namespace tests
}  // namespace ripple