NegativeUNL_test.cpp

 
#include <test/jtx/Env.h>
 
#include <xrpld/app/consensus/RCLValidations.h>
#include <xrpld/app/misc/NegativeUNLVote.h>
#include <xrpld/app/misc/ValidatorList.h>
 
#include <xrpl/basics/Slice.h>
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/unit_test/suite.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/Ledger.h>
#include <xrpl/ledger/OpenView.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/KeyType.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STValidation.h>
#include <xrpl/protocol/SecretKey.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/TxFormats.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/tokens.h>
#include <xrpl/shamap/SHAMapMissingNode.h>
#include <xrpl/tx/apply.h>
 
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <optional>
#include <utility>
#include <vector>
 
namespace xrpl::test {
 
/*
 * This file implements the following negative UNL related tests:
 * -- test filling and applying ttUNL_MODIFY Tx and ledger update
 * -- test the NegativeUNLVote class. The test cases are split to multiple
 *    test classes to allow parallel execution.
 * -- test the negativeUNLFilter function
 *
 * Other negative UNL related tests such as ValidatorList and RPC related ones
 * are put in their existing unit test files.
 */

bool
negUnlSizeTest(
    std::shared_ptr<Ledger const> const& l,
    size_t size,
    bool hasToDisable,
    bool hasToReEnable);

bool
applyAndTestResult(jtx::Env& env, OpenView& view, STTx const& tx, bool pass);

bool
verifyPubKeyAndSeq(
    std::shared_ptr<Ledger const> const& l,
    hash_map<PublicKey, std::uint32_t> nUnlLedgerSeq);

std::size_t
countTx(std::shared_ptr<SHAMap> const& txSet);

std::vector<PublicKey>
createPublicKeys(std::size_t n);

STTx
createTx(bool disabling, LedgerIndex seq, PublicKey const& txKey);
 
class NegativeUNL_test : public beast::unit_test::Suite
{
    void
    testNegativeUNL()
    {
        /*
         * test cases:
         *
         * (1) the ledger after genesis
         * -- cannot apply Disable Tx
         * -- cannot apply ReEnable Tx
         * -- nUNL empty
         * -- no ToDisable
         * -- no ToReEnable
         *
         * (2) a flag ledger
         * -- apply an Disable Tx
         * -- cannot apply the second Disable Tx
         * -- cannot apply a ReEnable Tx
         * -- nUNL empty
         * -- has ToDisable with right nodeId
         * -- no ToReEnable
         * ++ extra test: first Disable Tx in ledger TxSet
         *
         * (3) ledgers before the next flag ledger
         * -- nUNL empty
         * -- has ToDisable with right nodeId
         * -- no ToReEnable
         *
         * (4) next flag ledger
         * -- nUNL size == 1, with right nodeId
         * -- no ToDisable
         * -- no ToReEnable
         * -- cannot apply an Disable Tx with nodeId already in nUNL
         * -- apply an Disable Tx with different nodeId
         * -- cannot apply a ReEnable Tx with the same NodeId as Add
         * -- cannot apply a ReEnable Tx with a NodeId not in nUNL
         * -- apply a ReEnable Tx with a nodeId already in nUNL
         * -- has ToDisable with right nodeId
         * -- has ToReEnable with right nodeId
         * -- nUNL size still 1, right nodeId
         *
         * (5) ledgers before the next flag ledger
         * -- nUNL size == 1, right nodeId
         * -- has ToDisable with right nodeId
         * -- has ToReEnable with right nodeId
         *
         * (6) next flag ledger
         * -- nUNL size == 1, different nodeId
         * -- no ToDisable
         * -- no ToReEnable
         * -- apply an Disable Tx with different nodeId
         * -- nUNL size still 1, right nodeId
         * -- has ToDisable with right nodeId
         * -- no ToReEnable
         *
         * (7) ledgers before the next flag ledger
         * -- nUNL size still 1, right nodeId
         * -- has ToDisable with right nodeId
         * -- no ToReEnable
         *
         * (8) next flag ledger
         * -- nUNL size == 2
         * -- apply a ReEnable Tx
         * -- cannot apply second ReEnable Tx, even with right nodeId
         * -- cannot apply an Disable Tx with the same NodeId as Remove
         * -- nUNL size == 2
         * -- no ToDisable
         * -- has ToReEnable with right nodeId
         *
         * (9) ledgers before the next flag ledger
         * -- nUNL size == 2
         * -- no ToDisable
         * -- has ToReEnable with right nodeId
         *
         * (10) next flag ledger
         * -- nUNL size == 1
         * -- apply a ReEnable Tx
         * -- nUNL size == 1
         * -- no ToDisable
         * -- has ToReEnable with right nodeId
         *
         * (11) ledgers before the next flag ledger
         * -- nUNL size == 1
         * -- no ToDisable
         * -- has ToReEnable with right nodeId
         *
         * (12) next flag ledger
         * -- nUNL size == 0
         * -- no ToDisable
         * -- no ToReEnable
         *
         * (13) ledgers before the next flag ledger
         * -- nUNL size == 0
         * -- no ToDisable
         * -- no ToReEnable
         *
         * (14) next flag ledger
         * -- nUNL size == 0
         * -- no ToDisable
         * -- no ToReEnable
         */
 
        testcase("Create UNLModify Tx and apply to ledgers");
 
        jtx::Env env(*this, jtx::testableAmendments());
        std::vector<PublicKey> publicKeys = createPublicKeys(3);
        // genesis ledger
        auto l = std::make_shared<Ledger>(
            kCreateGenesis,
            Rules{env.app().config().features},
            env.app().config().fees.toFees(),
            std::vector<uint256>{},
            env.app().getNodeFamily());
 
        // Record the public keys and ledger sequences of expected negative UNL
        // validators when we build the ledger history
        hash_map<PublicKey, std::uint32_t> nUnlLedgerSeq;
 
        {
            //(1) the ledger after genesis, not a flag ledger
            l = std::make_shared<Ledger>(*l, env.app().getTimeKeeper().closeTime());
 
            auto txDisable0 = createTx(true, l->seq(), publicKeys[0]);
            auto txReEnable1 = createTx(false, l->seq(), publicKeys[1]);
 
            OpenView accum(&*l);
            BEAST_EXPECT(applyAndTestResult(env, accum, txDisable0, false));
            BEAST_EXPECT(applyAndTestResult(env, accum, txReEnable1, false));
            accum.apply(*l);
            BEAST_EXPECT(negUnlSizeTest(l, 0, false, false));
        }
 
        {
            //(2) a flag ledger
            // generate more ledgers
            for (auto i = 0; i < 256 - 2; ++i)
            {
                l = std::make_shared<Ledger>(*l, env.app().getTimeKeeper().closeTime());
            }
            BEAST_EXPECT(l->isFlagLedger());
            l->updateNegativeUNL();
 
            auto txDisable0 = createTx(true, l->seq(), publicKeys[0]);
            auto txDisable1 = createTx(true, l->seq(), publicKeys[1]);
            auto txReEnable2 = createTx(false, l->seq(), publicKeys[2]);
 
            // can apply 1 and only 1 ToDisable Tx,
            // cannot apply ToReEnable Tx, since negative UNL is empty
            OpenView accum(&*l);
            BEAST_EXPECT(applyAndTestResult(env, accum, txDisable0, true));
            BEAST_EXPECT(applyAndTestResult(env, accum, txDisable1, false));
            BEAST_EXPECT(applyAndTestResult(env, accum, txReEnable2, false));
            accum.apply(*l);
            auto goodSize = negUnlSizeTest(l, 0, true, false);
            BEAST_EXPECT(goodSize);
            if (goodSize)
            {
                BEAST_EXPECT(l->validatorToDisable() == publicKeys[0]);
                //++ first ToDisable Tx in ledger's TxSet
                uint256 const txID = txDisable0.getTransactionID();
                BEAST_EXPECT(l->txExists(txID));
            }
        }
 
        {
            //(3) ledgers before the next flag ledger
            for (auto i = 0; i < 256; ++i)
            {
                auto goodSize = negUnlSizeTest(l, 0, true, false);
                BEAST_EXPECT(goodSize);
                if (goodSize)
                    BEAST_EXPECT(l->validatorToDisable() == publicKeys[0]);
                l = std::make_shared<Ledger>(*l, env.app().getTimeKeeper().closeTime());
            }
            BEAST_EXPECT(l->isFlagLedger());
            l->updateNegativeUNL();
 
            //(4) next flag ledger
            // test if the ledger updated correctly
            auto goodSize = negUnlSizeTest(l, 1, false, false);
            BEAST_EXPECT(goodSize);
            if (goodSize)
            {
                BEAST_EXPECT(*(l->negativeUNL().begin()) == publicKeys[0]);
                nUnlLedgerSeq.emplace(publicKeys[0], l->seq());
            }
 
            auto txDisable0 = createTx(true, l->seq(), publicKeys[0]);
            auto txDisable1 = createTx(true, l->seq(), publicKeys[1]);
            auto txReEnable0 = createTx(false, l->seq(), publicKeys[0]);
            auto txReEnable1 = createTx(false, l->seq(), publicKeys[1]);
            auto txReEnable2 = createTx(false, l->seq(), publicKeys[2]);
 
            OpenView accum(&*l);
            BEAST_EXPECT(applyAndTestResult(env, accum, txDisable0, false));
            BEAST_EXPECT(applyAndTestResult(env, accum, txDisable1, true));
            BEAST_EXPECT(applyAndTestResult(env, accum, txReEnable1, false));
            BEAST_EXPECT(applyAndTestResult(env, accum, txReEnable2, false));
            BEAST_EXPECT(applyAndTestResult(env, accum, txReEnable0, true));
            accum.apply(*l);
            goodSize = negUnlSizeTest(l, 1, true, true);
            BEAST_EXPECT(goodSize);
            if (goodSize)
            {
                BEAST_EXPECT(l->negativeUNL().count(publicKeys[0]));
                BEAST_EXPECT(l->validatorToDisable() == publicKeys[1]);
                BEAST_EXPECT(l->validatorToReEnable() == publicKeys[0]);
                // test sfFirstLedgerSequence
                BEAST_EXPECT(verifyPubKeyAndSeq(l, nUnlLedgerSeq));
            }
        }
 
        {
            //(5) ledgers before the next flag ledger
            for (auto i = 0; i < 256; ++i)
            {
                auto goodSize = negUnlSizeTest(l, 1, true, true);
                BEAST_EXPECT(goodSize);
                if (goodSize)
                {
                    BEAST_EXPECT(l->negativeUNL().count(publicKeys[0]));
                    BEAST_EXPECT(l->validatorToDisable() == publicKeys[1]);
                    BEAST_EXPECT(l->validatorToReEnable() == publicKeys[0]);
                }
                l = std::make_shared<Ledger>(*l, env.app().getTimeKeeper().closeTime());
            }
            BEAST_EXPECT(l->isFlagLedger());
            l->updateNegativeUNL();
 
            //(6) next flag ledger
            // test if the ledger updated correctly
            auto goodSize = negUnlSizeTest(l, 1, false, false);
            BEAST_EXPECT(goodSize);
            if (goodSize)
            {
                BEAST_EXPECT(l->negativeUNL().count(publicKeys[1]));
            }
 
            auto txDisable0 = createTx(true, l->seq(), publicKeys[0]);
 
            OpenView accum(&*l);
            BEAST_EXPECT(applyAndTestResult(env, accum, txDisable0, true));
            accum.apply(*l);
            goodSize = negUnlSizeTest(l, 1, true, false);
            BEAST_EXPECT(goodSize);
            if (goodSize)
            {
                BEAST_EXPECT(l->negativeUNL().count(publicKeys[1]));
                BEAST_EXPECT(l->validatorToDisable() == publicKeys[0]);
                nUnlLedgerSeq.emplace(publicKeys[1], l->seq());
                nUnlLedgerSeq.erase(publicKeys[0]);
                BEAST_EXPECT(verifyPubKeyAndSeq(l, nUnlLedgerSeq));
            }
        }
 
        {
            //(7) ledgers before the next flag ledger
            for (auto i = 0; i < 256; ++i)
            {
                auto goodSize = negUnlSizeTest(l, 1, true, false);
                BEAST_EXPECT(goodSize);
                if (goodSize)
                {
                    BEAST_EXPECT(l->negativeUNL().count(publicKeys[1]));
                    BEAST_EXPECT(l->validatorToDisable() == publicKeys[0]);
                }
                l = std::make_shared<Ledger>(*l, env.app().getTimeKeeper().closeTime());
            }
            BEAST_EXPECT(l->isFlagLedger());
            l->updateNegativeUNL();
 
            //(8) next flag ledger
            // test if the ledger updated correctly
            auto goodSize = negUnlSizeTest(l, 2, false, false);
            BEAST_EXPECT(goodSize);
            if (goodSize)
            {
                BEAST_EXPECT(l->negativeUNL().count(publicKeys[0]));
                BEAST_EXPECT(l->negativeUNL().count(publicKeys[1]));
                nUnlLedgerSeq.emplace(publicKeys[0], l->seq());
                BEAST_EXPECT(verifyPubKeyAndSeq(l, nUnlLedgerSeq));
            }
 
            auto txDisable0 = createTx(true, l->seq(), publicKeys[0]);
            auto txReEnable0 = createTx(false, l->seq(), publicKeys[0]);
            auto txReEnable1 = createTx(false, l->seq(), publicKeys[1]);
 
            OpenView accum(&*l);
            BEAST_EXPECT(applyAndTestResult(env, accum, txReEnable0, true));
            BEAST_EXPECT(applyAndTestResult(env, accum, txReEnable1, false));
            BEAST_EXPECT(applyAndTestResult(env, accum, txDisable0, false));
            accum.apply(*l);
            goodSize = negUnlSizeTest(l, 2, false, true);
            BEAST_EXPECT(goodSize);
            if (goodSize)
            {
                BEAST_EXPECT(l->negativeUNL().count(publicKeys[0]));
                BEAST_EXPECT(l->negativeUNL().count(publicKeys[1]));
                BEAST_EXPECT(l->validatorToReEnable() == publicKeys[0]);
                BEAST_EXPECT(verifyPubKeyAndSeq(l, nUnlLedgerSeq));
            }
        }
 
        {
            //(9) ledgers before the next flag ledger
            for (auto i = 0; i < 256; ++i)
            {
                auto goodSize = negUnlSizeTest(l, 2, false, true);
                BEAST_EXPECT(goodSize);
                if (goodSize)
                {
                    BEAST_EXPECT(l->negativeUNL().count(publicKeys[0]));
                    BEAST_EXPECT(l->negativeUNL().count(publicKeys[1]));
                    BEAST_EXPECT(l->validatorToReEnable() == publicKeys[0]);
                }
                l = std::make_shared<Ledger>(*l, env.app().getTimeKeeper().closeTime());
            }
            BEAST_EXPECT(l->isFlagLedger());
            l->updateNegativeUNL();
 
            //(10) next flag ledger
            // test if the ledger updated correctly
            auto goodSize = negUnlSizeTest(l, 1, false, false);
            BEAST_EXPECT(goodSize);
            if (goodSize)
            {
                BEAST_EXPECT(l->negativeUNL().count(publicKeys[1]));
                nUnlLedgerSeq.erase(publicKeys[0]);
                BEAST_EXPECT(verifyPubKeyAndSeq(l, nUnlLedgerSeq));
            }
 
            auto txReEnable1 = createTx(false, l->seq(), publicKeys[1]);
 
            OpenView accum(&*l);
            BEAST_EXPECT(applyAndTestResult(env, accum, txReEnable1, true));
            accum.apply(*l);
            goodSize = negUnlSizeTest(l, 1, false, true);
            BEAST_EXPECT(goodSize);
            if (goodSize)
            {
                BEAST_EXPECT(l->negativeUNL().count(publicKeys[1]));
                BEAST_EXPECT(l->validatorToReEnable() == publicKeys[1]);
                BEAST_EXPECT(verifyPubKeyAndSeq(l, nUnlLedgerSeq));
            }
        }
 
        {
            //(11) ledgers before the next flag ledger
            for (auto i = 0; i < 256; ++i)
            {
                auto goodSize = negUnlSizeTest(l, 1, false, true);
                BEAST_EXPECT(goodSize);
                if (goodSize)
                {
                    BEAST_EXPECT(l->negativeUNL().count(publicKeys[1]));
                    BEAST_EXPECT(l->validatorToReEnable() == publicKeys[1]);
                }
                l = std::make_shared<Ledger>(*l, env.app().getTimeKeeper().closeTime());
            }
            BEAST_EXPECT(l->isFlagLedger());
            l->updateNegativeUNL();
 
            //(12) next flag ledger
            BEAST_EXPECT(negUnlSizeTest(l, 0, false, false));
        }
 
        {
            //(13) ledgers before the next flag ledger
            for (auto i = 0; i < 256; ++i)
            {
                BEAST_EXPECT(negUnlSizeTest(l, 0, false, false));
                l = std::make_shared<Ledger>(*l, env.app().getTimeKeeper().closeTime());
            }
            BEAST_EXPECT(l->isFlagLedger());
            l->updateNegativeUNL();
 
            //(14) next flag ledger
            BEAST_EXPECT(negUnlSizeTest(l, 0, false, false));
        }
    }
 
    void
    run() override
    {
        testNegativeUNL();
    }
};

struct NetworkHistory
{
    using LedgerHistory = std::vector<std::shared_ptr<Ledger>>;
    struct Parameter
    {
        std::uint32_t numNodes;    // number of validators
        std::uint32_t negUNLSize;  // size of negative UNL in the last ledger
        bool hasToDisable;         // if has ToDisable in the last ledger
        bool hasToReEnable;        // if has ToReEnable in the last ledger
        std::optional<int> numLedgers;
    };
 
    NetworkHistory(beast::unit_test::Suite& suite, Parameter const& p)
        : env(suite, jtx::testableAmendments()), param(p), validations(env.app().getValidations())
    {
        createNodes();
        if (!param.numLedgers)
            param.numLedgers = 256 * (param.negUNLSize + 1);
        goodHistory = createLedgerHistory();
    }
 
    void
    createNodes()
    {
        assert(param.numNodes <= 256);
        unlKeys = createPublicKeys(param.numNodes);
        for (int i = 0; i < param.numNodes; ++i)
        {
            unlKeySet.insert(unlKeys[i]);
            unlNodeIDs.push_back(calcNodeID(unlKeys[i]));
            unlNodeIdSet.insert(unlNodeIDs.back());
        }
    }

    bool
    createLedgerHistory()
    {
        static uint256 kFakeAmendment;  // So we have different genesis ledgers
        auto l = std::make_shared<Ledger>(
            kCreateGenesis,
            Rules{env.app().config().features},
            env.app().config().fees.toFees(),
            std::vector<uint256>{kFakeAmendment++},
            env.app().getNodeFamily());
        history.push_back(l);
 
        // When putting validators into the negative UNL, we start with
        // validator 0, then validator 1 ...
        int nidx = 0;
        while (l->seq() <= param.numLedgers)
        {
            l = std::make_shared<Ledger>(*l, env.app().getTimeKeeper().closeTime());
            history.push_back(l);
 
            if (l->isFlagLedger())
            {
                l->updateNegativeUNL();
                OpenView accum(&*l);
                if (l->negativeUNL().size() < param.negUNLSize)
                {
                    auto tx = createTx(true, l->seq(), unlKeys[nidx]);
                    if (!applyAndTestResult(env, accum, tx, true))
                        break;
                    ++nidx;
                }
                else if (l->negativeUNL().size() == param.negUNLSize)
                {
                    if (param.hasToDisable)
                    {
                        auto tx = createTx(true, l->seq(), unlKeys[nidx]);
                        if (!applyAndTestResult(env, accum, tx, true))
                            break;
                        ++nidx;
                    }
                    if (param.hasToReEnable)
                    {
                        auto tx = createTx(false, l->seq(), unlKeys[0]);
                        if (!applyAndTestResult(env, accum, tx, true))
                            break;
                    }
                }
                accum.apply(*l);
            }
            l->updateSkipList();
        }
        return negUnlSizeTest(l, param.negUNLSize, param.hasToDisable, param.hasToReEnable);
    }

    std::shared_ptr<STValidation>
    createSTVal(std::shared_ptr<Ledger const> const& ledger, NodeID const& v)
    {
        static auto kEyPair = randomKeyPair(KeyType::Secp256k1);
        return std::make_shared<STValidation>(
            env.app().getTimeKeeper().now(),
            kEyPair.first,
            kEyPair.second,
            v,
            [&](STValidation& v) {
                v.setFieldH256(sfLedgerHash, ledger->header().hash);
                v.setFieldU32(sfLedgerSequence, ledger->seq());
                v.setFlag(kVfFullValidation);
            });
    };

    template <class NeedValidation>
    void
    walkHistoryAndAddValidations(NeedValidation&& needVal)
    {
        std::uint32_t curr = 0;
        std::size_t const need = 256 + 1;
        // only last 256 + 1 ledgers need validations
        if (history.size() > need)
            curr = history.size() - need;
        for (; curr != history.size(); ++curr)
        {
            for (std::size_t i = 0; i < param.numNodes; ++i)
            {
                if (needVal(history[curr], i))
                {
                    RCLValidation v(createSTVal(history[curr], unlNodeIDs[i]));
                    v.setTrusted();
                    validations.add(unlNodeIDs[i], v);
                }
            }
        }
    }
 
    [[nodiscard]] std::shared_ptr<Ledger const>
    lastLedger() const
    {
        return history.back();
    }
 
    jtx::Env env;
    Parameter param;
    RCLValidations& validations;
    std::vector<PublicKey> unlKeys;
    hash_set<PublicKey> unlKeySet;
    std::vector<NodeID> unlNodeIDs;
    hash_set<NodeID> unlNodeIdSet;
    LedgerHistory history;
    bool goodHistory;
};
 
auto gDefaultPreVote = [](NegativeUNLVote& vote) {};
template <typename PreVote = decltype(gDefaultPreVote)>
bool
voteAndCheck(
    NetworkHistory& history,
    NodeID const& myId,
    std::size_t expect,
    PreVote const& pre = gDefaultPreVote)
{
    NegativeUNLVote vote(myId, history.env.journal);
    pre(vote);
    auto txSet =
        std::make_shared<SHAMap>(SHAMapType::TRANSACTION, history.env.app().getNodeFamily());
    vote.doVoting(history.lastLedger(), history.unlKeySet, history.validations, txSet);
    return countTx(txSet) == expect;
}

class NegativeUNLVoteInternal_test : public beast::unit_test::Suite
{
    void
    testAddTx()
    {
        testcase("Create UNLModify Tx");
        jtx::Env env(*this);
 
        NodeID const myId(0xA0);
        NegativeUNLVote vote(myId, env.journal);
 
        // one add, one remove
        auto txSet = std::make_shared<SHAMap>(SHAMapType::TRANSACTION, env.app().getNodeFamily());
        PublicKey const toDisableKey(derivePublicKey(KeyType::Ed25519, randomSecretKey()));
        PublicKey const toReEnableKey(derivePublicKey(KeyType::Ed25519, randomSecretKey()));
        LedgerIndex const seq(1234);
        BEAST_EXPECT(countTx(txSet) == 0);
        vote.addTx(seq, toDisableKey, NegativeUNLVote::NegativeUNLModify::ToDisable, txSet);
        BEAST_EXPECT(countTx(txSet) == 1);
        vote.addTx(seq, toReEnableKey, NegativeUNLVote::NegativeUNLModify::ToReEnable, txSet);
        BEAST_EXPECT(countTx(txSet) == 2);
        // content of a tx is implicitly tested after applied to a ledger
        // in later test cases
    }
 
    void
    testPickOneCandidate()
    {
        testcase("Pick One Candidate");
        jtx::Env const env(*this);
 
        NodeID const myId(0xA0);
        NegativeUNLVote const vote(myId, env.journal);
 
        uint256 const pad0(0);
        uint256 const padF = ~pad0;
        NodeID const n1(1);
        NodeID const n2(2);
        NodeID const n3(3);
        std::vector<NodeID> candidates({n1});
        BEAST_EXPECT(vote.choose(pad0, candidates) == n1);
        BEAST_EXPECT(vote.choose(padF, candidates) == n1);
        candidates.emplace_back(2);
        BEAST_EXPECT(vote.choose(pad0, candidates) == n1);
        BEAST_EXPECT(vote.choose(padF, candidates) == n2);
        candidates.emplace_back(3);
        BEAST_EXPECT(vote.choose(pad0, candidates) == n1);
        BEAST_EXPECT(vote.choose(padF, candidates) == n3);
    }
 
    void
    testBuildScoreTableSpecialCases()
    {
        testcase("Build Score Table");
        /*
         * 1. no skip list
         * 2. short skip list
         * 3. local node not enough history
         * 4. a node double validated some seq
         * 5. local node had enough validations but on a wrong chain
         * 6. a good case, long enough history and perfect scores
         */
        {
            // 1. no skip list
            NetworkHistory history = {
                *this,
                {.numNodes = 10,
                 .negUNLSize = 0,
                 .hasToDisable = false,
                 .hasToReEnable = false,
                 .numLedgers = 1}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                NegativeUNLVote vote(history.unlNodeIDs[3], history.env.journal);
                BEAST_EXPECT(!vote.buildScoreTable(
                    history.lastLedger(), history.unlNodeIdSet, history.validations));
            }
        }
 
        {
            // 2. short skip list
            NetworkHistory history = {
                *this,
                {.numNodes = 10,
                 .negUNLSize = 0,
                 .hasToDisable = false,
                 .hasToReEnable = false,
                 .numLedgers = 256 / 2}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                NegativeUNLVote vote(history.unlNodeIDs[3], history.env.journal);
                BEAST_EXPECT(!vote.buildScoreTable(
                    history.lastLedger(), history.unlNodeIdSet, history.validations));
            }
        }
 
        {
            // 3. local node not enough history
            NetworkHistory history = {
                *this,
                {.numNodes = 10,
                 .negUNLSize = 0,
                 .hasToDisable = false,
                 .hasToReEnable = false,
                 .numLedgers = 256 + 2}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                NodeID myId = history.unlNodeIDs[3];
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        // skip half my validations.
                        return history.unlNodeIDs[idx] != myId || l->seq() % 2 != 0;
                    });
                NegativeUNLVote vote(myId, history.env.journal);
                BEAST_EXPECT(!vote.buildScoreTable(
                    history.lastLedger(), history.unlNodeIdSet, history.validations));
            }
        }
 
        {
            // 4. a node double validated some seq
            // 5. local node had enough validations but on a wrong chain
            NetworkHistory history = {
                *this,
                {.numNodes = 10,
                 .negUNLSize = 0,
                 .hasToDisable = false,
                 .hasToReEnable = false,
                 .numLedgers = 256 + 2}};
            // We need two chains for these tests
            bool const wrongChainSuccess = history.goodHistory;
            BEAST_EXPECT(wrongChainSuccess);
            NetworkHistory::LedgerHistory wrongChain = std::move(history.history);
            // Create a new chain and use it as the one that majority of nodes
            // follow
            history.createLedgerHistory();
            BEAST_EXPECT(history.goodHistory);
 
            if (history.goodHistory && wrongChainSuccess)
            {
                NodeID myId = history.unlNodeIDs[3];
                NodeID const badNode = history.unlNodeIDs[4];
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        // everyone but me
                        return !(history.unlNodeIDs[idx] == myId);
                    });
 
                // local node validate wrong chain
                // a node double validates
                for (auto& l : wrongChain)
                {
                    RCLValidation const v1(history.createSTVal(l, myId));
                    history.validations.add(myId, v1);
                    RCLValidation const v2(history.createSTVal(l, badNode));
                    history.validations.add(badNode, v2);
                }
 
                NegativeUNLVote vote(myId, history.env.journal);
 
                // local node still on wrong chain, can build a scoreTable,
                // but all other nodes' scores are zero
                auto scoreTable = vote.buildScoreTable(
                    wrongChain.back(), history.unlNodeIdSet, history.validations);
                BEAST_EXPECT(scoreTable);
                if (scoreTable)
                {
                    for (auto const& [n, score] : *scoreTable)
                    {
                        if (n == myId)
                        {
                            BEAST_EXPECT(score == 256);
                        }
                        else
                        {
                            BEAST_EXPECT(score == 0);
                        }
                    }
                }
 
                // if local node switched to right history, but cannot build
                // scoreTable because not enough local validations
                BEAST_EXPECT(!vote.buildScoreTable(
                    history.lastLedger(), history.unlNodeIdSet, history.validations));
            }
        }
 
        {
            // 6. a good case
            NetworkHistory history = {
                *this,
                {.numNodes = 10,
                 .negUNLSize = 0,
                 .hasToDisable = false,
                 .hasToReEnable = false,
                 .numLedgers = 256 + 1}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        return true;
                    });
                NegativeUNLVote vote(history.unlNodeIDs[3], history.env.journal);
                auto scoreTable = vote.buildScoreTable(
                    history.lastLedger(), history.unlNodeIdSet, history.validations);
                BEAST_EXPECT(scoreTable);
                if (scoreTable)
                {
                    for (auto const& [_, score] : *scoreTable)
                    {
                        (void)_;
                        BEAST_EXPECT(score == 256);
                    }
                }
            }
        }
    }

    static bool
    checkCandidateSizes(
        NegativeUNLVote& vote,
        hash_set<NodeID> const& unl,
        hash_set<NodeID> const& negUnl,
        hash_map<NodeID, std::uint32_t> const& scoreTable,
        std::size_t numDisable,
        std::size_t numReEnable)
    {
        auto [disableCandidates, reEnableCandidates] =
            vote.findAllCandidates(unl, negUnl, scoreTable);
        bool const rightDisable = disableCandidates.size() == numDisable;
        bool const rightReEnable = reEnableCandidates.size() == numReEnable;
        return rightDisable && rightReEnable;
    };
 
    void
    testFindAllCandidates()
    {
        testcase("Find All Candidates");
        /*
         * -- unl size: 35
         * -- negUnl size: 3
         *
         * 0. all good scores
         * 1. all bad scores
         * 2. all between watermarks
         * 3. 2 good scorers in negUnl
         * 4. 2 bad scorers not in negUnl
         * 5. 2 in negUnl but not in unl, have a remove candidate from score
         * table
         * 6. 2 in negUnl but not in unl, no remove candidate from score table
         * 7. 2 new validators have good scores, already in negUnl
         * 8. 2 new validators have bad scores, not in negUnl
         * 9. expired the new validators have bad scores, not in negUnl
         */
        NetworkHistory history = {
            *this,
            {.numNodes = 35,
             .negUNLSize = 0,
             .hasToDisable = false,
             .hasToReEnable = false,
             .numLedgers = 0}};
 
        hash_set<NodeID> negUnl012;
        for (std::uint32_t i = 0; i < 3; ++i)
            negUnl012.insert(history.unlNodeIDs[i]);
 
        // build a good scoreTable to use, or copy and modify
        hash_map<NodeID, std::uint32_t> goodScoreTable;
        for (auto const& n : history.unlNodeIDs)
            goodScoreTable[n] = NegativeUNLVote::kNegativeUnlHighWaterMark + 1;
 
        NegativeUNLVote vote(history.unlNodeIDs[0], history.env.journal);
 
        {
            // all good scores
            BEAST_EXPECT(
                checkCandidateSizes(vote, history.unlNodeIdSet, negUnl012, goodScoreTable, 0, 3));
        }
        {
            // all bad scores
            hash_map<NodeID, std::uint32_t> scoreTable;
            for (auto& n : history.unlNodeIDs)
                scoreTable[n] = NegativeUNLVote::kNegativeUnlLowWaterMark - 1;
            BEAST_EXPECT(
                checkCandidateSizes(vote, history.unlNodeIdSet, negUnl012, scoreTable, 35 - 3, 0));
        }
        {
            // all between watermarks
            hash_map<NodeID, std::uint32_t> scoreTable;
            for (auto& n : history.unlNodeIDs)
                scoreTable[n] = NegativeUNLVote::kNegativeUnlLowWaterMark + 1;
            BEAST_EXPECT(
                checkCandidateSizes(vote, history.unlNodeIdSet, negUnl012, scoreTable, 0, 0));
        }
 
        {
            // 2 good scorers in negUnl
            auto scoreTable = goodScoreTable;
            scoreTable[*negUnl012.begin()] = NegativeUNLVote::kNegativeUnlLowWaterMark + 1;
            BEAST_EXPECT(
                checkCandidateSizes(vote, history.unlNodeIdSet, negUnl012, scoreTable, 0, 2));
        }
 
        {
            // 2 bad scorers not in negUnl
            auto scoreTable = goodScoreTable;
            scoreTable[history.unlNodeIDs[11]] = NegativeUNLVote::kNegativeUnlLowWaterMark - 1;
            scoreTable[history.unlNodeIDs[12]] = NegativeUNLVote::kNegativeUnlLowWaterMark - 1;
            BEAST_EXPECT(
                checkCandidateSizes(vote, history.unlNodeIdSet, negUnl012, scoreTable, 2, 3));
        }
 
        {
            // 2 in negUnl but not in unl, have a remove candidate from score
            // table
            hash_set<NodeID> unlTemp = history.unlNodeIdSet;
            unlTemp.erase(history.unlNodeIDs[0]);
            unlTemp.erase(history.unlNodeIDs[1]);
            BEAST_EXPECT(checkCandidateSizes(vote, unlTemp, negUnl012, goodScoreTable, 0, 3));
        }
 
        {
            // 2 in negUnl but not in unl, no remove candidate from score table
            auto scoreTable = goodScoreTable;
            scoreTable.erase(history.unlNodeIDs[0]);
            scoreTable.erase(history.unlNodeIDs[1]);
            scoreTable[history.unlNodeIDs[2]] = NegativeUNLVote::kNegativeUnlLowWaterMark + 1;
            hash_set<NodeID> unlTemp = history.unlNodeIdSet;
            unlTemp.erase(history.unlNodeIDs[0]);
            unlTemp.erase(history.unlNodeIDs[1]);
            BEAST_EXPECT(checkCandidateSizes(vote, unlTemp, negUnl012, scoreTable, 0, 2));
        }
 
        {
            // 2 new validators
            NodeID const new1(0xbead);
            NodeID const new2(0xbeef);
            hash_set<NodeID> const nowTrusted = {new1, new2};
            hash_set<NodeID> unlTemp = history.unlNodeIdSet;
            unlTemp.insert(new1);
            unlTemp.insert(new2);
            vote.newValidators(256, nowTrusted);
            {
                // 2 new validators have good scores, already in negUnl
                auto scoreTable = goodScoreTable;
                scoreTable[new1] = NegativeUNLVote::kNegativeUnlHighWaterMark + 1;
                scoreTable[new2] = NegativeUNLVote::kNegativeUnlHighWaterMark + 1;
                hash_set<NodeID> negUnlTemp = negUnl012;
                negUnlTemp.insert(new1);
                negUnlTemp.insert(new2);
                BEAST_EXPECT(checkCandidateSizes(vote, unlTemp, negUnlTemp, scoreTable, 0, 3 + 2));
            }
            {
                // 2 new validators have bad scores, not in negUnl
                auto scoreTable = goodScoreTable;
                scoreTable[new1] = 0;
                scoreTable[new2] = 0;
                BEAST_EXPECT(checkCandidateSizes(vote, unlTemp, negUnl012, scoreTable, 0, 3));
            }
            {
                // expired the new validators have bad scores, not in negUnl
                vote.purgeNewValidators(256 + NegativeUNLVote::kNewValidatorDisableSkip + 1);
                auto scoreTable = goodScoreTable;
                scoreTable[new1] = 0;
                scoreTable[new2] = 0;
                BEAST_EXPECT(checkCandidateSizes(vote, unlTemp, negUnl012, scoreTable, 2, 3));
            }
        }
    }
 
    void
    testFindAllCandidatesCombination()
    {
        testcase("Find All Candidates Combination");
        /*
         * == combination 1:
         * -- unl size: 34, 35, 80
         * -- nUnl size: 0, 50%, all
         * -- score pattern: all 0, all negativeUNLLowWaterMark & +1 & -1, all
         * negativeUNLHighWaterMark & +1 & -1, all 100%
         *
         * == combination 2:
         * -- unl size: 34, 35, 80
         * -- negativeUNL size: 0, all
         * -- nUnl size: one on, one off, one on, one off,
         * -- score pattern: 2*(negativeUNLLowWaterMark, +1, -1) &
         * 2*(negativeUNLHighWaterMark, +1, -1) & rest
         * negativeUNLMinLocalValsToVote
         */
 
        jtx::Env const env(*this);
 
        NodeID const myId(0xA0);
        NegativeUNLVote vote(myId, env.journal);
 
        std::array<std::uint32_t, 3> const unlSizes = {34, 35, 80};
        std::array<std::uint32_t, 3> const nUnlPercent = {0, 50, 100};
        std::array<std::uint32_t, 8> scores = {
            0,
            NegativeUNLVote::kNegativeUnlLowWaterMark - 1,
            NegativeUNLVote::kNegativeUnlLowWaterMark,
            NegativeUNLVote::kNegativeUnlLowWaterMark + 1,
            NegativeUNLVote::kNegativeUnlHighWaterMark - 1,
            NegativeUNLVote::kNegativeUnlHighWaterMark,
            NegativeUNLVote::kNegativeUnlHighWaterMark + 1,
            NegativeUNLVote::kNegativeUnlMinLocalValsToVote};
 
        //== combination 1:
        {
            auto fillScoreTable = [&](std::uint32_t unlSize,
                                      std::uint32_t nUnlSize,
                                      std::uint32_t score,
                                      hash_set<NodeID>& unl,
                                      hash_set<NodeID>& negUnl,
                                      hash_map<NodeID, std::uint32_t>& scoreTable) {
                std::vector<NodeID> nodeIDs;
                std::vector<PublicKey> const keys = createPublicKeys(unlSize);
                for (auto const& k : keys)
                {
                    nodeIDs.emplace_back(calcNodeID(k));
                    unl.emplace(nodeIDs.back());
                    scoreTable[nodeIDs.back()] = score;
                }
                for (std::uint32_t i = 0; i < nUnlSize; ++i)
                    negUnl.insert(nodeIDs[i]);
            };
 
            for (auto us : unlSizes)
            {
                for (auto np : nUnlPercent)
                {
                    for (auto score : scores)
                    {
                        hash_set<NodeID> unl;
                        hash_set<NodeID> negUnl;
                        hash_map<NodeID, std::uint32_t> scoreTable;
                        fillScoreTable(us, us * np / 100, score, unl, negUnl, scoreTable);
                        BEAST_EXPECT(unl.size() == us);
                        BEAST_EXPECT(negUnl.size() == us * np / 100);
                        BEAST_EXPECT(scoreTable.size() == us);
 
                        std::size_t toDisableExpect = 0;
                        std::size_t toReEnableExpect = 0;
                        if (np == 0)
                        {
                            if (score < NegativeUNLVote::kNegativeUnlLowWaterMark)
                            {
                                toDisableExpect = us;
                            }
                        }
                        else if (np == 50)
                        {
                            if (score > NegativeUNLVote::kNegativeUnlHighWaterMark)
                            {
                                toReEnableExpect = us * np / 100;
                            }
                        }
                        else
                        {
                            if (score > NegativeUNLVote::kNegativeUnlHighWaterMark)
                            {
                                toReEnableExpect = us;
                            }
                        }
                        BEAST_EXPECT(checkCandidateSizes(
                            vote, unl, negUnl, scoreTable, toDisableExpect, toReEnableExpect));
                    }
                }
            }
 
            //== combination 2:
            {
                auto fillScoreTable = [&](std::uint32_t unlSize,
                                          std::uint32_t nUnlPercent,
                                          hash_set<NodeID>& unl,
                                          hash_set<NodeID>& negUnl,
                                          hash_map<NodeID, std::uint32_t>& scoreTable) {
                    std::vector<NodeID> nodeIDs;
                    std::vector<PublicKey> const keys = createPublicKeys(unlSize);
                    for (auto const& k : keys)
                    {
                        nodeIDs.emplace_back(calcNodeID(k));
                        unl.emplace(nodeIDs.back());
                    }
 
                    std::uint32_t nIdx = 0;
                    for (auto score : scores)
                    {
                        scoreTable[nodeIDs[nIdx++]] = score;
                        scoreTable[nodeIDs[nIdx++]] = score;
                    }
                    for (; nIdx < unlSize;)
                    {
                        scoreTable[nodeIDs[nIdx++]] = scores.back();
                    }
 
                    if (nUnlPercent == 100)
                    {
                        negUnl = unl;
                    }
                    else if (nUnlPercent == 50)
                    {
                        for (std::uint32_t i = 1; i < unlSize; i += 2)
                            negUnl.insert(nodeIDs[i]);
                    }
                };
 
                for (auto us : unlSizes)
                {
                    for (auto np : nUnlPercent)
                    {
                        hash_set<NodeID> unl;
                        hash_set<NodeID> negUnl;
                        hash_map<NodeID, std::uint32_t> scoreTable;
 
                        fillScoreTable(us, np, unl, negUnl, scoreTable);
                        BEAST_EXPECT(unl.size() == us);
                        BEAST_EXPECT(negUnl.size() == us * np / 100);
                        BEAST_EXPECT(scoreTable.size() == us);
 
                        std::size_t toDisableExpect = 0;
                        std::size_t toReEnableExpect = 0;
                        if (np == 0)
                        {
                            toDisableExpect = 4;
                        }
                        else if (np == 50)
                        {
                            toReEnableExpect = negUnl.size() - 6;
                        }
                        else
                        {
                            toReEnableExpect = negUnl.size() - 12;
                        }
                        BEAST_EXPECT(checkCandidateSizes(
                            vote, unl, negUnl, scoreTable, toDisableExpect, toReEnableExpect));
                    }
                }
            }
        }
    }
 
    void
    testNewValidators()
    {
        testcase("New Validators");
        jtx::Env const env(*this);
 
        NodeID const myId(0xA0);
        NegativeUNLVote vote(myId, env.journal);
 
        // test cases:
        // newValidators_ of the NegativeUNLVote empty, add one
        // add a new one and one already added
        // add a new one and some already added
        // purge and see some are expired
 
        NodeID const n1(0xA1);
        NodeID const n2(0xA2);
        NodeID const n3(0xA3);
 
        vote.newValidators(2, {n1});
        BEAST_EXPECT(vote.newValidators_.size() == 1);
        if (vote.newValidators_.size() == 1)
        {
            BEAST_EXPECT(vote.newValidators_.begin()->first == n1);
            BEAST_EXPECT(vote.newValidators_.begin()->second == 2);
        }
 
        vote.newValidators(3, {n1, n2});
        BEAST_EXPECT(vote.newValidators_.size() == 2);
        if (vote.newValidators_.size() == 2)
        {
            BEAST_EXPECT(vote.newValidators_[n1] == 2);
            BEAST_EXPECT(vote.newValidators_[n2] == 3);
        }
 
        vote.newValidators(NegativeUNLVote::kNewValidatorDisableSkip, {n1, n2, n3});
        BEAST_EXPECT(vote.newValidators_.size() == 3);
        if (vote.newValidators_.size() == 3)
        {
            BEAST_EXPECT(vote.newValidators_[n1] == 2);
            BEAST_EXPECT(vote.newValidators_[n2] == 3);
            BEAST_EXPECT(vote.newValidators_[n3] == NegativeUNLVote::kNewValidatorDisableSkip);
        }
 
        vote.purgeNewValidators(NegativeUNLVote::kNewValidatorDisableSkip + 2);
        BEAST_EXPECT(vote.newValidators_.size() == 3);
        vote.purgeNewValidators(NegativeUNLVote::kNewValidatorDisableSkip + 3);
        BEAST_EXPECT(vote.newValidators_.size() == 2);
        vote.purgeNewValidators(NegativeUNLVote::kNewValidatorDisableSkip + 4);
        BEAST_EXPECT(vote.newValidators_.size() == 1);
        BEAST_EXPECT(vote.newValidators_.begin()->first == n3);
        BEAST_EXPECT(
            vote.newValidators_.begin()->second == NegativeUNLVote::kNewValidatorDisableSkip);
    }
 
    void
    run() override
    {
        testAddTx();
        testPickOneCandidate();
        testBuildScoreTableSpecialCases();
        testFindAllCandidates();
        testFindAllCandidatesCombination();
        testNewValidators();
    }
};

class NegativeUNLVoteScoreTable_test : public beast::unit_test::Suite
{
    void
    testBuildScoreTableCombination()
    {
        testcase("Build Score Table Combination");
        /*
         * local node good history, correct scores:
         * == combination:
         * -- unl size: 10, 34, 35, 50
         * -- score pattern: all 0, all 50%, all 100%, two 0% two 50% rest 100%
         */
        std::array<std::uint32_t, 4> const unlSizes = {10, 34, 35, 50};
        std::array<std::array<std::uint32_t, 3>, 4> scorePattern = {
            {{{0, 0, 0}}, {{50, 50, 50}}, {{100, 100, 100}}, {{0, 50, 100}}}};
 
        for (auto unlSize : unlSizes)
        {
            for (std::uint32_t sp = 0; sp < 4; ++sp)
            {
                NetworkHistory history = {
                    *this,
                    {.numNodes = unlSize,
                     .negUNLSize = 0,
                     .hasToDisable = false,
                     .hasToReEnable = false,
                     .numLedgers = 256 + 2}};
                BEAST_EXPECT(history.goodHistory);
                if (history.goodHistory)
                {
                    NodeID myId = history.unlNodeIDs[3];
                    history.walkHistoryAndAddValidations(
                        [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                            std::size_t k = 0;
                            if (idx < 2)
                            {
                                k = 0;
                            }
                            else if (idx < 4)
                            {
                                k = 1;
                            }
                            else
                            {
                                k = 2;
                            }
 
                            bool const add50 = scorePattern[sp][k] == 50 && l->seq() % 2 == 0;
                            bool const add100 = scorePattern[sp][k] == 100;
                            bool const addMe = history.unlNodeIDs[idx] == myId;
                            return add50 || add100 || addMe;
                        });
 
                    NegativeUNLVote vote(myId, history.env.journal);
                    auto scoreTable = vote.buildScoreTable(
                        history.lastLedger(), history.unlNodeIdSet, history.validations);
                    BEAST_EXPECT(scoreTable);
                    if (scoreTable)
                    {
                        std::uint32_t i = 0;  // looping unl
                        auto checkScores = [&](std::uint32_t score, std::uint32_t k) -> bool {
                            if (history.unlNodeIDs[i] == myId)
                                return score == 256;
                            if (scorePattern[sp][k] == 0)
                                return score == 0;
                            if (scorePattern[sp][k] == 50)
                                return score == 256 / 2;
                            if (scorePattern[sp][k] == 100)
                            {
                                return score == 256;
                            }
 
                            return false;
                        };
                        for (; i < 2; ++i)
                        {
                            BEAST_EXPECT(checkScores((*scoreTable)[history.unlNodeIDs[i]], 0));
                        }
                        for (; i < 4; ++i)
                        {
                            BEAST_EXPECT(checkScores((*scoreTable)[history.unlNodeIDs[i]], 1));
                        }
                        for (; i < unlSize; ++i)
                        {
                            BEAST_EXPECT(checkScores((*scoreTable)[history.unlNodeIDs[i]], 2));
                        }
                    }
                }
            }
        }
    }
 
    void
    run() override
    {
        testBuildScoreTableCombination();
    }
};
 
/*
 * Test the doVoting function of NegativeUNLVote.
 * The test cases are split to 5 classes for parallel execution.
 *
 * Voting tests: (use hasToDisable and hasToReEnable in some of the cases)
 *
 * == all good score, nUnl empty
 * -- txSet.size = 0
 * == all good score, nUnl not empty (use hasToDisable)
 * -- txSet.size = 1
 *
 * == 2 nodes offline, nUnl empty (use hasToReEnable)
 * -- txSet.size = 1
 * == 2 nodes offline, in nUnl
 * -- txSet.size = 0
 *
 * == 2 nodes offline, not in nUnl, but maxListed
 * -- txSet.size = 0
 *
 * == 2 nodes offline including me, not in nUnl
 * -- txSet.size = 0
 * == 2 nodes offline, not in negativeUNL, but I'm not a validator
 * -- txSet.size = 0
 * == 2 in nUnl, but not in unl, no other remove candidates
 * -- txSet.size = 1
 *
 * == 2 new validators have bad scores
 * -- txSet.size = 0
 * == 2 expired new validators have bad scores
 * -- txSet.size = 1
 */
 
class NegativeUNLVoteGoodScore_test : public beast::unit_test::Suite
{
    void
    testDoVoting()
    {
        testcase("Do Voting");
 
        {
            //== all good score, negativeUNL empty
            //-- txSet.size = 0
            NetworkHistory history = {
                *this,
                {.numNodes = 51,
                 .negUNLSize = 0,
                 .hasToDisable = false,
                 .hasToReEnable = false,
                 .numLedgers = {}}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        return true;
                    });
                BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs[0], 0));
            }
        }
 
        {
            // all good score, negativeUNL not empty (use hasToDisable)
            //-- txSet.size = 1
            NetworkHistory history = {
                *this,
                {.numNodes = 37,
                 .negUNLSize = 0,
                 .hasToDisable = true,
                 .hasToReEnable = false,
                 .numLedgers = {}}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        return true;
                    });
                BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs[0], 1));
            }
        }
    }
 
    void
    run() override
    {
        testDoVoting();
    }
};
 
class NegativeUNLVoteOffline_test : public beast::unit_test::Suite
{
    void
    testDoVoting()
    {
        testcase("Do Voting");
 
        {
            //== 2 nodes offline, negativeUNL empty (use hasToReEnable)
            //-- txSet.size = 1
            NetworkHistory history = {
                *this,
                {.numNodes = 29,
                 .negUNLSize = 1,
                 .hasToDisable = false,
                 .hasToReEnable = true,
                 .numLedgers = {}}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        // skip node 0 and node 1
                        return idx > 1;
                    });
                BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs.back(), 1));
            }
        }
 
        {
            // 2 nodes offline, in negativeUNL
            //-- txSet.size = 0
            NetworkHistory history = {
                *this,
                {.numNodes = 30,
                 .negUNLSize = 1,
                 .hasToDisable = true,
                 .hasToReEnable = false,
                 .numLedgers = {}}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                NodeID n1 = calcNodeID(*history.lastLedger()->negativeUNL().begin());
                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                NodeID n2 = calcNodeID(*history.lastLedger()->validatorToDisable());
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        // skip node 0 and node 1
                        return history.unlNodeIDs[idx] != n1 && history.unlNodeIDs[idx] != n2;
                    });
                BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs.back(), 0));
            }
        }
    }
 
    void
    run() override
    {
        testDoVoting();
    }
};
 
class NegativeUNLVoteMaxListed_test : public beast::unit_test::Suite
{
    void
    testDoVoting()
    {
        testcase("Do Voting");
 
        {
            // 2 nodes offline, not in negativeUNL, but maxListed
            //-- txSet.size = 0
            NetworkHistory history = {
                *this,
                {.numNodes = 32,
                 .negUNLSize = 8,
                 .hasToDisable = true,
                 .hasToReEnable = true,
                 .numLedgers = {}}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        // skip node 0 ~ 10
                        return idx > 10;
                    });
                BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs.back(), 0));
            }
        }
    }
 
    void
    run() override
    {
        testDoVoting();
    }
};
 
class NegativeUNLVoteRetiredValidator_test : public beast::unit_test::Suite
{
    void
    testDoVoting()
    {
        testcase("Do Voting");
 
        {
            //== 2 nodes offline including me, not in negativeUNL
            //-- txSet.size = 0
            NetworkHistory history = {
                *this,
                {.numNodes = 35,
                 .negUNLSize = 0,
                 .hasToDisable = false,
                 .hasToReEnable = false,
                 .numLedgers = {}}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        return idx > 1;
                    });
                BEAST_EXPECT(voteAndCheck(history, history.unlNodeIDs[0], 0));
            }
        }
 
        {
            // 2 nodes offline, not in negativeUNL, but I'm not a validator
            //-- txSet.size = 0
            NetworkHistory history = {
                *this,
                {.numNodes = 40,
                 .negUNLSize = 0,
                 .hasToDisable = false,
                 .hasToReEnable = false,
                 .numLedgers = {}}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        return idx > 1;
                    });
                BEAST_EXPECT(voteAndCheck(history, NodeID(0xdeadbeef), 0));
            }
        }
 
        {
            //== 2 in negativeUNL, but not in unl, no other remove candidates
            //-- txSet.size = 1
            NetworkHistory history = {
                *this,
                {.numNodes = 25,
                 .negUNLSize = 2,
                 .hasToDisable = false,
                 .hasToReEnable = false,
                 .numLedgers = {}}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        return idx > 1;
                    });
                BEAST_EXPECT(
                    voteAndCheck(history, history.unlNodeIDs.back(), 1, [&](NegativeUNLVote& vote) {
                        history.unlKeySet.erase(history.unlKeys[0]);
                        history.unlKeySet.erase(history.unlKeys[1]);
                    }));
            }
        }
    }
 
    void
    run() override
    {
        testDoVoting();
    }
};
 
class NegativeUNLVoteNewValidator_test : public beast::unit_test::Suite
{
    void
    testDoVoting()
    {
        testcase("Do Voting");
 
        {
            //== 2 new validators have bad scores
            //-- txSet.size = 0
            NetworkHistory history = {
                *this,
                {.numNodes = 15,
                 .negUNLSize = 0,
                 .hasToDisable = false,
                 .hasToReEnable = false,
                 .numLedgers = {}}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        return true;
                    });
                BEAST_EXPECT(
                    voteAndCheck(history, history.unlNodeIDs[0], 0, [&](NegativeUNLVote& vote) {
                        auto extraKey1 = randomKeyPair(KeyType::Ed25519).first;
                        auto extraKey2 = randomKeyPair(KeyType::Ed25519).first;
                        history.unlKeySet.insert(extraKey1);
                        history.unlKeySet.insert(extraKey2);
                        hash_set<NodeID> nowTrusted;
                        nowTrusted.insert(calcNodeID(extraKey1));
                        nowTrusted.insert(calcNodeID(extraKey2));
                        vote.newValidators(history.lastLedger()->seq(), nowTrusted);
                    }));
            }
        }
 
        {
            //== 2 expired new validators have bad scores
            //-- txSet.size = 1
            NetworkHistory history = {
                *this,
                {.numNodes = 21,
                 .negUNLSize = 0,
                 .hasToDisable = false,
                 .hasToReEnable = false,
                 .numLedgers = NegativeUNLVote::kNewValidatorDisableSkip * 2}};
            BEAST_EXPECT(history.goodHistory);
            if (history.goodHistory)
            {
                history.walkHistoryAndAddValidations(
                    [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                        return true;
                    });
                BEAST_EXPECT(
                    voteAndCheck(history, history.unlNodeIDs[0], 1, [&](NegativeUNLVote& vote) {
                        auto extraKey1 = randomKeyPair(KeyType::Ed25519).first;
                        auto extraKey2 = randomKeyPair(KeyType::Ed25519).first;
                        history.unlKeySet.insert(extraKey1);
                        history.unlKeySet.insert(extraKey2);
                        hash_set<NodeID> nowTrusted;
                        nowTrusted.insert(calcNodeID(extraKey1));
                        nowTrusted.insert(calcNodeID(extraKey2));
                        vote.newValidators(256, nowTrusted);
                    }));
            }
        }
    }
 
    void
    run() override
    {
        testDoVoting();
    }
};
 
class NegativeUNLVoteFilterValidations_test : public beast::unit_test::Suite
{
    void
    testFilterValidations()
    {
        testcase("Filter Validations");
        jtx::Env env(*this);
        auto l = std::make_shared<Ledger>(
            kCreateGenesis,
            Rules{env.app().config().features},
            env.app().config().fees.toFees(),
            std::vector<uint256>{},
            env.app().getNodeFamily());
 
        auto createSTVal = [&](std::pair<PublicKey, SecretKey> const& keys) {
            return std::make_shared<STValidation>(
                env.app().getTimeKeeper().now(),
                keys.first,
                keys.second,
                calcNodeID(keys.first),
                [&](STValidation& v) {
                    v.setFieldH256(sfLedgerHash, l->header().hash);
                    v.setFieldU32(sfLedgerSequence, l->seq());
                    v.setFlag(kVfFullValidation);
                });
        };
 
        // create keys and validations
        std::uint32_t const numNodes = 10;
        std::uint32_t const negUnlSize = 3;
        std::vector<std::string> cfgKeys;
        hash_set<NodeID> activeValidators;
        hash_set<PublicKey> nUnlKeys;
        std::vector<std::shared_ptr<STValidation>> vals;
        for (int i = 0; i < numNodes; ++i)
        {
            auto keyPair = randomKeyPair(KeyType::Secp256k1);
            vals.emplace_back(createSTVal(keyPair));
            cfgKeys.push_back(toBase58(TokenType::NodePublic, keyPair.first));
            activeValidators.emplace(calcNodeID(keyPair.first));
            if (i < negUnlSize)
            {
                nUnlKeys.insert(keyPair.first);
            }
        }
 
        // setup the ValidatorList
        auto& validators = env.app().getValidators();
        auto& local = *nUnlKeys.begin();
        std::vector<std::string> const cfgPublishers;
        validators.load(local, cfgKeys, cfgPublishers);
        validators.updateTrusted(
            activeValidators,
            env.timeKeeper().now(),
            env.app().getOPs(),
            env.app().getOverlay(),
            env.app().getHashRouter());
        BEAST_EXPECT(validators.getTrustedMasterKeys().size() == numNodes);
        validators.setNegativeUNL(nUnlKeys);
        BEAST_EXPECT(validators.getNegativeUNL().size() == negUnlSize);
 
        // test the filter
        BEAST_EXPECT(vals.size() == numNodes);
        vals = validators.negativeUNLFilter(std::move(vals));
        BEAST_EXPECT(vals.size() == numNodes - negUnlSize);
    }
 
    void
    run() override
    {
        testFilterValidations();
    }
};
 
BEAST_DEFINE_TESTSUITE(NegativeUNL, consensus, xrpl);
 
BEAST_DEFINE_TESTSUITE(NegativeUNLVoteInternal, consensus, xrpl);
BEAST_DEFINE_TESTSUITE_MANUAL(NegativeUNLVoteScoreTable, consensus, xrpl);
BEAST_DEFINE_TESTSUITE_PRIO(NegativeUNLVoteGoodScore, consensus, xrpl, 1);
BEAST_DEFINE_TESTSUITE(NegativeUNLVoteOffline, consensus, xrpl);
BEAST_DEFINE_TESTSUITE(NegativeUNLVoteMaxListed, consensus, xrpl);
BEAST_DEFINE_TESTSUITE_PRIO(NegativeUNLVoteRetiredValidator, consensus, xrpl, 1);
BEAST_DEFINE_TESTSUITE(NegativeUNLVoteNewValidator, consensus, xrpl);
BEAST_DEFINE_TESTSUITE(NegativeUNLVoteFilterValidations, consensus, xrpl);

bool
negUnlSizeTest(
    std::shared_ptr<Ledger const> const& l,
    size_t size,
    bool hasToDisable,
    bool hasToReEnable)
{
    bool const sameSize = l->negativeUNL().size() == size;
    bool const sameToDisable = (l->validatorToDisable() != std::nullopt) == hasToDisable;
    bool const sameToReEnable = (l->validatorToReEnable() != std::nullopt) == hasToReEnable;
 
    return sameSize && sameToDisable && sameToReEnable;
}
 
bool
applyAndTestResult(jtx::Env& env, OpenView& view, STTx const& tx, bool pass)
{
    auto const res = apply(env.app(), view, tx, ApplyFlags::TapNone, env.journal);
    if (pass)
    {
        return isTesSuccess(res.ter);
    }
 
    return res.ter == tefFAILURE || res.ter == temDISABLED;
}
 
bool
verifyPubKeyAndSeq(
    std::shared_ptr<Ledger const> const& l,
    hash_map<PublicKey, std::uint32_t> nUnlLedgerSeq)
{
    auto sle = l->read(keylet::negativeUNL());
    if (!sle)
        return false;
    if (!sle->isFieldPresent(sfDisabledValidators))
        return false;
 
    auto const& nUnlData = sle->getFieldArray(sfDisabledValidators);
    if (nUnlData.size() != nUnlLedgerSeq.size())
        return false;
 
    for (auto const& n : nUnlData)
    {
        if (!n.isFieldPresent(sfFirstLedgerSequence) || !n.isFieldPresent(sfPublicKey))
            return false;
 
        auto seq = n.getFieldU32(sfFirstLedgerSequence);
        auto d = n.getFieldVL(sfPublicKey);
        auto s = makeSlice(d);
        if (!publicKeyType(s))
            return false;
        PublicKey const pk(s);
        auto it = nUnlLedgerSeq.find(pk);
        if (it == nUnlLedgerSeq.end())
            return false;
        if (it->second != seq)
            return false;
        nUnlLedgerSeq.erase(it);
    }
    return nUnlLedgerSeq.empty();
}
 
std::size_t
countTx(std::shared_ptr<SHAMap> const& txSet)
{
    std::size_t count = 0;
    for (auto i = txSet->begin(); i != txSet->end(); ++i)
    {
        ++count;
    }
    return count;
};
 
std::vector<PublicKey>
createPublicKeys(std::size_t n)
{
    std::vector<PublicKey> keys;
    std::size_t const ss = 33;
    std::vector<uint8_t> data(ss, 0);
    data[0] = 0xED;
    for (int i = 0; i < n; ++i)
    {
        data[1]++;
        Slice const s(data.data(), ss);
        keys.emplace_back(s);
    }
    return keys;
}
 
STTx
createTx(bool disabling, LedgerIndex seq, PublicKey const& txKey)
{
    auto fill = [&](auto& obj) {
        obj.setFieldU8(sfUNLModifyDisabling, disabling ? 1 : 0);
        obj.setFieldU32(sfLedgerSequence, seq);
        obj.setFieldVL(sfUNLModifyValidator, txKey);
    };
    return STTx(ttUNL_MODIFY, fill);
}
 
}  // namespace xrpl::test