rippled/src/doctest/protocol/Issue.cpp

// Issue doctest - converted from src/test/protocol/Issue_test.cpp

#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/protocol/Book.h>
#include <xrpl/protocol/Issue.h>

#include <doctest/doctest.h>

#include <map>
#include <optional>
#include <set>
#include <unordered_set>

#if BEAST_MSVC
#define STL_SET_HAS_EMPLACE 1
#else
#define STL_SET_HAS_EMPLACE 0
#endif

#ifndef XRPL_ASSETS_ENABLE_STD_HASH
#if BEAST_MAC || BEAST_IOS
#define XRPL_ASSETS_ENABLE_STD_HASH 0
#else
#define XRPL_ASSETS_ENABLE_STD_HASH 1
#endif
#endif

TEST_SUITE_BEGIN("Issue");

namespace {

using namespace xrpl;
using Domain = uint256;

// Comparison, hash tests for uint60 (via base_uint)
template <typename Unsigned>
void
testUnsigned()
{
    Unsigned const u1(1);
    Unsigned const u2(2);
    Unsigned const u3(3);

    CHECK_NE(u1, u2);
    CHECK_LT(u1, u2);
    CHECK_LE(u1, u2);
    CHECK_LE(u2, u2);
    CHECK_EQ(u2, u2);
    CHECK_GE(u2, u2);
    CHECK_GE(u3, u2);
    CHECK_GT(u3, u2);

    std::hash<Unsigned> hash;

    CHECK_EQ(hash(u1), hash(u1));
    CHECK_EQ(hash(u2), hash(u2));
    CHECK_EQ(hash(u3), hash(u3));
    CHECK_NE(hash(u1), hash(u2));
    CHECK_NE(hash(u1), hash(u3));
    CHECK_NE(hash(u2), hash(u3));
}

// Comparison, hash tests for Issue
template <class IssueType>
void
testIssue()
{
    Currency const c1(1);
    AccountID const i1(1);
    Currency const c2(2);
    AccountID const i2(2);
    Currency const c3(3);
    AccountID const i3(3);

    CHECK_NE(IssueType(c1, i1), IssueType(c2, i1));
    CHECK_LT(IssueType(c1, i1), IssueType(c2, i1));
    CHECK_LE(IssueType(c1, i1), IssueType(c2, i1));
    CHECK_LE(IssueType(c2, i1), IssueType(c2, i1));
    CHECK_EQ(IssueType(c2, i1), IssueType(c2, i1));
    CHECK_GE(IssueType(c2, i1), IssueType(c2, i1));
    CHECK_GE(IssueType(c3, i1), IssueType(c2, i1));
    CHECK_GT(IssueType(c3, i1), IssueType(c2, i1));
    CHECK_NE(IssueType(c1, i1), IssueType(c1, i2));
    CHECK_LT(IssueType(c1, i1), IssueType(c1, i2));
    CHECK_LE(IssueType(c1, i1), IssueType(c1, i2));
    CHECK_LE(IssueType(c1, i2), IssueType(c1, i2));
    CHECK_EQ(IssueType(c1, i2), IssueType(c1, i2));
    CHECK_GE(IssueType(c1, i2), IssueType(c1, i2));
    CHECK_GE(IssueType(c1, i3), IssueType(c1, i2));
    CHECK_GT(IssueType(c1, i3), IssueType(c1, i2));

    std::hash<IssueType> hash;

    CHECK_EQ(hash(IssueType(c1, i1)), hash(IssueType(c1, i1)));
    CHECK_EQ(hash(IssueType(c1, i2)), hash(IssueType(c1, i2)));
    CHECK_EQ(hash(IssueType(c1, i3)), hash(IssueType(c1, i3)));
    CHECK_EQ(hash(IssueType(c2, i1)), hash(IssueType(c2, i1)));
    CHECK_EQ(hash(IssueType(c2, i2)), hash(IssueType(c2, i2)));
    CHECK_EQ(hash(IssueType(c2, i3)), hash(IssueType(c2, i3)));
    CHECK_EQ(hash(IssueType(c3, i1)), hash(IssueType(c3, i1)));
    CHECK_EQ(hash(IssueType(c3, i2)), hash(IssueType(c3, i2)));
    CHECK_EQ(hash(IssueType(c3, i3)), hash(IssueType(c3, i3)));
    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c1, i2)));
    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c1, i3)));
    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c2, i1)));
    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c2, i2)));
    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c2, i3)));
    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c3, i1)));
    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c3, i2)));
    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c3, i3)));
}

template <class Set>
void
testIssueSet()
{
    Currency const c1(1);
    AccountID const i1(1);
    Currency const c2(2);
    AccountID const i2(2);
    Issue const a1(c1, i1);
    Issue const a2(c2, i2);

    {
        Set c;

        c.insert(a1);
        REQUIRE(c.size() == 1);
        c.insert(a2);
        REQUIRE(c.size() == 2);

        REQUIRE(c.erase(Issue(c1, i2)) == 0);
        REQUIRE(c.erase(Issue(c1, i1)) == 1);
        REQUIRE(c.erase(Issue(c2, i2)) == 1);
        REQUIRE(c.empty());
    }

    {
        Set c;

        c.insert(a1);
        REQUIRE(c.size() == 1);
        c.insert(a2);
        REQUIRE(c.size() == 2);

        REQUIRE(c.erase(Issue(c1, i2)) == 0);
        REQUIRE(c.erase(Issue(c1, i1)) == 1);
        REQUIRE(c.erase(Issue(c2, i2)) == 1);
        REQUIRE(c.empty());

#if STL_SET_HAS_EMPLACE
        c.emplace(c1, i1);
        REQUIRE(c.size() == 1);
        c.emplace(c2, i2);
        REQUIRE(c.size() == 2);
#endif
    }
}

}  // namespace

TEST_CASE("Currency")
{
    testUnsigned<Currency>();
}

TEST_CASE("AccountID")
{
    testUnsigned<AccountID>();
}

TEST_CASE("Issue")
{
    testIssue<Issue>();
}

TEST_CASE("std::set<Issue>")
{
    testIssueSet<std::set<Issue>>();
}

#if XRPL_ASSETS_ENABLE_STD_HASH
TEST_CASE("std::unordered_set<Issue>")
{
    testIssueSet<std::unordered_set<Issue>>();
}
#endif

TEST_CASE("hash_set<Issue>")
{
    testIssueSet<hash_set<Issue>>();
}

TEST_SUITE_END();