EntryTestHelpers.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/ApplyViewImpl.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerHeader.h>
 
#include <gtest/gtest.h>
#include <helpers/Account.h>
#include <helpers/TxTest.h>
 
#include <string>
 
namespace xrpl::test {

class EntryTestEnv
{
public:
    TxTest env;
    Account const alice{"alice"};
    Account const bob{"bob"};
    Account const carol{"carol"};
 
    EntryTestEnv() : av_(&fundAndClose(), TapNone)
    {
    }

    [[nodiscard]] ReadView const&
    read() const
    {
        return env.getClosedLedger();
    }
 
    [[nodiscard]] ApplyView&
    apply()
    {
        return av_;
    }

    [[nodiscard]] UInt256
    someID() const
    {
        return read().header().parentHash;
    }
 
private:
    // Runs from the av_ member initializer, so it may only touch env and the
    // accounts -- everything declared above av_.
    ReadView const&
    fundAndClose()
    {
        env.createAccount(alice, XRP(10'000));
        env.createAccount(bob, XRP(10'000));
        env.createAccount(carol, XRP(10'000));
        env.close();
        return env.getClosedLedger();
    }
 
    ApplyViewImpl av_;
};

template <template <typename> class Entry, typename... Args>
void
expectKeylet(EntryTestEnv& e, Keylet const& expected, std::string const& what, Args const&... args)
{
    bool const present = e.read().read(expected) != nullptr;
 
    // The writable entry retains its keylet, so it can be inspected whether
    // or not the entry exists.
    Entry<ApplyView> const w(args..., e.apply());
    EXPECT_EQ(w.keylet().key, expected.key) << what << ": writable key";
    EXPECT_EQ(w.keylet().type, expected.type) << what << ": writable type";
    EXPECT_EQ(w.exists(), present) << what << ": writable exists";
 
    // The read-only entry has no keylet of its own -- it derives one from the
    // SLE, and only when the SLE exists. Its agreement with a direct read
    // of the expected keylet is what shows it resolved the same key.
    Entry<ReadView> const r(args..., e.read());
    EXPECT_EQ(r.exists(), present) << what << ": read-only exists";
    if (present)
    {
        EXPECT_EQ(r.key(), expected.key) << what << ": read-only key";
    }
 
    // Not r.type(): for a typed entry that returns kEntryType, so checking it
    // would just be this same assertion spelled twice.
    static_assert(Entry<ReadView>::kEntryType == Entry<ApplyView>::kEntryType);
    EXPECT_EQ(Entry<ReadView>::kEntryType, expected.type) << what << ": kEntryType";
}
 
}  // namespace xrpl::test