feedc0de/boost_unordered
1
0
Fork 0
forked from boostorg/unordered
Code Pull Requests Activity

Factor insert_exception_tests for better code reuse

Browse Source
This commit is contained in:
Daniel James
2017-05-07 18:43:50 +01:00
parent 8af4b37d14
commit 9119a42b7d
1 changed files with 73 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
test/exception/insert_exception_tests.cpp
View File

@ -15,6 +15,21 @@
test::seed_t initialize_seed(747373); test::seed_t initialize_seed(747373);
// Fill in a container so that it's about to rehash
template <typename T> void rehash_prep(T& x)
{
using namespace std;
typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
x.max_load_factor(0.25);
size_type bucket_count = x.bucket_count();
size_type initial_elements = static_cast<size_type>(
ceil((double)bucket_count * (double)x.max_load_factor()) - 1);
test::random_values<T> v(initial_elements);
x.insert(v.begin(), v.end());
BOOST_TEST(bucket_count == x.bucket_count());
}
// Overload to generate inserters that need type information. // Overload to generate inserters that need type information.
template <typename Inserter, typename T> template <typename Inserter, typename T>
@ -51,17 +66,13 @@ void insert_exception_test_impl(T x, Inserter insert, Values const& v)
insert(x, it); insert(x, it);
} }
} catch (...) { } catch (...) {
std::string scope(test::scope);
if (scope.find("hash::operator()") == std::string::npos)
strong.test(x, test::detail::tracker.count_allocations);
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
insert.exception_check(x, strong);
throw; throw;
} }
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
tracker.insert(v.begin(), v.end()); insert.track(tracker, v.begin(), v.end());
tracker.compare(x); tracker.compare(x);
} }
@ -85,18 +96,9 @@ template <typename T, typename Inserter>
void insert_rehash_exception_test( void insert_rehash_exception_test(
T*, Inserter insert, test::random_generator gen) T*, Inserter insert, test::random_generator gen)
{ {
using namespace std;
typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
T x; T x;
x.max_load_factor(0.25); rehash_prep(x);
size_type bucket_count = x.bucket_count();
size_type initial_elements = static_cast<size_type>(
ceil((double)bucket_count * (double)x.max_load_factor()) - 1);
test::random_values<T> v(initial_elements);
x.insert(v.begin(), v.end());
BOOST_TEST(bucket_count == x.bucket_count());
test::random_values<T> v2(5, gen); test::random_values<T> v2(5, gen);
EXCEPTION_LOOP(insert_exception_test_impl(x, generate(insert, x), v2)); EXCEPTION_LOOP(insert_exception_test_impl(x, generate(insert, x), v2));
@ -105,7 +107,24 @@ void insert_rehash_exception_test(
// Various methods for inserting a single element // Various methods for inserting a single element
struct insert_lvalue_type struct inserter_base
{
template <typename T> void exception_check(T& x, test::strong<T>& strong)
{
std::string scope(test::scope);
if (scope.find("hash::operator()") == std::string::npos)
strong.test(x, test::detail::tracker.count_allocations);
}
template <typename T, typename Iterator>
void track(T& tracker, Iterator begin, Iterator end)
{
tracker.insert(begin, end);
}
};
struct insert_lvalue_type : inserter_base
{ {
template <typename T, typename Iterator> void operator()(T& x, Iterator it) template <typename T, typename Iterator> void operator()(T& x, Iterator it)
{ {
@ -113,7 +132,7 @@ struct insert_lvalue_type
} }
} insert_lvalue; } insert_lvalue;
struct insert_lvalue_begin_type struct insert_lvalue_begin_type : inserter_base
{ {
template <typename T, typename Iterator> void operator()(T& x, Iterator it) template <typename T, typename Iterator> void operator()(T& x, Iterator it)
{ {
@ -121,7 +140,7 @@ struct insert_lvalue_begin_type
} }
} insert_lvalue_begin; } insert_lvalue_begin;
struct insert_lvalue_end_type struct insert_lvalue_end_type : inserter_base
{ {
template <typename T, typename Iterator> void operator()(T& x, Iterator it) template <typename T, typename Iterator> void operator()(T& x, Iterator it)
{ {
@ -131,7 +150,7 @@ struct insert_lvalue_end_type
struct insert_lvalue_pos_type struct insert_lvalue_pos_type
{ {
template <typename T> struct impl template <typename T> struct impl : inserter_base
{ {
typename T::iterator pos; typename T::iterator pos;
@ -149,7 +168,7 @@ struct insert_lvalue_pos_type
} }
} insert_lvalue_pos; } insert_lvalue_pos;
struct insert_single_item_range_type struct insert_single_item_range_type : inserter_base
{ {
template <typename T, typename Iterator> void operator()(T& x, Iterator it) template <typename T, typename Iterator> void operator()(T& x, Iterator it)
{ {
@ -157,7 +176,7 @@ struct insert_single_item_range_type
} }
} insert_single_item_range; } insert_single_item_range;
struct emplace_lvalue_type struct emplace_lvalue_type : inserter_base
{ {
template <typename T, typename Iterator> void operator()(T& x, Iterator it) template <typename T, typename Iterator> void operator()(T& x, Iterator it)
{ {
@ -165,7 +184,7 @@ struct emplace_lvalue_type
} }
} emplace_lvalue; } emplace_lvalue;
struct emplace_lvalue_begin_type struct emplace_lvalue_begin_type : inserter_base
{ {
template <typename T, typename Iterator> void operator()(T& x, Iterator it) template <typename T, typename Iterator> void operator()(T& x, Iterator it)
{ {
@ -173,7 +192,7 @@ struct emplace_lvalue_begin_type
} }
} emplace_lvalue_begin; } emplace_lvalue_begin;
struct emplace_lvalue_end_type struct emplace_lvalue_end_type : inserter_base
{ {
template <typename T, typename Iterator> void operator()(T& x, Iterator it) template <typename T, typename Iterator> void operator()(T& x, Iterator it)
{ {
@ -183,7 +202,7 @@ struct emplace_lvalue_end_type
struct emplace_lvalue_pos_type struct emplace_lvalue_pos_type
{ {
template <typename T> struct impl template <typename T> struct impl : inserter_base
{ {
typename T::iterator pos; typename T::iterator pos;
@ -236,7 +255,7 @@ UNORDERED_TEST(insert_rehash_exception_test,
// Repeat insert tests with pairs // Repeat insert tests with pairs
struct pair_emplace_type struct pair_emplace_type : inserter_base
{ {
template <typename T, typename Iterator> void operator()(T& x, Iterator it) template <typename T, typename Iterator> void operator()(T& x, Iterator it)
{ {
@ -245,7 +264,7 @@ struct pair_emplace_type
} }
} pair_emplace; } pair_emplace;
struct pair_emplace2_type struct pair_emplace2_type : inserter_base
{ {
template <typename T, typename Iterator> void operator()(T& x, Iterator it) template <typename T, typename Iterator> void operator()(T& x, Iterator it)
{ {
@ -273,45 +292,43 @@ UNORDERED_TEST(insert_rehash_exception_test,
// Test inserting using operator[] // Test inserting using operator[]
template <typename T, typename Values> struct map_inserter_base
void insert_operator_exception_test_impl(T x, Values const& v)
{ {
test::ordered<T> tracker; template <typename T> void exception_check(T& x, test::strong<T>& strong)
tracker.insert(x.begin(), x.end()); {
std::string scope(test::scope);
try { if (scope.find("hash::operator()") == std::string::npos &&
ENABLE_EXCEPTIONS; scope.find("::operator=") == std::string::npos)
strong.test(x, test::detail::tracker.count_allocations);
}
for (typename Values::const_iterator it = v.begin(); it != v.end(); template <typename T, typename Iterator>
++it) { void track(T& tracker, Iterator begin, Iterator end)
x[it->first] = it->second; {
for (; begin != end; ++begin) {
DISABLE_EXCEPTIONS; tracker[begin->first] = begin->second;
tracker[it->first] = it->second;
} }
} catch (...) {
test::check_equivalent_keys(x);
throw;
} }
};
test::check_equivalent_keys(x); struct map_insert_operator_type : map_inserter_base
tracker.compare(x);
}
template <typename T>
void insert_operator_exception_test(T*, test::random_generator gen)
{ {
for (int i = 0; i < 5; ++i) { template <typename T, typename Iterator> void operator()(T& x, Iterator it)
test::random_values<T> v(10, gen); {
T x; x[it->first] = it->second;
EXCEPTION_LOOP(insert_operator_exception_test_impl(x, v));
} }
} } map_insert_operator;
// clang-format off // clang-format off
UNORDERED_TEST(insert_operator_exception_test, UNORDERED_TEST(insert_exception_test,
((test_map_)) ((test_map_))
((map_insert_operator))
((default_generator)(limited_range)(generate_collisions))
)
UNORDERED_TEST(insert_rehash_exception_test,
((test_map_))
((map_insert_operator))
((default_generator)(limited_range)(generate_collisions)) ((default_generator)(limited_range)(generate_collisions))
) )
// clang-format on // clang-format on
@ -351,18 +368,9 @@ void insert_range_exception_test(T*, test::random_generator gen)
template <typename T> template <typename T>
void insert_range_rehash_exception_test(T*, test::random_generator gen) void insert_range_rehash_exception_test(T*, test::random_generator gen)
{ {
using namespace std;
typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
T x; T x;
x.max_load_factor(0.25); rehash_prep(x);
size_type bucket_count = x.bucket_count();
size_type initial_elements = static_cast<size_type>(
ceil((double)bucket_count * (double)x.max_load_factor()) - 1);
test::random_values<T> v(initial_elements);
x.insert(v.begin(), v.end());
BOOST_TEST(bucket_count == x.bucket_count());
test::random_values<T> v2(5, gen); test::random_values<T> v2(5, gen);
EXCEPTION_LOOP(insert_range_exception_test_impl(x, v2)); EXCEPTION_LOOP(insert_range_exception_test_impl(x, v2));