From b881bcfee3b2f39225c3a768efc3297981a1cfdc Mon Sep 17 00:00:00 2001 From: Daniel James Date: Sun, 18 Sep 2016 12:22:48 +0100 Subject: [PATCH] More insert and erase tests --- test/unordered/erase_tests.cpp | 49 ++++++++++++++++++++++++++++++--- test/unordered/insert_tests.cpp | 45 +++++++++++++++++++++++++++++- 2 files changed, 89 insertions(+), 5 deletions(-) diff --git a/test/unordered/erase_tests.cpp b/test/unordered/erase_tests.cpp index 9c737bd8..d098c3df 100644 --- a/test/unordered/erase_tests.cpp +++ b/test/unordered/erase_tests.cpp @@ -16,7 +16,7 @@ #include "../helpers/equivalent.hpp" #include "../helpers/helpers.hpp" #include "../helpers/invariants.hpp" - +#include #include namespace erase_tests @@ -27,6 +27,9 @@ test::seed_t initialize_seed(85638); template void erase_tests1(Container*, test::random_generator generator) { + typedef BOOST_DEDUCED_TYPENAME Container::iterator iterator; + typedef BOOST_DEDUCED_TYPENAME Container::const_iterator c_iterator; + std::cerr<<"Erase by key.\n"; { test::check_instances check_; @@ -60,8 +63,7 @@ void erase_tests1(Container*, test::random_generator generator) BOOST_DEDUCED_TYPENAME Container::key_type key = test::get_key(*x.begin()); std::size_t count = x.count(key); - BOOST_DEDUCED_TYPENAME Container::iterator - pos = x.erase(x.begin()); + iterator pos = x.erase(x.begin()); --size; BOOST_TEST(pos == x.begin()); BOOST_TEST(x.count(key) == count - 1); @@ -83,7 +85,7 @@ void erase_tests1(Container*, test::random_generator generator) { using namespace std; int index = rand() % (int) x.size(); - BOOST_DEDUCED_TYPENAME Container::const_iterator prev, pos, next; + c_iterator prev, pos, next; if(index == 0) { prev = pos = x.begin(); } @@ -138,6 +140,45 @@ void erase_tests1(Container*, test::random_generator generator) test::check_equivalent_keys(x); } + std::cerr<<"erase(random ranges).\n"; + { + test::check_instances check_; + Container x; + + for (int i = 0; i < 100; ++i) { + test::random_values v(1000, generator); + x.insert(v.begin(), v.end()); + + // Note that erase only invalidates the erased iterators. + std::vector iterators; + for(c_iterator it = x.cbegin(); it != x.cend(); ++it) { + iterators.push_back(it); + } + iterators.push_back(x.cend()); + + while(iterators.size() > 1) { + int start = rand() % (int) iterators.size(); + int length = rand() % (int) (iterators.size() - start); + x.erase(iterators[start], iterators[start + length]); + iterators.erase( + boost::next(iterators.begin(), start), + boost::next(iterators.begin(), start + length)); + + BOOST_TEST(x.size() == iterators.size() - 1); + BOOST_DEDUCED_TYPENAME std::vector::const_iterator + i2 = iterators.begin(); + for(c_iterator i1 = x.cbegin(); i1 != x.cend(); ++i1) { + BOOST_TEST(i1 == *i2); + ++i2; + } + BOOST_TEST(x.cend() == *i2); + + test::check_equivalent_keys(x); + } + BOOST_TEST(x.empty()); + } + } + std::cerr<<"quick_erase(begin()).\n"; { test::check_instances check_; diff --git a/test/unordered/insert_tests.cpp b/test/unordered/insert_tests.cpp index 8ebdd337..36c5c9dc 100644 --- a/test/unordered/insert_tests.cpp +++ b/test/unordered/insert_tests.cpp @@ -128,6 +128,7 @@ void insert_tests2(X*, test::random_generator generator) BOOST_TEST(x.bucket_count() == old_bucket_count); } + tracker.compare(x); test::check_equivalent_keys(x); } @@ -157,6 +158,7 @@ void insert_tests2(X*, test::random_generator generator) BOOST_TEST(x.bucket_count() == old_bucket_count); } + tracker.compare(x); test::check_equivalent_keys(x); } @@ -186,6 +188,7 @@ void insert_tests2(X*, test::random_generator generator) BOOST_TEST(x.bucket_count() == old_bucket_count); } + tracker.compare(x); test::check_equivalent_keys(x); } @@ -213,6 +216,7 @@ void insert_tests2(X*, test::random_generator generator) BOOST_TEST(x.bucket_count() == old_bucket_count); } + tracker.compare(x); test::check_equivalent_keys(x); } @@ -292,6 +296,42 @@ void insert_tests2(X*, test::random_generator generator) test::check_equivalent_keys(x); } + + std::cerr<<"insert various ranges.\n"; + + { + for (int i = 0; i < 100; ++i) { + X x; + test::ordered tracker = test::create_ordered(x); + + test::random_values v(1000, generator); + + for(BOOST_DEDUCED_TYPENAME test::random_values::iterator + it = v.begin(); it != v.end();) + { + BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count(); + float b = x.max_load_factor(); + + BOOST_DEDUCED_TYPENAME test::random_values::iterator + next = it; + for (int j = rand() % 20; j > 0; ++j) { + ++next; + if (next == v.end()) { break; } + } + + x.insert(it, next); + tracker.insert(it, next); + it = next; + + tracker.compare(x); // Slow, but I can't see any other way. + + if(static_cast(x.size()) <= b * static_cast(old_bucket_count)) + BOOST_TEST(x.bucket_count() == old_bucket_count); + } + + test::check_equivalent_keys(x); + } + } } template @@ -327,6 +367,7 @@ void unique_emplace_tests1(X*, test::random_generator generator) BOOST_TEST(x.bucket_count() == old_bucket_count); } + tracker.compare(x); test::check_equivalent_keys(x); } @@ -357,6 +398,7 @@ void equivalent_emplace_tests1(X*, test::random_generator generator) BOOST_TEST(x.bucket_count() == old_bucket_count); } + tracker.compare(x); test::check_equivalent_keys(x); } @@ -386,8 +428,8 @@ void move_emplace_tests(X*, test::random_generator generator) BOOST_TEST(x.bucket_count() == old_bucket_count); } - test::check_equivalent_keys(x); tracker.compare(x); + test::check_equivalent_keys(x); } template @@ -449,6 +491,7 @@ void map_tests(X*, test::random_generator generator) BOOST_TEST(x.bucket_count() == old_bucket_count); } + tracker.compare(x); test::check_equivalent_keys(x); }