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

Reformat with clang-format

Browse Source
This commit is contained in:
Daniel James
2017-02-19 13:05:17 +00:00
parent 01dcd36c41
commit bf5ef9824d
70 changed files with 13000 additions and 13625 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
test/exception/insert_exception_tests.cpp
View File

@@ -5,51 +5,52 @@
#include "./containers.hpp"
#include <string>
#include "../helpers/random_values.hpp"
#include "../helpers/invariants.hpp"
#include "../helpers/strong.hpp"
#include "../helpers/helpers.hpp"
#include "../helpers/invariants.hpp"
#include "../helpers/random_values.hpp"
#include "../helpers/strong.hpp"
#include <cmath>
#include <string>
test::seed_t initialize_seed(747373);
template <class T>
struct insert_test_base : public test::exception_base
template <class T> struct insert_test_base : public test::exception_base
{
test::random_values<T> values;
insert_test_base(unsigned int count = 5) : values(count, test::limited_range) {}
insert_test_base(unsigned int count = 5)
: values(count, test::limited_range)
{
}
typedef T data_type;
typedef test::strong<T> strong_type;
data_type init() const {
return T();
}
data_type init() const { return T(); }
void check BOOST_PREVENT_MACRO_SUBSTITUTION(
T const& x, strong_type const& strong) const
{
std::string scope(test::scope);
if(scope.find("hash::operator()") == std::string::npos)
if (scope.find("hash::operator()") == std::string::npos)
strong.test(x, test::detail::tracker.count_allocations);
test::check_equivalent_keys(x);
}
};
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template <class T>
struct emplace_test1 : public insert_test_base<T>
template <class T> struct emplace_test1 : public insert_test_base<T>
{
typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
void run(T& x, strong_type& strong) const {
for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(), end = this->values.end();
it != end; ++it)
{
void run(T& x, strong_type& strong) const
{
for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(),
end = this->values.end();
it != end; ++it) {
strong.store(x, test::detail::tracker.count_allocations);
x.emplace(*it);
}
@@ -58,74 +59,72 @@ struct emplace_test1 : public insert_test_base<T>
#endif
template <class T>
struct insert_test1 : public insert_test_base<T>
template <class T> struct insert_test1 : public insert_test_base<T>
{
typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
void run(T& x, strong_type& strong) const {
for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(), end = this->values.end();
it != end; ++it)
{
void run(T& x, strong_type& strong) const
{
for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(),
end = this->values.end();
it != end; ++it) {
strong.store(x, test::detail::tracker.count_allocations);
x.insert(*it);
}
}
};
template <class T>
struct insert_test2 : public insert_test_base<T>
template <class T> struct insert_test2 : public insert_test_base<T>
{
typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
void run(T& x, strong_type& strong) const {
for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(), end = this->values.end();
it != end; ++it)
{
void run(T& x, strong_type& strong) const
{
for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(),
end = this->values.end();
it != end; ++it) {
strong.store(x, test::detail::tracker.count_allocations);
x.insert(x.begin(), *it);
}
}
};
template <class T>
struct insert_test3 : public insert_test_base<T>
template <class T> struct insert_test3 : public insert_test_base<T>
{
void run(T& x) const {
x.insert(this->values.begin(), this->values.end());
}
void run(T& x) const { x.insert(this->values.begin(), this->values.end()); }
void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
{
test::check_equivalent_keys(x);
}
};
template <class T>
struct insert_test4 : public insert_test_base<T>
template <class T> struct insert_test4 : public insert_test_base<T>
{
typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
void run(T& x, strong_type& strong) const {
for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(), end = this->values.end();
it != end; ++it)
{
void run(T& x, strong_type& strong) const
{
for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(),
end = this->values.end();
it != end; ++it) {
strong.store(x, test::detail::tracker.count_allocations);
x.insert(it, test::next(it));
}
}
};
template <class T>
struct insert_test_rehash1 : public insert_test_base<T>
template <class T> struct insert_test_rehash1 : public insert_test_base<T>
{
typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
insert_test_rehash1() : insert_test_base<T>(1000) {}
T init() const {
T init() const
{
using namespace std;
typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
@@ -134,24 +133,24 @@ struct insert_test_rehash1 : public insert_test_base<T>
// TODO: This doesn't really work is bucket_count is 0
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);
ceil((double)bucket_count * (double)x.max_load_factor()) - 1);
BOOST_TEST(initial_elements < this->values.size());
x.insert(this->values.begin(),
test::next(this->values.begin(), initial_elements));
test::next(this->values.begin(), initial_elements));
BOOST_TEST(bucket_count == x.bucket_count());
return x;
}
void run(T& x, strong_type& strong) const {
void run(T& x, strong_type& strong) const
{
BOOST_DEDUCED_TYPENAME T::size_type bucket_count = x.bucket_count();
int count = 0;
BOOST_DEDUCED_TYPENAME T::const_iterator pos = x.cbegin();
for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = test::next(this->values.begin(), x.size()),
end = this->values.end();
it != end && count < 10; ++it, ++count)
{
for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = test::next(this->values.begin(), x.size()),
end = this->values.end();
it != end && count < 10; ++it, ++count) {
strong.store(x, test::detail::tracker.count_allocations);
pos = x.insert(pos, *it);
}
@@ -162,20 +161,19 @@ struct insert_test_rehash1 : public insert_test_base<T>
}
};
template <class T>
struct insert_test_rehash2 : public insert_test_rehash1<T>
template <class T> struct insert_test_rehash2 : public insert_test_rehash1<T>
{
typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
void run(T& x, strong_type& strong) const {
void run(T& x, strong_type& strong) const
{
BOOST_DEDUCED_TYPENAME T::size_type bucket_count = x.bucket_count();
int count = 0;
for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = test::next(this->values.begin(), x.size()),
end = this->values.end();
it != end && count < 10; ++it, ++count)
{
for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = test::next(this->values.begin(), x.size()),
end = this->values.end();
it != end && count < 10; ++it, ++count) {
strong.store(x, test::detail::tracker.count_allocations);
x.insert(*it);
}
@@ -186,15 +184,15 @@ struct insert_test_rehash2 : public insert_test_rehash1<T>
}
};
template <class T>
struct insert_test_rehash3 : public insert_test_base<T>
template <class T> struct insert_test_rehash3 : public insert_test_base<T>
{
BOOST_DEDUCED_TYPENAME T::size_type mutable
rehash_bucket_count, original_bucket_count;
BOOST_DEDUCED_TYPENAME T::size_type mutable rehash_bucket_count,
original_bucket_count;
insert_test_rehash3() : insert_test_base<T>(1000) {}
T init() const {
T init() const
{
using namespace std;
typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
@@ -202,78 +200,82 @@ struct insert_test_rehash3 : public insert_test_base<T>
x.max_load_factor(0.25);
original_bucket_count = x.bucket_count();
rehash_bucket_count = static_cast<size_type>(
ceil((double) original_bucket_count * (double) x.max_load_factor())) - 1;
rehash_bucket_count =
static_cast<size_type>(ceil(
(double)original_bucket_count * (double)x.max_load_factor())) -
1;
size_type initial_elements =
rehash_bucket_count > 5 ? rehash_bucket_count - 5 : 1;
BOOST_TEST(initial_elements < this->values.size());
x.insert(this->values.begin(),
test::next(this->values.begin(), initial_elements));
test::next(this->values.begin(), initial_elements));
BOOST_TEST(original_bucket_count == x.bucket_count());
return x;
}
void run(T& x) const {
void run(T& x) const
{
BOOST_DEDUCED_TYPENAME T::size_type bucket_count = x.bucket_count();
x.insert(test::next(this->values.begin(), x.size()),
test::next(this->values.begin(), x.size() + 20));
test::next(this->values.begin(), x.size() + 20));
// This isn't actually a failure, but it means the test isn't doing its
// job.
BOOST_TEST(x.bucket_count() != bucket_count);
}
void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
if(x.size() < rehash_bucket_count) {
//BOOST_TEST(x.bucket_count() == original_bucket_count);
void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
{
if (x.size() < rehash_bucket_count) {
// BOOST_TEST(x.bucket_count() == original_bucket_count);
}
test::check_equivalent_keys(x);
}
};
#define BASIC_TESTS \
(insert_test1)(insert_test2)(insert_test3)(insert_test4) \
(insert_test_rehash1)(insert_test_rehash2)(insert_test_rehash3)
#define BASIC_TESTS \
(insert_test1)(insert_test2)(insert_test3)(insert_test4)( \
insert_test_rehash1)(insert_test_rehash2)(insert_test_rehash3)
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#define ALL_TESTS (emplace_test1)BASIC_TESTS
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#define ALL_TESTS (emplace_test1) BASIC_TESTS
#else
#define ALL_TESTS BASIC_TESTS
#endif
EXCEPTION_TESTS(ALL_TESTS, CONTAINER_SEQ)
template <class T>
struct pair_emplace_test1 : public insert_test_base<T>
template <class T> struct pair_emplace_test1 : public insert_test_base<T>
{
typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
void run(T& x, strong_type& strong) const {
for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(), end = this->values.end();
it != end; ++it)
{
void run(T& x, strong_type& strong) const
{
for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(),
end = this->values.end();
it != end; ++it) {
strong.store(x, test::detail::tracker.count_allocations);
x.emplace(boost::unordered::piecewise_construct,
boost::make_tuple(it->first),
boost::make_tuple(it->second));
boost::make_tuple(it->first), boost::make_tuple(it->second));
}
}
};
template <class T>
struct pair_emplace_test2 : public insert_test_base<T>
template <class T> struct pair_emplace_test2 : public insert_test_base<T>
{
typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
void run(T& x, strong_type& strong) const {
for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(), end = this->values.end();
it != end; ++it)
{
void run(T& x, strong_type& strong) const
{
for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(),
end = this->values.end();
it != end; ++it) {
strong.store(x, test::detail::tracker.count_allocations);
x.emplace(boost::unordered::piecewise_construct,
boost::make_tuple(it->first),
@@ -284,16 +286,16 @@ struct pair_emplace_test2 : public insert_test_base<T>
EXCEPTION_TESTS((pair_emplace_test1)(pair_emplace_test2), CONTAINER_PAIR_SEQ)
template <class T>
struct index_insert_test1 : public insert_test_base<T>
template <class T> struct index_insert_test1 : public insert_test_base<T>
{
typedef BOOST_DEDUCED_TYPENAME insert_test_base<T>::strong_type strong_type;
void run(T& x, strong_type& strong) const {
for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(), end = this->values.end();
it != end; ++it)
{
void run(T& x, strong_type& strong) const
{
for (BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
it = this->values.begin(),
end = this->values.end();
it != end; ++it) {
strong.store(x, test::detail::tracker.count_allocations);
x[it->first];
}