1#include <xrpl/beast/clock/manual_clock.h>
2#include <xrpl/beast/container/aged_map.h>
3#include <xrpl/beast/container/aged_multimap.h>
4#include <xrpl/beast/container/aged_multiset.h>
5#include <xrpl/beast/container/aged_set.h>
6#include <xrpl/beast/container/aged_unordered_map.h>
7#include <xrpl/beast/container/aged_unordered_multimap.h>
8#include <xrpl/beast/container/aged_unordered_multiset.h>
9#include <xrpl/beast/container/aged_unordered_set.h>
10#include <xrpl/beast/container/detail/aged_ordered_container.h>
11#include <xrpl/beast/container/detail/aged_unordered_container.h>
12#include <xrpl/beast/unit_test/suite.h>
25#ifndef BEAST_AGED_UNORDERED_NO_ALLOC_DEFAULTCTOR
27#define BEAST_AGED_UNORDERED_NO_ALLOC_DEFAULTCTOR 0
29#define BEAST_AGED_UNORDERED_NO_ALLOC_DEFAULTCTOR 1
33#ifndef BEAST_CONTAINER_EXTRACT_NOREF
35#define BEAST_CONTAINER_EXTRACT_NOREF 1
37#define BEAST_CONTAINER_EXTRACT_NOREF 1
62 return less_(lhs, rhs);
102 return eq_(lhs, rhs);
144 return !(*
this == o);
150 return static_cast<T*
>(::operator
new(n *
sizeof(T)));
156 ::operator
delete(p);
159#if !BEAST_AGED_UNORDERED_NO_ALLOC_DEFAULTCTOR
171 template <
class Base,
bool IsUnordered>
187 template <
class Base>
205 template <
class Base,
bool IsMulti>
218 template <
class Base>
231 template <
class Base,
bool IsMap>
239 static Base::Key
const&
267 template <
class Base>
275 static Base::Key
const&
305 template <
class Base,
bool IsUnordered = Base::IsUnorderedType::value>
312 Base::IsMultiType::value,
313 Base::IsMapType::value,
316 typename Base::Clock,
322 template <
class Base>
330 Base::IsMultiType::value,
331 Base::IsMapType::value,
334 typename Base::Clock,
349 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
351 :
MaybeUnordered<MaybeMulti<MaybeMap<TestTraitsBase, IsMap>, IsMulti>, IsUnordered>
358 using typename Base::Key;
370 return std::string(
"aged_") + Base::name_ordered_part() + Base::name_multi_part() +
371 Base::name_map_part();
375 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
377 ContType<TestTraitsHelper<IsUnordered, IsMulti, IsMap>>
381 template <
class Cont>
388 template <
class Traits>
392 operator()(Traits::Value
const& lhs, Traits::Value
const& rhs)
394 return Traits::extract(lhs) == Traits::extract(rhs);
398 template <
class Cont>
407 template <
class Container,
class Values>
410 requires(Container::IsMapType::value && !Container::IsMultiType::value);
412 template <
class Container,
class Values>
415 requires(!(Container::IsMapType::value && !Container::IsMultiType::value))
420 template <
class C,
class Values>
425 template <
class C,
class Values>
432 template <
class C,
class Values>
436 template <
class Cont,
class Values>
440 template <
class Cont>
447 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
450 requires(!IsUnordered);
453 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
456 requires IsUnordered;
459 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
462 requires(!IsUnordered);
465 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
468 requires IsUnordered;
471 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
474 requires(!IsUnordered);
477 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
480 requires IsUnordered;
484 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
490 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
495 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
498 requires(!IsUnordered);
500 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
509 template <
class Container,
class Values>
513 template <
class Container,
class Values>
517 template <
class Container,
class Values>
521 template <
class Container,
class Values>
525 template <
class Container,
class Values>
529 template <
class Container,
class Values>
533 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
539 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
546 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
549 requires(IsMap && !IsMulti);
551 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
554 requires(!IsMap || IsMulti)
561 template <
class Container,
class Values>
565 template <
class Iter>
571 template <
class Container,
class Iter>
573 doElementErase(Container& c, Iter
const beginItr, Iter
const endItr);
575 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
581 template <
class Container,
class BeginEndSrc>
583 doRangeErase(Container& c, BeginEndSrc
const& beginEndSrc);
585 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
592 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
595 requires(!IsUnordered);
597 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
607 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
610 requires(!IsUnordered);
613 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
616 requires IsUnordered;
620 template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
624 template <
bool IsUnordered,
bool IsMulti>
628 template <
bool IsUnordered>
637template <class Container, class Values>
640 requires(Container::IsMapType::value && !Container::IsMultiType::value)
644 BEAST_EXPECT(c.empty());
645 BEAST_EXPECT(c.size() == 0);
652 for (auto const& e : v)
654 for (auto const& e : v)
655 BEAST_EXPECT(c.operator[](e.first) == e.second);
659 fail(
"caught exception");
664template <
class C,
class Values>
672 using size_type = Cont::size_type;
673 auto const hash(c.hashFunction());
674 auto const keyEq(c.keyEq());
675 for (size_type i(0); i < c.bucketCount(); ++i)
677 auto const last(c.end(i));
678 for (
auto iter(c.begin(i)); iter != last; ++iter)
681 return Traits::extract(*iter) == Traits::extract(e);
683 BEAST_EXPECT(match != v.end());
684 BEAST_EXPECT(keyEq(Traits::extract(*iter), Traits::extract(*match)));
685 BEAST_EXPECT(hash(Traits::extract(*iter)) == hash(Traits::extract(*match)));
690template <
class C,
class Values>
695 using size_type = Cont::size_type;
697 BEAST_EXPECT(c.size() == v.size());
698 BEAST_EXPECT(size_type(
std::distance(c.begin(), c.end())) == v.size());
699 BEAST_EXPECT(size_type(
std::distance(c.cbegin(), c.cend())) == v.size());
701 size_type(
std::distance(c.chronological.begin(), c.chronological.end())) == v.size());
703 size_type(
std::distance(c.chronological.cbegin(), c.chronological.cend())) == v.size());
705 size_type(
std::distance(c.chronological.rbegin(), c.chronological.rend())) == v.size());
707 size_type(
std::distance(c.chronological.crbegin(), c.chronological.crend())) == v.size());
712template <
class Cont,
class Values>
727 using Values = Traits::Values;
738template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
741 requires(!IsUnordered)
744 using Comp = Traits::Comp;
745 using Alloc = Traits::Alloc;
746 using MyComp = Traits::MyComp;
747 using MyAlloc = Traits::MyAlloc;
748 typename Traits::ManualClock clock;
754 typename Traits::template Cont<Comp, Alloc> c(clock);
759 typename Traits::template Cont<MyComp, Alloc> c(clock, MyComp(1));
764 typename Traits::template Cont<Comp, MyAlloc> c(clock, MyAlloc(1));
769 typename Traits::template Cont<MyComp, MyAlloc> c(clock, MyComp(1), MyAlloc(1));
775template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
780 using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
781 using Hash = Traits::Hash;
782 using Equal = Traits::Equal;
783 using Alloc = Traits::Alloc;
784 using MyHash = Traits::MyHash;
785 using MyEqual = Traits::MyEqual;
786 using MyAlloc = Traits::MyAlloc;
787 typename Traits::ManualClock clock;
792 typename Traits::template Cont<Hash, Equal, Alloc> c(clock);
797 typename Traits::template Cont<MyHash, Equal, Alloc> c(clock, MyHash(1));
802 typename Traits::template Cont<Hash, MyEqual, Alloc> c(clock, MyEqual(1));
807 typename Traits::template Cont<Hash, Equal, MyAlloc> c(clock, MyAlloc(1));
812 typename Traits::template Cont<MyHash, MyEqual, Alloc> c(clock, MyHash(1), MyEqual(1));
817 typename Traits::template Cont<MyHash, Equal, MyAlloc> c(clock, MyHash(1), MyAlloc(1));
822 typename Traits::template Cont<Hash, MyEqual, MyAlloc> c(clock, MyEqual(1), MyAlloc(1));
827 typename Traits::template Cont<MyHash, MyEqual, MyAlloc> c(
828 clock, MyHash(1), MyEqual(1), MyAlloc(1));
834template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
837 requires(!IsUnordered)
840 using Comp = Traits::Comp;
841 using Alloc = Traits::Alloc;
842 using MyComp = Traits::MyComp;
843 using MyAlloc = Traits::MyAlloc;
844 typename Traits::ManualClock clock;
845 auto const v(Traits::values());
851 typename Traits::template Cont<Comp, Alloc> c(v.begin(), v.end(), clock);
856 typename Traits::template Cont<MyComp, Alloc> c(v.begin(), v.end(), clock, MyComp(1));
861 typename Traits::template Cont<Comp, MyAlloc> c(v.begin(), v.end(), clock, MyAlloc(1));
866 typename Traits::template Cont<MyComp, MyAlloc> c(
867 v.begin(), v.end(), clock, MyComp(1), MyAlloc(1));
874 typename Traits::template Cont<Comp, Alloc> c1(v.begin(), v.end(), clock);
875 typename Traits::template Cont<Comp, Alloc> c2(clock);
882template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
887 using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
888 using Hash = Traits::Hash;
889 using Equal = Traits::Equal;
890 using Alloc = Traits::Alloc;
891 using MyHash = Traits::MyHash;
892 using MyEqual = Traits::MyEqual;
893 using MyAlloc = Traits::MyAlloc;
894 typename Traits::ManualClock clock;
895 auto const v(Traits::values());
901 typename Traits::template Cont<Hash, Equal, Alloc> c(v.begin(), v.end(), clock);
906 typename Traits::template Cont<MyHash, Equal, Alloc> c(
907 v.begin(), v.end(), clock, MyHash(1));
912 typename Traits::template Cont<Hash, MyEqual, Alloc> c(
913 v.begin(), v.end(), clock, MyEqual(1));
918 typename Traits::template Cont<Hash, Equal, MyAlloc> c(
919 v.begin(), v.end(), clock, MyAlloc(1));
924 typename Traits::template Cont<MyHash, MyEqual, Alloc> c(
925 v.begin(), v.end(), clock, MyHash(1), MyEqual(1));
930 typename Traits::template Cont<MyHash, Equal, MyAlloc> c(
931 v.begin(), v.end(), clock, MyHash(1), MyAlloc(1));
936 typename Traits::template Cont<Hash, MyEqual, MyAlloc> c(
937 v.begin(), v.end(), clock, MyEqual(1), MyAlloc(1));
942 typename Traits::template Cont<MyHash, MyEqual, MyAlloc> c(
943 v.begin(), v.end(), clock, MyHash(1), MyEqual(1), MyAlloc(1));
949template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
952 requires(!IsUnordered)
955 typename Traits::ManualClock
const clock;
966template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
971 using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
972 typename Traits::ManualClock
const clock;
987template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
992 using Alloc = Traits::Alloc;
993 typename Traits::ManualClock clock;
994 auto const v(Traits::values());
1002 typename Traits::template Cont<> c(v.begin(), v.end(), clock);
1003 typename Traits::template Cont<> c2(c);
1006 BEAST_EXPECT(c == c2);
1011 typename Traits::template Cont<> c(v.begin(), v.end(), clock);
1012 typename Traits::template Cont<> c2(c, Alloc());
1015 BEAST_EXPECT(c == c2);
1020 typename Traits::template Cont<> c(v.begin(), v.end(), clock);
1021 typename Traits::template Cont<> c2(clock);
1025 BEAST_EXPECT(c == c2);
1032 typename Traits::template Cont<> c(v.begin(), v.end(), clock);
1033 typename Traits::template Cont<> c2(std::move(c));
1038 typename Traits::template Cont<> c(v.begin(), v.end(), clock);
1039 typename Traits::template Cont<> c2(std::move(c), Alloc());
1044 typename Traits::template Cont<> c(v.begin(), v.end(), clock);
1045 typename Traits::template Cont<> c2(clock);
1057template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
1062 typename Traits::ManualClock clock;
1063 auto const v(Traits::values());
1068 typename Traits::template Cont<> c{clock};
1070 using iterator =
decltype(c.begin());
1071 using const_iterator =
decltype(c.cbegin());
1074 iterator
const nnIt0{c.begin()};
1075 iterator
const nnIt1{nnIt0};
1076 BEAST_EXPECT(nnIt0 == nnIt1);
1079 BEAST_EXPECT(nnIt1 == nnIt2);
1083 const_iterator
const ccIt0{c.cbegin()};
1084 const_iterator
const ccIt1{ccIt0};
1085 BEAST_EXPECT(ccIt0 == ccIt1);
1086 const_iterator ccIt2;
1088 BEAST_EXPECT(ccIt1 == ccIt2);
1091 BEAST_EXPECT(nnIt0 == ccIt0);
1092 BEAST_EXPECT(ccIt1 == nnIt1);
1095 const_iterator
const ncIt3{c.begin()};
1096 const_iterator
const ncIt4{nnIt0};
1097 BEAST_EXPECT(ncIt3 == ncIt4);
1098 const_iterator ncIt5;
1100 BEAST_EXPECT(ncIt5 == ncIt4);
1113template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
1116 requires(!IsUnordered)
1119 typename Traits::ManualClock clock;
1120 auto const v(Traits::values());
1125 typename Traits::template Cont<> c{clock};
1127 using iterator =
decltype(c.begin());
1128 using reverse_iterator =
decltype(c.rbegin());
1129 using const_reverse_iterator =
decltype(c.crbegin());
1140 reverse_iterator
const rNrNit0{c.rbegin()};
1141 reverse_iterator
const rNrNit1{rNrNit0};
1142 BEAST_EXPECT(rNrNit0 == rNrNit1);
1143 reverse_iterator xXrNit2;
1145 BEAST_EXPECT(rNrNit1 == xXrNit2);
1149 const_reverse_iterator
const rCrCit0{c.crbegin()};
1150 const_reverse_iterator
const rCrCit1{rCrCit0};
1151 BEAST_EXPECT(rCrCit0 == rCrCit1);
1152 const_reverse_iterator xXrCit2;
1154 BEAST_EXPECT(rCrCit1 == xXrCit2);
1157 BEAST_EXPECT(rNrNit0 == rCrCit0);
1158 BEAST_EXPECT(rCrCit1 == rNrNit1);
1162 const_reverse_iterator
const rNrCit0{c.rbegin()};
1163 const_reverse_iterator
const rNrCit1{rNrNit0};
1164 BEAST_EXPECT(rNrCit0 == rNrCit1);
1166 BEAST_EXPECT(rNrCit1 == xXrCit2);
1174 reverse_iterator
const fNrNit0{c.begin()};
1175 const_reverse_iterator
const fNrCit0{c.begin()};
1176 BEAST_EXPECT(fNrNit0 == fNrCit0);
1177 const_reverse_iterator
const fCrCit0{c.cbegin()};
1178 BEAST_EXPECT(fNrCit0 == fCrCit0);
1188 iterator
const xXfNit0;
1199template <
class Container,
class Values>
1203 for (
auto const& e : v)
1208template <
class Container,
class Values>
1214 c.insert(std::move(e));
1218template <
class Container,
class Values>
1222 for (
auto const& e : v)
1223 c.insert(c.cend(), e);
1227template <
class Container,
class Values>
1233 c.insert(c.cend(), std::move(e));
1237template <
class Container,
class Values>
1241 for (
auto const& e : v)
1246template <
class Container,
class Values>
1250 for (
auto const& e : v)
1251 c.emplace_hint(c.cend(), e);
1255template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
1260 typename Traits::ManualClock clock;
1261 auto const v(Traits::values());
1268 typename Traits::template Cont<> c(clock);
1273 typename Traits::template Cont<> c(clock);
1278 typename Traits::template Cont<> c(clock);
1283 typename Traits::template Cont<> c(clock);
1288 typename Traits::template Cont<> c(clock);
1293 typename Traits::template Cont<> c(clock);
1298 typename Traits::template Cont<> c(clock);
1303 typename Traits::template Cont<> c(clock);
1314template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
1319 typename Traits::ManualClock clock;
1320 auto const v(Traits::values());
1325 typename Traits::template Cont<> c(v.begin(), v.end(), clock);
1330 for (
auto iter(v.crbegin()); iter != v.crend(); ++iter)
1332 using iterator =
decltype(c)::iterator;
1333 iterator
const found(c.find(Traits::extract(*iter)));
1335 BEAST_EXPECT(found != c.cend());
1336 if (found == c.cend())
1343 c.chronological.cbegin(),
1344 c.chronological.cend(),
1350 for (
auto iter(v.cbegin()); iter != v.cend(); ++iter)
1352 using const_iterator =
decltype(c)::const_iterator;
1353 const_iterator
const found(c.find(Traits::extract(*iter)));
1355 BEAST_EXPECT(found != c.cend());
1356 if (found == c.cend())
1378template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
1381 requires(IsMap && !IsMulti)
1384 typename Traits::ManualClock clock;
1385 auto const v(Traits::values());
1392 typename Traits::template Cont<> c(clock);
1393 for (
auto const& e : v)
1394 c[e.first] = e.second;
1400 typename Traits::template Cont<> c(clock);
1402 c[std::move(e.first)] = e.second;
1413template <
class Container,
class Values>
1423 auto& clk =
dynamic_cast<ManualClock&
>(c.clock());
1429 for (
auto const& v : rev)
1439template <
class Iter>
1443 if (beginIter == endIter)
1445 fail(
"Internal test failure. Cannot advance beginIter");
1450 Iter nextToEnd = beginIter;
1453 nextToEnd = beginIter++;
1454 }
while (beginIter != endIter);
1471template <
class Container,
class Iter>
1475 Iter
const beginItr,
1479 size_t count = c.size();
1480 while (it != endItr)
1488 fail(
"Unexpected returned iterator from element erase");
1493 if (count != c.size())
1495 fail(
"Failed to erase element");
1503 fail(
"Erase of last element didn't produce end");
1517template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
1527 typename Traits::ManualClock clock;
1528 typename Traits::template Cont<> c{clock};
1533 auto tempContainer(c);
1534 if (!
doElementErase(tempContainer, tempContainer.cbegin(), tempContainer.cend()))
1537 BEAST_EXPECT(tempContainer.empty());
1542 auto tempContainer(c);
1543 auto& chron(tempContainer.chronological);
1547 BEAST_EXPECT(tempContainer.empty());
1552 auto tempContainer(c);
1553 BEAST_EXPECT(tempContainer.size() > 2);
1556 ++tempContainer.begin(),
1560 BEAST_EXPECT(tempContainer.size() == 2);
1565 auto tempContainer(c);
1566 BEAST_EXPECT(tempContainer.size() > 2);
1567 auto& chron(tempContainer.chronological);
1569 tempContainer, ++chron.begin(),
nextToEndIter(chron.begin(), chron.end())))
1572 BEAST_EXPECT(tempContainer.size() == 2);
1576 auto const tempContainer(c);
1577 BEAST_EXPECT(tempContainer.size() > 4);
1602template <
class Container,
class BeginEndSrc>
1606 BEAST_EXPECT(c.size() > 2);
1607 auto itBeginPlusOne(beginEndSrc.begin());
1608 auto const valueFront = *itBeginPlusOne;
1612 auto const itBack(
nextToEndIter(itBeginPlusOne, beginEndSrc.end()));
1613 auto const valueBack = *itBack;
1616 auto const retIter = c.erase(itBeginPlusOne, itBack);
1618 BEAST_EXPECT(c.size() == 2);
1619 BEAST_EXPECT(valueFront == *(beginEndSrc.begin()));
1620 BEAST_EXPECT(valueBack == *(++beginEndSrc.begin()));
1621 BEAST_EXPECT(retIter == (++beginEndSrc.begin()));
1630template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
1640 typename Traits::ManualClock clock;
1641 typename Traits::template Cont<> c{clock};
1646 auto tempContainer(c);
1650 auto tempContainer(c);
1651 doRangeErase(tempContainer, tempContainer.chronological);
1662template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
1665 requires(!IsUnordered)
1668 typename Traits::ManualClock clock;
1669 auto const v(Traits::values());
1674 typename Traits::template Cont<>
const c1(v.begin(), v.end(), clock);
1676 typename Traits::template Cont<> c2(v.begin(), v.end(), clock);
1677 c2.erase(c2.cbegin());
1694template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
1697 requires(!IsUnordered)
1700 typename Traits::ManualClock clock;
1705 typename Traits::template Cont<>
const c(clock);
1713template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
1716 requires IsUnordered
1718 using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
1719 typename Traits::ManualClock clock;
1724 typename Traits::template Cont<>
const c(clock);
1737template <
bool IsUnordered,
bool IsMulti,
bool IsMap>
1768 "bad alias: AgedSet");
1772 "bad alias: AgedMultiset");
1776 "bad alias: AgedMap");
1780 "bad alias: AgedMultimap");
1786 "bad alias: AgedUnorderedSet");
1792 "bad alias: AgedUnorderedMultiset");
1798 "bad alias: AgedUnorderedMap");
1804 "bad alias: AgedUnorderedMultimap");
std::size_t operator()(T const &t) const
static std::string nameMapPart()
static Base::Key const & extract(Value const &value)
std::vector< Value > Values
std::pair< typename Base::Key, T > Value
static Base::Key const & extract(Value const &value)
static std::string nameMapPart()
std::vector< Value > Values
static std::string nameMultiPart()
static std::string nameMultiPart()
std::hash< typename Base::Key > Hash
static std::string nameOrderedPart()
EqualT< typename Base::Key > MyEqual
HashT< typename Base::Key > MyHash
std::equal_to< typename Base::Key > Equal
std::less< typename Base::Key > Comp
static std::string nameOrderedPart()
CompT< typename Base::Key > MyComp
void checkInsertHintMove(Container &c, Values const &v)
void testConstructRange()
void reverseFillAgedContainer(Container &c, Values const &v)
bool doElementErase(Container &c, Iter const beginItr, Iter const endItr)
void checkMapContents(Container, Values const &)
void checkContentsRefRef(C &&c, Values const &v)
static std::string name(Cont const &)
void testReverseIterator()
void testConstructInitList()
void testMaybeUnorderedMultiMap()
void checkEmplaceHint(Container &c, Values const &v)
void checkUnorderedContentsRefRef(C &&c, Values const &v)
void checkInsertCopy(Container &c, Values const &v)
void checkUnorderedContentsRefRef(C &&, Values const &)
void doRangeErase(Container &c, BeginEndSrc const &beginEndSrc)
void checkInsertMove(Container &c, Values const &v)
void checkEmplace(Container &c, Values const &v)
static std::vector< typename Cont::value_type > makeList(Cont const &c)
void checkMapContents(Container &c, Values const &v)
void testConstructEmpty()
void checkInsertHintCopy(Container &c, Values const &v)
Iter nextToEndIter(Iter const beginIter, Iter const endItr)
void testConstructEmpty()
void testMaybeUnorderedMulti()
void testMaybeUnordered()
void checkContents(Cont &c, Values const &v)
Manual clock implementation.
void set(time_point const &when)
Set the current time of the manual clock.
void run() override
Runs the suite.
void run() override
Runs the suite.
void run() override
Runs the suite.
void run() override
Runs the suite.
void run() override
Runs the suite.
void run() override
Runs the suite.
void run() override
Runs the suite.
void run() override
Runs the suite.
Associative container where each element is also indexed by time.
Associative container where each element is also indexed by time.
bool unexpected(Condition shouldBeFalse, String const &reason)
DEPRECATED.
void pass()
Record a successful test condition.
bool expect(Condition const &shouldBeTrue)
Evaluate a test condition.
void fail(String const &reason, char const *file, int line)
Record a failure.
TestcaseT testcase
Memberspace for declaring test cases.
detail::AgedUnorderedContainer< true, false, Key, void, Clock, Hash, KeyEqual, Allocator > AgedUnorderedMultiset
BEAST_DEFINE_TESTSUITE(aged_set, beast, beast)
detail::AgedUnorderedContainer< true, true, Key, T, Clock, Hash, KeyEqual, Allocator > AgedUnorderedMultimap
detail::AgedUnorderedContainer< false, false, Key, void, Clock, Hash, KeyEqual, Allocator > AgedUnorderedSet
detail::AgedUnorderedContainer< false, true, Key, T, Clock, Hash, KeyEqual, Allocator > AgedUnorderedMap
AllocT(AllocT< U > const &)
bool operator==(AllocT< U > const &) const
AllocT(AllocT const &)=default
T * allocate(std::size_t n, T const *=nullptr)
bool operator!=(AllocT< U > const &o) const
void deallocate(T *p, std::size_t)
bool operator()(T const &lhs, T const &rhs) const
detail::AgedUnorderedContainer< Base::IsMultiType::value, Base::IsMapType::value, typename Base::Key, typename Base::T, typename Base::Clock, Hash, KeyEqual, Allocator > Cont
detail::AgedOrderedContainer< Base::IsMultiType::value, Base::IsMapType::value, typename Base::Key, typename Base::T, typename Base::Clock, Compare, Allocator > Cont
bool operator()(T const &lhs, T const &rhs) const
bool operator()(Traits::Value const &lhs, Traits::Value const &rhs)
std::chrono::steady_clock Clock
beast::ManualClock< Clock > ManualClock
std::integral_constant< bool, IsUnordered > IsUnorderedType
AllocT< typename Base::Value > MyAlloc
MaybeUnordered< MaybeMulti< MaybeMap< TestTraitsBase, IsMap >, IsMulti >, IsUnordered > Base
std::allocator< typename Base::Value > Alloc
static std::string name()
std::integral_constant< bool, IsMulti > IsMultiType
std::integral_constant< bool, IsMap > IsMapType