aged_associative_container_test.cpp

#include <xrpl/beast/clock/manual_clock.h>
#include <xrpl/beast/container/aged_map.h>                 // IWYU pragma: keep
#include <xrpl/beast/container/aged_multimap.h>            // IWYU pragma: keep
#include <xrpl/beast/container/aged_multiset.h>            // IWYU pragma: keep
#include <xrpl/beast/container/aged_set.h>                 // IWYU pragma: keep
#include <xrpl/beast/container/aged_unordered_map.h>       // IWYU pragma: keep
#include <xrpl/beast/container/aged_unordered_multimap.h>  // IWYU pragma: keep
#include <xrpl/beast/container/aged_unordered_multiset.h>  // IWYU pragma: keep
#include <xrpl/beast/container/aged_unordered_set.h>       // IWYU pragma: keep
#include <xrpl/beast/container/detail/aged_ordered_container.h>
#include <xrpl/beast/container/detail/aged_unordered_container.h>
#include <xrpl/beast/unit_test/suite.h>
 
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>  // IWYU pragma: keep
#include <utility>
#include <vector>  // IWYU pragma: keep
 
#ifndef BEAST_AGED_UNORDERED_NO_ALLOC_DEFAULTCTOR
#ifdef _MSC_VER
#define BEAST_AGED_UNORDERED_NO_ALLOC_DEFAULTCTOR 0
#else
#define BEAST_AGED_UNORDERED_NO_ALLOC_DEFAULTCTOR 1
#endif
#endif
 
#ifndef BEAST_CONTAINER_EXTRACT_NOREF
#ifdef _MSC_VER
#define BEAST_CONTAINER_EXTRACT_NOREF 1
#else
#define BEAST_CONTAINER_EXTRACT_NOREF 1
#endif
#endif
 
namespace beast {
 
class AgedAssociativeContainerTestBase : public unit_test::Suite
{
public:
    template <class T>
    struct CompT
    {
        CompT() = delete;
 
        explicit CompT(int)
        {
        }
 
        CompT(CompT const&)
        {
        }
 
        bool
        operator()(T const& lhs, T const& rhs) const
        {
            return less_(lhs, rhs);
        }
 
    private:
        std::less<T> less_;
    };
 
    template <class T>
    class HashT
    {
    public:
        HashT() = delete;
 
        explicit HashT(int)
        {
        }
 
        std::size_t
        operator()(T const& t) const
        {
            return hash_(t);
        }
 
    private:
        std::hash<T> hash_;
    };
 
    template <class T>
    struct EqualT
    {
    public:
        EqualT() = delete;
 
        explicit EqualT(int)
        {
        }
 
        bool
        operator()(T const& lhs, T const& rhs) const
        {
            return eq_(lhs, rhs);
        }
 
    private:
        std::equal_to<T> eq_;
    };
 
    template <class T>
    struct AllocT
    {
        using value_type = T;
 
        // using std::true_type::type = propagate_on_container_swap :;
 
        template <class U>
        struct Rebind
        {
            using other = AllocT<U>;
        };
 
        explicit AllocT(int)
        {
        }
 
        AllocT(AllocT const&) = default;
 
        template <class U>
        AllocT(AllocT<U> const&)
        {
        }
 
        template <class U>
        bool
        operator==(AllocT<U> const&) const
        {
            return true;
        }
 
        template <class U>
        bool
        operator!=(AllocT<U> const& o) const
        {
            return !(*this == o);
        }
 
        T*
        allocate(std::size_t n, T const* = nullptr)
        {
            return static_cast<T*>(::operator new(n * sizeof(T)));
        }
 
        void
        deallocate(T* p, std::size_t)
        {
            ::operator delete(p);
        }
 
#if !BEAST_AGED_UNORDERED_NO_ALLOC_DEFAULTCTOR
        AllocT()
        {
        }
#else
        AllocT() = delete;
#endif
    };
 
    //--------------------------------------------------------------------------
 
    // ordered
    template <class Base, bool IsUnordered>
    class MaybeUnordered : public Base
    {
    public:
        using Comp = std::less<typename Base::Key>;
        using MyComp = CompT<typename Base::Key>;
 
    protected:
        static std::string
        nameOrderedPart()
        {
            return "";
        }
    };
 
    // unordered
    template <class Base>
    class MaybeUnordered<Base, true> : public Base
    {
    public:
        using Hash = std::hash<typename Base::Key>;
        using Equal = std::equal_to<typename Base::Key>;
        using MyHash = HashT<typename Base::Key>;
        using MyEqual = EqualT<typename Base::Key>;
 
    protected:
        static std::string
        nameOrderedPart()
        {
            return "unordered_";
        }
    };
 
    // unique
    template <class Base, bool IsMulti>
    class MaybeMulti : public Base
    {
    public:
    protected:
        static std::string
        nameMultiPart()
        {
            return "";
        }
    };
 
    // multi
    template <class Base>
    class MaybeMulti<Base, true> : public Base
    {
    public:
    protected:
        static std::string
        nameMultiPart()
        {
            return "multi";
        }
    };
 
    // set
    template <class Base, bool IsMap>
    class MaybeMap : public Base
    {
    public:
        using T = void;
        using Value = Base::Key;
        using Values = std::vector<Value>;
 
        static Base::Key const&
        extract(Value const& value)
        {
            return value;  // NOLINT(bugprone-return-const-ref-from-parameter)
        }
 
        static Values
        values()
        {
            Values v{
                "apple",
                "banana",
                "cherry",
                "grape",
                "orange",
            };
            return v;
        }
 
    protected:
        static std::string
        nameMapPart()
        {
            return "set";
        }
    };
 
    // map
    template <class Base>
    class MaybeMap<Base, true> : public Base
    {
    public:
        using T = int;
        using Value = std::pair<typename Base::Key, T>;
        using Values = std::vector<Value>;
 
        static Base::Key const&
        extract(Value const& value)
        {
            return value.first;
        }
 
        static Values
        values()
        {
            Values v{
                std::make_pair("apple", 1),
                std::make_pair("banana", 2),
                std::make_pair("cherry", 3),
                std::make_pair("grape", 4),
                std::make_pair("orange", 5)};
            return v;
        }
 
    protected:
        static std::string
        nameMapPart()
        {
            return "map";
        }
    };
 
    //--------------------------------------------------------------------------
 
    // ordered
    template <class Base, bool IsUnordered = Base::is_unordered::value>
    struct ContType
    {
        template <
            class Compare = std::less<typename Base::Key>,
            class Allocator = std::allocator<typename Base::Value>>
        using Cont = detail::AgedOrderedContainer<
            Base::is_multi::value,
            Base::is_map::value,
            typename Base::Key,
            typename Base::T,
            typename Base::Clock,
            Compare,
            Allocator>;
    };
 
    // unordered
    template <class Base>
    struct ContType<Base, true>
    {
        template <
            class Hash = std::hash<typename Base::Key>,
            class KeyEqual = std::equal_to<typename Base::Key>,
            class Allocator = std::allocator<typename Base::Value>>
        using Cont = detail::AgedUnorderedContainer<
            Base::is_multi::value,
            Base::is_map::value,
            typename Base::Key,
            typename Base::T,
            typename Base::Clock,
            Hash,
            KeyEqual,
            Allocator>;
    };
 
    //--------------------------------------------------------------------------
 
    struct TestTraitsBase
    {
        using Key = std::string;
        using Clock = std::chrono::steady_clock;
        using ManualClock = beast::ManualClock<Clock>;
    };
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    struct TestTraitsHelper
        : MaybeUnordered<MaybeMulti<MaybeMap<TestTraitsBase, IsMap>, IsMulti>, IsUnordered>
    {
    private:
        using Base =
            MaybeUnordered<MaybeMulti<MaybeMap<TestTraitsBase, IsMap>, IsMulti>, IsUnordered>;
 
    public:
        using typename Base::Key;
 
        using is_unordered = std::integral_constant<bool, IsUnordered>;
        using is_multi = std::integral_constant<bool, IsMulti>;
        using is_map = std::integral_constant<bool, IsMap>;
 
        using Alloc = std::allocator<typename Base::Value>;
        using MyAlloc = AllocT<typename Base::Value>;
 
        static std::string
        name()
        {
            return std::string("aged_") + Base::name_ordered_part() + Base::name_multi_part() +
                Base::name_map_part();
        }
    };
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    struct TestTraits : TestTraitsHelper<IsUnordered, IsMulti, IsMap>,
                        ContType<TestTraitsHelper<IsUnordered, IsMulti, IsMap>>
    {
    };
 
    template <class Cont>
    static std::string
    name(Cont const&)
    {
        return TestTraits<Cont::is_unordered, Cont::is_multi, Cont::is_map>::name();
    }
 
    template <class Traits>
    struct EqualValue
    {
        bool
        operator()(Traits::Value const& lhs, Traits::Value const& rhs)
        {
            return Traits::extract(lhs) == Traits::extract(rhs);
        }
    };
 
    template <class Cont>
    static std::vector<typename Cont::value_type>
    makeList(Cont const& c)
    {
        return std::vector<typename Cont::value_type>(c.begin(), c.end());
    }
 
    //--------------------------------------------------------------------------
 
    template <class Container, class Values>
    void
    checkMapContents(Container& c, Values const& v)
        requires(Container::is_map::value && !Container::is_multi::value);
 
    template <class Container, class Values>
    void
    checkMapContents(Container, Values const&)
        requires(!(Container::is_map::value && !Container::is_multi::value))
    {
    }
 
    // unordered
    template <class C, class Values>
    void
    checkUnorderedContentsRefRef(C&& c, Values const& v)
        requires(std::remove_reference_t<C>::is_unordered::value);
 
    template <class C, class Values>
    void
    checkUnorderedContentsRefRef(C&&, Values const&)
        requires(!std::remove_reference_t<C>::is_unordered::value)
    {
    }
 
    template <class C, class Values>
    void
    checkContentsRefRef(C&& c, Values const& v);
 
    template <class Cont, class Values>
    void
    checkContents(Cont& c, Values const& v);
 
    template <class Cont>
    void
    checkContents(Cont& c);
 
    //--------------------------------------------------------------------------
 
    // ordered
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testConstructEmpty()
        requires(!IsUnordered);
 
    // unordered
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testConstructEmpty()
        requires IsUnordered;
 
    // ordered
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testConstructRange()
        requires(!IsUnordered);
 
    // unordered
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testConstructRange()
        requires IsUnordered;
 
    // ordered
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testConstructInitList()
        requires(!IsUnordered);
 
    // unordered
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testConstructInitList()
        requires IsUnordered;
 
    //--------------------------------------------------------------------------
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testCopyMove();
 
    //--------------------------------------------------------------------------
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testIterator();
 
    // Unordered containers don't have reverse iterators
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testReverseIterator()
        requires(!IsUnordered);
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testReverseIterator()
        requires IsUnordered
    {
    }
 
    //--------------------------------------------------------------------------
 
    template <class Container, class Values>
    void
    checkInsertCopy(Container& c, Values const& v);
 
    template <class Container, class Values>
    void
    checkInsertMove(Container& c, Values const& v);
 
    template <class Container, class Values>
    void
    checkInsertHintCopy(Container& c, Values const& v);
 
    template <class Container, class Values>
    void
    checkInsertHintMove(Container& c, Values const& v);
 
    template <class Container, class Values>
    void
    checkEmplace(Container& c, Values const& v);
 
    template <class Container, class Values>
    void
    checkEmplaceHint(Container& c, Values const& v);
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testModifiers();
 
    //--------------------------------------------------------------------------
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testChronological();
 
    //--------------------------------------------------------------------------
 
    // map, unordered_map
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testArrayCreate()
        requires(IsMap && !IsMulti);
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testArrayCreate()
        requires(!IsMap || IsMulti)
    {
    }
 
    //--------------------------------------------------------------------------
 
    // Helpers for erase tests
    template <class Container, class Values>
    void
    reverseFillAgedContainer(Container& c, Values const& v);
 
    template <class Iter>
    Iter
    nextToEndIter(Iter const beginIter, Iter const endItr);
 
    //--------------------------------------------------------------------------
 
    template <class Container, class Iter>
    bool
    doElementErase(Container& c, Iter const beginItr, Iter const endItr);
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testElementErase();
 
    //--------------------------------------------------------------------------
 
    template <class Container, class BeginEndSrc>
    void
    doRangeErase(Container& c, BeginEndSrc const& beginEndSrc);
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testRangeErase();
 
    //--------------------------------------------------------------------------
 
    // ordered
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testCompare()
        requires(!IsUnordered);
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testCompare()
        requires IsUnordered
    {
    }
 
    //--------------------------------------------------------------------------
 
    // ordered
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testObservers()
        requires(!IsUnordered);
 
    // unordered
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testObservers()
        requires IsUnordered;
 
    //--------------------------------------------------------------------------
 
    template <bool IsUnordered, bool IsMulti, bool IsMap>
    void
    testMaybeUnorderedMultiMap();
 
    template <bool IsUnordered, bool IsMulti>
    void
    testMaybeUnorderedMulti();
 
    template <bool IsUnordered>
    void
    testMaybeUnordered();
};
 
//------------------------------------------------------------------------------
 
// Check contents via at() and operator[]
// map, unordered_map
template <class Container, class Values>
void
AgedAssociativeContainerTestBase::checkMapContents(Container& c, Values const& v)
    requires(Container::is_map::value && !Container::is_multi::value)
{
    if (v.empty())
    {
        BEAST_EXPECT(c.empty());
        BEAST_EXPECT(c.size() == 0);
        return;
    }
 
    try
    {
        // Make sure no exception is thrown
        for (auto const& e : v)
            c.at(e.first);
        for (auto const& e : v)
            BEAST_EXPECT(c.operator[](e.first) == e.second);
    }
    catch (std::out_of_range const&)
    {
        fail("caught exception");
    }
}
 
// unordered
template <class C, class Values>
void
AgedAssociativeContainerTestBase::checkUnorderedContentsRefRef(C&& c, Values const& v)
    requires(std::remove_reference_t<C>::is_unordered::value)
{
    using Cont = std::remove_reference_t<C>;
    using Traits =
        TestTraits<Cont::is_unordered::value, Cont::is_multi::value, Cont::is_map::value>;
    using size_type = Cont::size_type;
    auto const hash(c.hashFunction());
    auto const keyEq(c.keyEq());
    for (size_type i(0); i < c.bucketCount(); ++i)
    {
        auto const last(c.end(i));
        for (auto iter(c.begin(i)); iter != last; ++iter)
        {
            auto const match(std::ranges::find_if(v, [iter](Values::value_type const& e) {
                return Traits::extract(*iter) == Traits::extract(e);
            }));
            BEAST_EXPECT(match != v.end());
            BEAST_EXPECT(keyEq(Traits::extract(*iter), Traits::extract(*match)));
            BEAST_EXPECT(hash(Traits::extract(*iter)) == hash(Traits::extract(*match)));
        }
    }
}
 
template <class C, class Values>
void
AgedAssociativeContainerTestBase::checkContentsRefRef(C&& c, Values const& v)
{
    using Cont = std::remove_reference_t<C>;
    using size_type = Cont::size_type;
 
    BEAST_EXPECT(c.size() == v.size());
    BEAST_EXPECT(size_type(std::distance(c.begin(), c.end())) == v.size());
    BEAST_EXPECT(size_type(std::distance(c.cbegin(), c.cend())) == v.size());
    BEAST_EXPECT(
        size_type(std::distance(c.chronological.begin(), c.chronological.end())) == v.size());
    BEAST_EXPECT(
        size_type(std::distance(c.chronological.cbegin(), c.chronological.cend())) == v.size());
    BEAST_EXPECT(
        size_type(std::distance(c.chronological.rbegin(), c.chronological.rend())) == v.size());
    BEAST_EXPECT(
        size_type(std::distance(c.chronological.crbegin(), c.chronological.crend())) == v.size());
 
    checkUnorderedContentsRefRef(c, v);
}
 
template <class Cont, class Values>
void
AgedAssociativeContainerTestBase::checkContents(Cont& c, Values const& v)
{
    checkContentsRefRef(c, v);
    checkContentsRefRef(const_cast<Cont const&>(c), v);
    checkMapContents(c, v);
}
 
template <class Cont>
void
AgedAssociativeContainerTestBase::checkContents(Cont& c)
{
    using Traits =
        TestTraits<Cont::is_unordered::value, Cont::is_multi::value, Cont::is_map::value>;
    using Values = Traits::Values;
    checkContents(c, Values());
}
 
//------------------------------------------------------------------------------
//
// Construction
//
//------------------------------------------------------------------------------
 
// ordered
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testConstructEmpty()
    requires(!IsUnordered)
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    using Comp = Traits::Comp;
    using Alloc = Traits::Alloc;
    using MyComp = Traits::MyComp;
    using MyAlloc = Traits::MyAlloc;
    typename Traits::ManualClock clock;
 
    // testcase (Traits::name() + " empty");
    testcase("empty");
 
    {
        typename Traits::template Cont<Comp, Alloc> c(clock);
        checkContents(c);
    }
 
    {
        typename Traits::template Cont<MyComp, Alloc> c(clock, MyComp(1));
        checkContents(c);
    }
 
    {
        typename Traits::template Cont<Comp, MyAlloc> c(clock, MyAlloc(1));
        checkContents(c);
    }
 
    {
        typename Traits::template Cont<MyComp, MyAlloc> c(clock, MyComp(1), MyAlloc(1));
        checkContents(c);
    }
}
 
// unordered
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testConstructEmpty()
    requires IsUnordered
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    using Hash = Traits::Hash;
    using Equal = Traits::Equal;
    using Alloc = Traits::Alloc;
    using MyHash = Traits::MyHash;
    using MyEqual = Traits::MyEqual;
    using MyAlloc = Traits::MyAlloc;
    typename Traits::ManualClock clock;
 
    // testcase (Traits::name() + " empty");
    testcase("empty");
    {
        typename Traits::template Cont<Hash, Equal, Alloc> c(clock);
        checkContents(c);
    }
 
    {
        typename Traits::template Cont<MyHash, Equal, Alloc> c(clock, MyHash(1));
        checkContents(c);
    }
 
    {
        typename Traits::template Cont<Hash, MyEqual, Alloc> c(clock, MyEqual(1));
        checkContents(c);
    }
 
    {
        typename Traits::template Cont<Hash, Equal, MyAlloc> c(clock, MyAlloc(1));
        checkContents(c);
    }
 
    {
        typename Traits::template Cont<MyHash, MyEqual, Alloc> c(clock, MyHash(1), MyEqual(1));
        checkContents(c);
    }
 
    {
        typename Traits::template Cont<MyHash, Equal, MyAlloc> c(clock, MyHash(1), MyAlloc(1));
        checkContents(c);
    }
 
    {
        typename Traits::template Cont<Hash, MyEqual, MyAlloc> c(clock, MyEqual(1), MyAlloc(1));
        checkContents(c);
    }
 
    {
        typename Traits::template Cont<MyHash, MyEqual, MyAlloc> c(
            clock, MyHash(1), MyEqual(1), MyAlloc(1));
        checkContents(c);
    }
}
 
// ordered
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testConstructRange()
    requires(!IsUnordered)
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    using Comp = Traits::Comp;
    using Alloc = Traits::Alloc;
    using MyComp = Traits::MyComp;
    using MyAlloc = Traits::MyAlloc;
    typename Traits::ManualClock clock;
    auto const v(Traits::values());
 
    // testcase (Traits::name() + " range");
    testcase("range");
 
    {
        typename Traits::template Cont<Comp, Alloc> c(v.begin(), v.end(), clock);
        checkContents(c, v);
    }
 
    {
        typename Traits::template Cont<MyComp, Alloc> c(v.begin(), v.end(), clock, MyComp(1));
        checkContents(c, v);
    }
 
    {
        typename Traits::template Cont<Comp, MyAlloc> c(v.begin(), v.end(), clock, MyAlloc(1));
        checkContents(c, v);
    }
 
    {
        typename Traits::template Cont<MyComp, MyAlloc> c(
            v.begin(), v.end(), clock, MyComp(1), MyAlloc(1));
        checkContents(c, v);
    }
 
    // swap
 
    {
        typename Traits::template Cont<Comp, Alloc> c1(v.begin(), v.end(), clock);
        typename Traits::template Cont<Comp, Alloc> c2(clock);
        std::swap(c1, c2);
        checkContents(c2, v);
    }
}
 
// unordered
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testConstructRange()
    requires IsUnordered
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    using Hash = Traits::Hash;
    using Equal = Traits::Equal;
    using Alloc = Traits::Alloc;
    using MyHash = Traits::MyHash;
    using MyEqual = Traits::MyEqual;
    using MyAlloc = Traits::MyAlloc;
    typename Traits::ManualClock clock;
    auto const v(Traits::values());
 
    // testcase (Traits::name() + " range");
    testcase("range");
 
    {
        typename Traits::template Cont<Hash, Equal, Alloc> c(v.begin(), v.end(), clock);
        checkContents(c, v);
    }
 
    {
        typename Traits::template Cont<MyHash, Equal, Alloc> c(
            v.begin(), v.end(), clock, MyHash(1));
        checkContents(c, v);
    }
 
    {
        typename Traits::template Cont<Hash, MyEqual, Alloc> c(
            v.begin(), v.end(), clock, MyEqual(1));
        checkContents(c, v);
    }
 
    {
        typename Traits::template Cont<Hash, Equal, MyAlloc> c(
            v.begin(), v.end(), clock, MyAlloc(1));
        checkContents(c, v);
    }
 
    {
        typename Traits::template Cont<MyHash, MyEqual, Alloc> c(
            v.begin(), v.end(), clock, MyHash(1), MyEqual(1));
        checkContents(c, v);
    }
 
    {
        typename Traits::template Cont<MyHash, Equal, MyAlloc> c(
            v.begin(), v.end(), clock, MyHash(1), MyAlloc(1));
        checkContents(c, v);
    }
 
    {
        typename Traits::template Cont<Hash, MyEqual, MyAlloc> c(
            v.begin(), v.end(), clock, MyEqual(1), MyAlloc(1));
        checkContents(c, v);
    }
 
    {
        typename Traits::template Cont<MyHash, MyEqual, MyAlloc> c(
            v.begin(), v.end(), clock, MyHash(1), MyEqual(1), MyAlloc(1));
        checkContents(c, v);
    }
}
 
// ordered
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testConstructInitList()
    requires(!IsUnordered)
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    typename Traits::ManualClock const clock;
 
    // testcase (Traits::name() + " init-list");
    testcase("init-list");
 
    // VFALCO TODO
 
    pass();
}
 
// unordered
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testConstructInitList()
    requires IsUnordered
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    typename Traits::ManualClock const clock;
 
    // testcase (Traits::name() + " init-list");
    testcase("init-list");
 
    // VFALCO TODO
    pass();
}
 
//------------------------------------------------------------------------------
//
// Copy/Move construction and assign
//
//------------------------------------------------------------------------------
 
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testCopyMove()
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    using Alloc = Traits::Alloc;
    typename Traits::ManualClock clock;
    auto const v(Traits::values());
 
    // testcase (Traits::name() + " copy/move");
    testcase("copy/move");
 
    // copy
 
    {
        typename Traits::template Cont<> c(v.begin(), v.end(), clock);
        typename Traits::template Cont<> c2(c);
        checkContents(c, v);
        checkContents(c2, v);
        BEAST_EXPECT(c == c2);
        unexpected(c != c2);
    }
 
    {
        typename Traits::template Cont<> c(v.begin(), v.end(), clock);
        typename Traits::template Cont<> c2(c, Alloc());
        checkContents(c, v);
        checkContents(c2, v);
        BEAST_EXPECT(c == c2);
        unexpected(c != c2);
    }
 
    {
        typename Traits::template Cont<> c(v.begin(), v.end(), clock);
        typename Traits::template Cont<> c2(clock);
        c2 = c;
        checkContents(c, v);
        checkContents(c2, v);
        BEAST_EXPECT(c == c2);
        unexpected(c != c2);
    }
 
    // move
 
    {
        typename Traits::template Cont<> c(v.begin(), v.end(), clock);
        typename Traits::template Cont<> c2(std::move(c));
        checkContents(c2, v);
    }
 
    {
        typename Traits::template Cont<> c(v.begin(), v.end(), clock);
        typename Traits::template Cont<> c2(std::move(c), Alloc());
        checkContents(c2, v);
    }
 
    {
        typename Traits::template Cont<> c(v.begin(), v.end(), clock);
        typename Traits::template Cont<> c2(clock);
        c2 = std::move(c);
        checkContents(c2, v);
    }
}
 
//------------------------------------------------------------------------------
//
// Iterator construction and assignment
//
//------------------------------------------------------------------------------
 
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testIterator()
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    typename Traits::ManualClock clock;
    auto const v(Traits::values());
 
    // testcase (Traits::name() + " iterators");
    testcase("iterator");
 
    typename Traits::template Cont<> c{clock};
 
    using iterator = decltype(c.begin());
    using const_iterator = decltype(c.cbegin());
 
    // Should be able to construct or assign an iterator from an iterator.
    iterator const nnIt0{c.begin()};
    iterator const nnIt1{nnIt0};
    BEAST_EXPECT(nnIt0 == nnIt1);
    iterator nnIt2;
    nnIt2 = nnIt1;
    BEAST_EXPECT(nnIt1 == nnIt2);
 
    // Should be able to construct or assign a const_iterator from a
    // const_iterator.
    const_iterator const ccIt0{c.cbegin()};
    const_iterator const ccIt1{ccIt0};
    BEAST_EXPECT(ccIt0 == ccIt1);
    const_iterator ccIt2;
    ccIt2 = ccIt1;
    BEAST_EXPECT(ccIt1 == ccIt2);
 
    // Comparison between iterator and const_iterator is okay
    BEAST_EXPECT(nnIt0 == ccIt0);
    BEAST_EXPECT(ccIt1 == nnIt1);
 
    // Should be able to construct a const_iterator from an iterator.
    const_iterator const ncIt3{c.begin()};
    const_iterator const ncIt4{nnIt0};
    BEAST_EXPECT(ncIt3 == ncIt4);
    const_iterator ncIt5;
    ncIt5 = nnIt2;
    BEAST_EXPECT(ncIt5 == ncIt4);
 
    // None of these should compile because they construct or assign to a
    // non-const iterator with a const_iterator.
 
    //  iterator cnIt_0 {c.cbegin()};
 
    //  iterator cnIt_1 {ccIt_0};
 
    //  iterator cnIt_2;
    //  cnIt_2 = ccIt_2;
}
 
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testReverseIterator()
    requires(!IsUnordered)
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    typename Traits::ManualClock clock;
    auto const v(Traits::values());
 
    // testcase (Traits::name() + " reverse_iterators");
    testcase("reverse_iterator");
 
    typename Traits::template Cont<> c{clock};
 
    using iterator = decltype(c.begin());
    using reverse_iterator = decltype(c.rbegin());
    using const_reverse_iterator = decltype(c.crbegin());
 
    // Naming decoder ring
    //       constructed from ------+ +----- constructed type
    //                              /\/\  -- character pairs
    //                              xAyBit
    //  r (reverse) or f (forward)--^-^
    //                               ^-^------ C (const) or N (non-const)
 
    // Should be able to construct or assign a reverse_iterator from a
    // reverse_iterator.
    reverse_iterator const rNrNit0{c.rbegin()};
    reverse_iterator const rNrNit1{rNrNit0};
    BEAST_EXPECT(rNrNit0 == rNrNit1);
    reverse_iterator xXrNit2;
    xXrNit2 = rNrNit1;
    BEAST_EXPECT(rNrNit1 == xXrNit2);
 
    // Should be able to construct or assign a const_reverse_iterator from a
    // const_reverse_iterator
    const_reverse_iterator const rCrCit0{c.crbegin()};
    const_reverse_iterator const rCrCit1{rCrCit0};
    BEAST_EXPECT(rCrCit0 == rCrCit1);
    const_reverse_iterator xXrCit2;
    xXrCit2 = rCrCit1;
    BEAST_EXPECT(rCrCit1 == xXrCit2);
 
    // Comparison between reverse_iterator and const_reverse_iterator is okay
    BEAST_EXPECT(rNrNit0 == rCrCit0);
    BEAST_EXPECT(rCrCit1 == rNrNit1);
 
    // Should be able to construct or assign a const_reverse_iterator from a
    // reverse_iterator
    const_reverse_iterator const rNrCit0{c.rbegin()};
    const_reverse_iterator const rNrCit1{rNrNit0};
    BEAST_EXPECT(rNrCit0 == rNrCit1);
    xXrCit2 = rNrNit1;
    BEAST_EXPECT(rNrCit1 == xXrCit2);
 
    // The standard allows these conversions:
    //  o reverse_iterator is explicitly constructible from iterator.
    //  o const_reverse_iterator is explicitly constructible from
    //  const_iterator.
    // Should be able to construct or assign reverse_iterators from
    // non-reverse iterators.
    reverse_iterator const fNrNit0{c.begin()};
    const_reverse_iterator const fNrCit0{c.begin()};
    BEAST_EXPECT(fNrNit0 == fNrCit0);
    const_reverse_iterator const fCrCit0{c.cbegin()};
    BEAST_EXPECT(fNrCit0 == fCrCit0);
 
    // None of these should compile because they construct a non-reverse
    // iterator from a reverse_iterator.
    //  iterator rNfNit_0 {c.rbegin()};
    //  const_iterator rNfCit_0 {c.rbegin()};
    //  const_iterator rCfCit_0 {c.crbegin()};
 
    // You should not be able to assign an iterator to a reverse_iterator or
    // vise-versa.  So the following lines should not compile.
    iterator const xXfNit0;
    //  xXfNit_0 = xXrNit_2;
    //  xXrNit_2 = xXfNit_0;
}
 
//------------------------------------------------------------------------------
//
// Modifiers
//
//------------------------------------------------------------------------------
 
template <class Container, class Values>
void
AgedAssociativeContainerTestBase::checkInsertCopy(Container& c, Values const& v)
{
    for (auto const& e : v)
        c.insert(e);
    checkContents(c, v);
}
 
template <class Container, class Values>
void
AgedAssociativeContainerTestBase::checkInsertMove(Container& c, Values const& v)
{
    Values v2(v);
    for (auto& e : v2)
        c.insert(std::move(e));
    checkContents(c, v);
}
 
template <class Container, class Values>
void
AgedAssociativeContainerTestBase::checkInsertHintCopy(Container& c, Values const& v)
{
    for (auto const& e : v)
        c.insert(c.cend(), e);
    checkContents(c, v);
}
 
template <class Container, class Values>
void
AgedAssociativeContainerTestBase::checkInsertHintMove(Container& c, Values const& v)
{
    Values v2(v);
    for (auto& e : v2)
        c.insert(c.cend(), std::move(e));
    checkContents(c, v);
}
 
template <class Container, class Values>
void
AgedAssociativeContainerTestBase::checkEmplace(Container& c, Values const& v)
{
    for (auto const& e : v)
        c.emplace(e);
    checkContents(c, v);
}
 
template <class Container, class Values>
void
AgedAssociativeContainerTestBase::checkEmplaceHint(Container& c, Values const& v)
{
    for (auto const& e : v)
        c.emplace_hint(c.cend(), e);
    checkContents(c, v);
}
 
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testModifiers()
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    typename Traits::ManualClock clock;
    auto const v(Traits::values());
    auto const l(makeList(v));
 
    // testcase (Traits::name() + " modify");
    testcase("modify");
 
    {
        typename Traits::template Cont<> c(clock);
        checkInsertCopy(c, v);
    }
 
    {
        typename Traits::template Cont<> c(clock);
        checkInsertCopy(c, l);
    }
 
    {
        typename Traits::template Cont<> c(clock);
        checkInsertMove(c, v);
    }
 
    {
        typename Traits::template Cont<> c(clock);
        checkInsertMove(c, l);
    }
 
    {
        typename Traits::template Cont<> c(clock);
        checkInsertHintCopy(c, v);
    }
 
    {
        typename Traits::template Cont<> c(clock);
        checkInsertHintCopy(c, l);
    }
 
    {
        typename Traits::template Cont<> c(clock);
        checkInsertHintMove(c, v);
    }
 
    {
        typename Traits::template Cont<> c(clock);
        checkInsertHintMove(c, l);
    }
}
 
//------------------------------------------------------------------------------
//
// Chronological ordering
//
//------------------------------------------------------------------------------
 
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testChronological()
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    typename Traits::ManualClock clock;
    auto const v(Traits::values());
 
    // testcase (Traits::name() + " chronological");
    testcase("chronological");
 
    typename Traits::template Cont<> c(v.begin(), v.end(), clock);
 
    BEAST_EXPECT(std::ranges::equal(c.chronological, v, EqualValue<Traits>()));
 
    // Test touch() with a non-const iterator.
    for (auto iter(v.crbegin()); iter != v.crend(); ++iter)
    {
        using iterator = decltype(c)::iterator;
        iterator const found(c.find(Traits::extract(*iter)));
 
        BEAST_EXPECT(found != c.cend());
        if (found == c.cend())
            return;
        c.touch(found);
    }
 
    BEAST_EXPECT(
        std::equal(
            c.chronological.cbegin(),
            c.chronological.cend(),
            v.crbegin(),
            v.crend(),
            EqualValue<Traits>()));
 
    // Test touch() with a const_iterator
    for (auto iter(v.cbegin()); iter != v.cend(); ++iter)
    {
        using const_iterator = decltype(c)::const_iterator;
        const_iterator const found(c.find(Traits::extract(*iter)));
 
        BEAST_EXPECT(found != c.cend());
        if (found == c.cend())
            return;
        c.touch(found);
    }
 
    BEAST_EXPECT(std::ranges::equal(c.chronological, v, EqualValue<Traits>()));
 
    {
        // Because touch (reverse_iterator pos) is not allowed, the following
        // lines should not compile for any aged_container type.
        //      c.touch (c.rbegin());
        //      c.touch (c.crbegin());
    }
}
 
//------------------------------------------------------------------------------
//
// Element creation via operator[]
//
//------------------------------------------------------------------------------
 
// map, unordered_map
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testArrayCreate()
    requires(IsMap && !IsMulti)
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    typename Traits::ManualClock clock;
    auto v(Traits::values());
 
    // testcase (Traits::name() + " array create");
    testcase("array create");
 
    {
        // Copy construct key
        typename Traits::template Cont<> c(clock);
        for (auto const& e : v)
            c[e.first] = e.second;
        checkContents(c, v);
    }
 
    {
        // Move construct key
        typename Traits::template Cont<> c(clock);
        for (auto e : v)
            c[std::move(e.first)] = e.second;
        checkContents(c, v);
    }
}
 
//------------------------------------------------------------------------------
//
// Helpers for erase tests
//
//------------------------------------------------------------------------------
 
template <class Container, class Values>
void
AgedAssociativeContainerTestBase::reverseFillAgedContainer(Container& c, Values const& values)
{
    // Just in case the passed in container was not empty.
    c.clear();
 
    // c.clock() returns an abstract_clock, so dynamic_cast to ManualClock.
    // VFALCO NOTE This is sketchy
    using ManualClock = TestTraitsBase::ManualClock;
    auto& clk = dynamic_cast<ManualClock&>(c.clock());
    clk.set(0);
 
    Values rev(values);
    std::ranges::sort(rev);
    std::ranges::reverse(rev);
    for (auto& v : rev)
    {
        // Add values in reverse order so they are reversed chronologically.
        ++clk;
        c.insert(v);
    }
}
 
// Get one iterator before endIter.  We have to use operator++ because you
// cannot use operator-- with unordered container iterators.
template <class Iter>
Iter
AgedAssociativeContainerTestBase::nextToEndIter(Iter beginIter, Iter const endIter)
{
    if (beginIter == endIter)
    {
        fail("Internal test failure. Cannot advance beginIter");
        return beginIter;
    }
 
    //
    Iter nextToEnd = beginIter;
    do
    {
        nextToEnd = beginIter++;
    } while (beginIter != endIter);
    return nextToEnd;
}
 
// Implementation for the element erase tests
//
// This test accepts:
//  o the container from which we will erase elements
//  o iterators into that container defining the range of the erase
//
// This implementation does not declare a pass, since it wants to allow
// the caller to examine the size of the container and the returned iterator
//
// Note that this test works on the aged_associative containers because an
// erase only invalidates references and iterators to the erased element
// (see 23.2.4/13).  Therefore the passed-in end iterator stays valid through
// the whole test.
template <class Container, class Iter>
bool
AgedAssociativeContainerTestBase::doElementErase(
    Container& c,
    Iter const beginItr,
    Iter const endItr)
{
    auto it(beginItr);
    size_t count = c.size();
    while (it != endItr)
    {
        auto expectIt = it;
        ++expectIt;
        it = c.erase(it);
 
        if (it != expectIt)
        {
            fail("Unexpected returned iterator from element erase");
            return false;
        }
 
        --count;
        if (count != c.size())
        {
            fail("Failed to erase element");
            return false;
        }
 
        if (c.empty())
        {
            if (it != endItr)
            {
                fail("Erase of last element didn't produce end");
                return false;
            }
        }
    }
    return true;
}
 
//------------------------------------------------------------------------------
//
// Erase of individual elements
//
//------------------------------------------------------------------------------
 
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testElementErase()
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
 
    // testcase (Traits::name() + " element erase"
    testcase("element erase");
 
    // Make and fill the container
    typename Traits::ManualClock clock;
    typename Traits::template Cont<> c{clock};
    reverseFillAgedContainer(c, Traits::values());
 
    {
        // Test standard iterators
        auto tempContainer(c);
        if (!doElementErase(tempContainer, tempContainer.cbegin(), tempContainer.cend()))
            return;  // Test failed
 
        BEAST_EXPECT(tempContainer.empty());
        pass();
    }
    {
        // Test chronological iterators
        auto tempContainer(c);
        auto& chron(tempContainer.chronological);
        if (!doElementErase(tempContainer, chron.begin(), chron.end()))
            return;  // Test failed
 
        BEAST_EXPECT(tempContainer.empty());
        pass();
    }
    {
        // Test standard iterator partial erase
        auto tempContainer(c);
        BEAST_EXPECT(tempContainer.size() > 2);
        if (!doElementErase(
                tempContainer,
                ++tempContainer.begin(),
                nextToEndIter(tempContainer.begin(), tempContainer.end())))
            return;  // Test failed
 
        BEAST_EXPECT(tempContainer.size() == 2);
        pass();
    }
    {
        // Test chronological iterator partial erase
        auto tempContainer(c);
        BEAST_EXPECT(tempContainer.size() > 2);
        auto& chron(tempContainer.chronological);
        if (!doElementErase(
                tempContainer, ++chron.begin(), nextToEndIter(chron.begin(), chron.end())))
            return;  // Test failed
 
        BEAST_EXPECT(tempContainer.size() == 2);
        pass();
    }
    {
        auto tempContainer(c);
        BEAST_EXPECT(tempContainer.size() > 4);
        // erase(reverse_iterator) is not allowed.  None of the following
        // should compile for any aged_container type.
        //      c.erase (c.rbegin());
        //      c.erase (c.crbegin());
        //      c.erase(c.rbegin(), ++c.rbegin());
        //      c.erase(c.crbegin(), ++c.crbegin());
    }
}
 
// Implementation for the range erase tests
//
// This test accepts:
//
//  o A container with more than 2 elements and
//  o An object to ask for begin() and end() iterators in the passed container
//
// This peculiar interface allows either the container itself to be passed as
// the second argument or the container's "chronological" element.  Both
// sources of iterators need to be tested on the container.
//
// The test locates iterators such that a range-based delete leaves the first
// and last elements in the container.  It then validates that the container
// ended up with the expected contents.
//
template <class Container, class BeginEndSrc>
void
AgedAssociativeContainerTestBase::doRangeErase(Container& c, BeginEndSrc const& beginEndSrc)
{
    BEAST_EXPECT(c.size() > 2);
    auto itBeginPlusOne(beginEndSrc.begin());
    auto const valueFront = *itBeginPlusOne;
    ++itBeginPlusOne;
 
    // Get one iterator before end()
    auto itBack(nextToEndIter(itBeginPlusOne, beginEndSrc.end()));
    auto const valueBack = *itBack;
 
    // Erase all elements but first and last
    auto const retIter = c.erase(itBeginPlusOne, itBack);
 
    BEAST_EXPECT(c.size() == 2);
    BEAST_EXPECT(valueFront == *(beginEndSrc.begin()));
    BEAST_EXPECT(valueBack == *(++beginEndSrc.begin()));
    BEAST_EXPECT(retIter == (++beginEndSrc.begin()));
}
 
//------------------------------------------------------------------------------
//
// Erase range of elements
//
//------------------------------------------------------------------------------
 
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testRangeErase()
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
 
    // testcase (Traits::name() + " element erase"
    testcase("range erase");
 
    // Make and fill the container
    typename Traits::ManualClock clock;
    typename Traits::template Cont<> c{clock};
    reverseFillAgedContainer(c, Traits::values());
 
    // Not bothering to test range erase with reverse iterators.
    {
        auto tempContainer(c);
        doRangeErase(tempContainer, tempContainer);
    }
    {
        auto tempContainer(c);
        doRangeErase(tempContainer, tempContainer.chronological);
    }
}
 
//------------------------------------------------------------------------------
//
// Container-wide comparison
//
//------------------------------------------------------------------------------
 
// ordered
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testCompare()
    requires(!IsUnordered)
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    typename Traits::ManualClock clock;
    auto const v(Traits::values());
 
    // testcase (Traits::name() + " array create");
    testcase("array create");
 
    typename Traits::template Cont<> const c1(v.begin(), v.end(), clock);
 
    typename Traits::template Cont<> c2(v.begin(), v.end(), clock);
    c2.erase(c2.cbegin());
 
    expect(c1 != c2);
    unexpected(c1 == c2);
    expect(c1 < c2);
    expect(c1 <= c2);
    unexpected(c1 > c2);
    unexpected(c1 >= c2);
}
 
//------------------------------------------------------------------------------
//
// Observers
//
//------------------------------------------------------------------------------
 
// ordered
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testObservers()
    requires(!IsUnordered)
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    typename Traits::ManualClock clock;
 
    // testcase (Traits::name() + " observers");
    testcase("observers");
 
    typename Traits::template Cont<> const c(clock);
    c.keyComp();
    c.valueComp();
 
    pass();
}
 
// unordered
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testObservers()
    requires IsUnordered
{
    using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
    typename Traits::ManualClock clock;
 
    // testcase (Traits::name() + " observers");
    testcase("observers");
 
    typename Traits::template Cont<> const c(clock);
    c.hashFunction();
    c.keyEq();
 
    pass();
}
 
//------------------------------------------------------------------------------
//
// Matrix
//
//------------------------------------------------------------------------------
 
template <bool IsUnordered, bool IsMulti, bool IsMap>
void
AgedAssociativeContainerTestBase::testMaybeUnorderedMultiMap()
{
    testConstructEmpty<IsUnordered, IsMulti, IsMap>();
    testConstructRange<IsUnordered, IsMulti, IsMap>();
    testConstructInitList<IsUnordered, IsMulti, IsMap>();
    testCopyMove<IsUnordered, IsMulti, IsMap>();
    testIterator<IsUnordered, IsMulti, IsMap>();
    testReverseIterator<IsUnordered, IsMulti, IsMap>();
    testModifiers<IsUnordered, IsMulti, IsMap>();
    testChronological<IsUnordered, IsMulti, IsMap>();
    testArrayCreate<IsUnordered, IsMulti, IsMap>();
    testElementErase<IsUnordered, IsMulti, IsMap>();
    testRangeErase<IsUnordered, IsMulti, IsMap>();
    testCompare<IsUnordered, IsMulti, IsMap>();
    testObservers<IsUnordered, IsMulti, IsMap>();
}
 
//------------------------------------------------------------------------------
 
class aged_set_test : public AgedAssociativeContainerTestBase
{
public:
    // Compile time checks
 
    using Key = std::string;
    using T = int;
 
    static_assert(
        std::is_same_v<aged_set<Key>, detail::AgedOrderedContainer<false, false, Key, void>>,
        "bad alias: aged_set");
 
    static_assert(
        std::is_same_v<aged_multiset<Key>, detail::AgedOrderedContainer<true, false, Key, void>>,
        "bad alias: aged_multiset");
 
    static_assert(
        std::is_same_v<aged_map<Key, T>, detail::AgedOrderedContainer<false, true, Key, T>>,
        "bad alias: aged_map");
 
    static_assert(
        std::is_same_v<aged_multimap<Key, T>, detail::AgedOrderedContainer<true, true, Key, T>>,
        "bad alias: aged_multimap");
 
    static_assert(
        std::is_same_v<
            aged_unordered_set<Key>,
            detail::AgedUnorderedContainer<false, false, Key, void>>,
        "bad alias: aged_unordered_set");
 
    static_assert(
        std::is_same_v<
            aged_unordered_multiset<Key>,
            detail::AgedUnorderedContainer<true, false, Key, void>>,
        "bad alias: aged_unordered_multiset");
 
    static_assert(
        std::is_same_v<
            aged_unordered_map<Key, T>,
            detail::AgedUnorderedContainer<false, true, Key, T>>,
        "bad alias: aged_unordered_map");
 
    static_assert(
        std::is_same_v<
            aged_unordered_multimap<Key, T>,
            detail::AgedUnorderedContainer<true, true, Key, T>>,
        "bad alias: aged_unordered_multimap");
 
    void
    run() override
    {
        testMaybeUnorderedMultiMap<false, false, false>();
    }
};
 
class aged_map_test : public AgedAssociativeContainerTestBase
{
public:
    void
    run() override
    {
        testMaybeUnorderedMultiMap<false, false, true>();
    }
};
 
class aged_multiset_test : public AgedAssociativeContainerTestBase
{
public:
    void
    run() override
    {
        testMaybeUnorderedMultiMap<false, true, false>();
    }
};
 
class aged_multimap_test : public AgedAssociativeContainerTestBase
{
public:
    void
    run() override
    {
        testMaybeUnorderedMultiMap<false, true, true>();
    }
};
 
class aged_unordered_set_test : public AgedAssociativeContainerTestBase
{
public:
    void
    run() override
    {
        testMaybeUnorderedMultiMap<true, false, false>();
    }
};
 
class aged_unordered_map_test : public AgedAssociativeContainerTestBase
{
public:
    void
    run() override
    {
        testMaybeUnorderedMultiMap<true, false, true>();
    }
};
 
class aged_unordered_multiset_test : public AgedAssociativeContainerTestBase
{
public:
    void
    run() override
    {
        testMaybeUnorderedMultiMap<true, true, false>();
    }
};
 
class aged_unordered_multimap_test : public AgedAssociativeContainerTestBase
{
public:
    void
    run() override
    {
        testMaybeUnorderedMultiMap<true, true, true>();
    }
};
 
BEAST_DEFINE_TESTSUITE(aged_set, beast, beast);
BEAST_DEFINE_TESTSUITE(aged_map, beast, beast);
BEAST_DEFINE_TESTSUITE(aged_multiset, beast, beast);
BEAST_DEFINE_TESTSUITE(aged_multimap, beast, beast);
BEAST_DEFINE_TESTSUITE(aged_unordered_set, beast, beast);
BEAST_DEFINE_TESTSUITE(aged_unordered_map, beast, beast);
BEAST_DEFINE_TESTSUITE(aged_unordered_multiset, beast, beast);
BEAST_DEFINE_TESTSUITE(aged_unordered_multimap, beast, beast);
 
}  // namespace beast