TestFamily.h

#pragma once
 
#include <xrpl/basics/ByteUtilities.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/basics/contract.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/config/BasicConfig.h>
#include <xrpl/config/Constants.h>
#include <xrpl/nodestore/Database.h>
#include <xrpl/nodestore/DummyScheduler.h>
#include <xrpl/nodestore/Manager.h>
#include <xrpl/shamap/Family.h>
#include <xrpl/shamap/FullBelowCache.h>
#include <xrpl/shamap/TreeNodeCache.h>
 
#include <cstdint>
#include <memory>
#include <stdexcept>
 
namespace xrpl::test {

class TestFamily : public Family
{
private:
    std::unique_ptr<node_store::Database> db_;
    TestStopwatch clock_;
    std::shared_ptr<FullBelowCache> fbCache_;
    std::shared_ptr<TreeNodeCache> tnCache_;
    node_store::DummyScheduler scheduler_;
    beast::Journal j_;
 
public:
    explicit TestFamily(beast::Journal j)
        : fbCache_(std::make_shared<FullBelowCache>("TestFamily full below cache", clock_, j))
        , tnCache_(
              std::make_shared<TreeNodeCache>(
                  "TestFamily tree node cache",
                  65536,
                  std::chrono::minutes{1},
                  clock_,
                  j))
        , j_(j)
    {
        Section config;
        config.set(Keys::kType, "memory");
        config.set(Keys::kPath, "TestFamily");
        db_ = node_store::Manager::instance().makeDatabase(megabytes(4), scheduler_, 1, config, j);
    }
 
    node_store::Database&
    db() override
    {
        return *db_;
    }
 
    [[nodiscard]] node_store::Database const&
    db() const override
    {
        return *db_;
    }
 
    beast::Journal const&
    journal() override
    {
        return j_;
    }
 
    std::shared_ptr<FullBelowCache>
    getFullBelowCache() override
    {
        return fbCache_;
    }
 
    std::shared_ptr<TreeNodeCache>
    getTreeNodeCache() override
    {
        return tnCache_;
    }
 
    void
    sweep() override
    {
        fbCache_->sweep();
        tnCache_->sweep();
    }
 
    void
    missingNodeAcquireBySeq(std::uint32_t refNum, uint256 const& nodeHash) override
    {
        Throw<std::runtime_error>("TestFamily: missing node (by seq)");
    }
 
    void
    missingNodeAcquireByHash(uint256 const& refHash, std::uint32_t refNum) override
    {
        Throw<std::runtime_error>("TestFamily: missing node (by hash)");
    }
 
    void
    reset() override
    {
        (*fbCache_).reset();
        (*tnCache_).reset();
    }

    TestStopwatch&
    clock()
    {
        return clock_;
    }
};
 
}  // namespace xrpl::test