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

Use streams from lightweight test

Browse Source
This commit is contained in:
Daniel James
2017-05-10 19:02:47 +01:00
parent 3c42138e45
commit 76e7322262
22 changed files with 163 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test/exception/insert_exception_tests.cpp
View File

@ -3,7 +3,6 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include "./containers.hpp"
#include <iostream>
#include "../helpers/helpers.hpp"
#include "../helpers/invariants.hpp"

1
test/exception/move_assign_exception_tests.cpp
View File

@ -8,7 +8,6 @@
#include "../helpers/invariants.hpp"
#include "../helpers/random_values.hpp"
#include "../helpers/tracker.hpp"
#include <iostream>
#if defined(BOOST_MSVC)
#pragma warning( \

2
test/exception/rehash_exception_tests.cpp
View File

@ -11,8 +11,6 @@
#include "../helpers/tracker.hpp"
#include <string>
#include <iostream>
test::seed_t initialize_seed(3298597);
template <class T> struct rehash_test_base : public test::exception_base

1
test/helpers/count.hpp
View File

@ -7,7 +7,6 @@
#define BOOST_UNORDERED_TEST_HELPERS_COUNT_HEAD
#include <boost/detail/lightweight_test.hpp>
#include <iostream>
namespace test {
struct object_count

32
test/helpers/test.hpp
View File

@ -9,7 +9,6 @@
#include <boost/detail/lightweight_test.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <iostream>
#define UNORDERED_AUTO_TEST(x) \
struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base \
@ -69,10 +68,10 @@ static inline void add_test(registered_test_base* test)
static inline void run_tests()
{
for (registered_test_base* i = first(); i; i = i->next) {
std::cout << "Running " << i->name << "\n" << std::flush;
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Running " << i->name << "\n"
<< std::flush;
i->run();
std::cerr << std::flush;
std::cout << std::flush;
BOOST_LIGHTWEIGHT_TEST_OSTREAM << std::flush;
}
}
}
@ -86,18 +85,19 @@ static inline void run_tests()
#define BOOST_UNORDERED_TEST_COMPILER_INFO() \
{ \
std::cout << "Compiler: " << BOOST_COMPILER << "\n" \
<< "Library: " << BOOST_STDLIB << "\n" \
<< "__cplusplus: " << BOOST_UNORDERED_CPLUSPLUS << "\n\n" \
<< "BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT: " \
<< BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT << "\n" \
<< "BOOST_UNORDERED_EMPLACE_LIMIT: " \
<< BOOST_UNORDERED_EMPLACE_LIMIT << "\n" \
<< "BOOST_UNORDERED_USE_ALLOCATOR_TRAITS: " \
<< BOOST_UNORDERED_USE_ALLOCATOR_TRAITS << "\n" \
<< "BOOST_UNORDERED_CXX11_CONSTRUCTION: " \
<< BOOST_UNORDERED_CXX11_CONSTRUCTION << "\n\n" \
<< std::flush; \
BOOST_LIGHTWEIGHT_TEST_OSTREAM \
<< "Compiler: " << BOOST_COMPILER << "\n" \
<< "Library: " << BOOST_STDLIB << "\n" \
<< "__cplusplus: " << BOOST_UNORDERED_CPLUSPLUS << "\n\n" \
<< "BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT: " \
<< BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT << "\n" \
<< "BOOST_UNORDERED_EMPLACE_LIMIT: " \
<< BOOST_UNORDERED_EMPLACE_LIMIT << "\n" \
<< "BOOST_UNORDERED_USE_ALLOCATOR_TRAITS: " \
<< BOOST_UNORDERED_USE_ALLOCATOR_TRAITS << "\n" \
<< "BOOST_UNORDERED_CXX11_CONSTRUCTION: " \
<< BOOST_UNORDERED_CXX11_CONSTRUCTION << "\n\n" \
<< std::flush; \
}
#include <boost/preprocessor/cat.hpp>

1
test/objects/exception.hpp
View File

@ -15,7 +15,6 @@
#include "./fwd.hpp"
#include <boost/limits.hpp>
#include <cstddef>
#include <iostream>
#include <new>
namespace test {

22
test/unordered/assign_tests.cpp
View File

@ -17,8 +17,6 @@
#include "../helpers/tracker.hpp"
#include "../helpers/equivalent.hpp"
#include <iostream>
#if defined(BOOST_MSVC)
#pragma warning(disable : 4127) // conditional expression is constant
#endif
@ -32,7 +30,7 @@ template <class T> void assign_tests1(T*, test::random_generator generator)
BOOST_DEDUCED_TYPENAME T::hasher hf;
BOOST_DEDUCED_TYPENAME T::key_equal eq;
std::cerr << "assign_tests1.1\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests1.1\n";
{
test::check_instances check_;
@ -43,7 +41,7 @@ template <class T> void assign_tests1(T*, test::random_generator generator)
BOOST_TEST(test::equivalent(x.key_eq(), eq));
}
std::cerr << "assign_tests1.2\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests1.2\n";
{
test::check_instances check_;
@ -79,7 +77,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
std::cerr << "assign_tests2.0 - empty container\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.0 - empty container\n";
{
test::check_instances check_;
@ -93,7 +91,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
test::check_container(x1, x2);
}
std::cerr << "assign_tests2.1\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.1\n";
{
test::check_instances check_;
@ -110,7 +108,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
}
std::cerr << "assign_tests2.1a\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.1a\n";
{
test::check_instances check_;
@ -128,7 +126,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
}
std::cerr << "assign_tests2.2\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.2\n";
{
test::check_instances check_;
@ -150,7 +148,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
}
std::cerr << "assign_tests2.3\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.3\n";
{
test::check_instances check_;
@ -172,7 +170,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
}
std::cerr << "assign_tests2.4\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.4\n";
{
test::check_instances check_;
@ -271,7 +269,7 @@ UNORDERED_TEST(
UNORDERED_AUTO_TEST(assign_default_initializer_list)
{
std::cerr << "Initializer List Tests\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
std::initializer_list<std::pair<int const, int> > init;
boost::unordered_map<int, int> x1;
x1[25] = 3;
@ -286,7 +284,7 @@ UNORDERED_AUTO_TEST(assign_default_initializer_list)
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
UNORDERED_AUTO_TEST(assign_initializer_list)
{
std::cerr << "Initializer List Tests\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
boost::unordered_set<int> x;
x.insert(10);

3
test/unordered/bucket_tests.cpp
View File

@ -37,7 +37,8 @@ template <class X> void tests(X*, test::random_generator generator)
BOOST_TEST(x.bucket_count() <= x.max_bucket_count());
if (!(x.bucket_count() <= x.max_bucket_count())) {
std::cerr << x.bucket_count() << "<=" << x.max_bucket_count() << "\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << x.bucket_count()
<< "<=" << x.max_bucket_count() << "\n";
}
for (BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator

13
test/unordered/compile_map.cpp
View File

@ -12,7 +12,6 @@
#include "../helpers/postfix.hpp"
// clang-format on
#include <iostream>
#include "../helpers/test.hpp"
#include "../objects/minimal.hpp"
#include "./compile_tests.hpp"
@ -46,7 +45,7 @@ UNORDERED_AUTO_TEST(test0)
value_type;
value_type value(x, x);
std::cout << "Test unordered_map.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
boost::unordered_map<int, int> int_map;
@ -64,7 +63,7 @@ UNORDERED_AUTO_TEST(test0)
container_test(int_map2, std::pair<int const, int>(0, 0));
container_test(map, value);
std::cout << "Test unordered_multimap.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
boost::unordered_multimap<int, int> int_multimap;
@ -139,7 +138,7 @@ UNORDERED_AUTO_TEST(test1)
int value = 0;
std::pair<int const, int> map_value(0, 0);
std::cout << "Test unordered_map.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
boost::unordered_map<int, int> map;
@ -157,7 +156,7 @@ UNORDERED_AUTO_TEST(test1)
unordered_copyable_test(map2, value, map_value, hash, equal_to);
unordered_map_functions(map2, value, value);
std::cout << "Test unordered_multimap.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
boost::unordered_multimap<int, int> multimap;
@ -188,7 +187,7 @@ UNORDERED_AUTO_TEST(test2)
map_value_type;
map_value_type map_value(assignable, assignable);
std::cout << "Test unordered_map.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
boost::unordered_map<test::minimal::assignable, test::minimal::assignable,
test::minimal::hash<test::minimal::assignable>,
@ -212,7 +211,7 @@ UNORDERED_AUTO_TEST(test2)
unordered_map_functions(map2, assignable, default_assignable);
std::cout << "Test unordered_multimap.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
boost::unordered_multimap<test::minimal::assignable,
test::minimal::assignable,

25
test/unordered/compile_set.cpp
View File

@ -12,7 +12,6 @@
#include "../helpers/postfix.hpp"
// clang-format on
#include <iostream>
#include "../helpers/test.hpp"
#include "../objects/minimal.hpp"
#include "./compile_tests.hpp"
@ -42,7 +41,7 @@ UNORDERED_AUTO_TEST(test0)
test::minimal::assignable assignable(x);
std::cout << "Test unordered_set.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
boost::unordered_set<int> int_set;
@ -60,7 +59,7 @@ UNORDERED_AUTO_TEST(test0)
container_test(int_set2, 0);
container_test(set, assignable);
std::cout << "Test unordered_multiset.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
boost::unordered_multiset<int> int_multiset;
@ -128,7 +127,7 @@ UNORDERED_AUTO_TEST(test1)
std::equal_to<int> equal_to;
int value = 0;
std::cout << "Test unordered_set." << std::endl;
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set." << std::endl;
boost::unordered_set<int> set;
@ -144,7 +143,7 @@ UNORDERED_AUTO_TEST(test1)
unordered_set_test(set2, value);
unordered_copyable_test(set2, value, value, hash, equal_to);
std::cout << "Test unordered_multiset." << std::endl;
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset." << std::endl;
boost::unordered_multiset<int> multiset;
@ -170,7 +169,7 @@ UNORDERED_AUTO_TEST(test2)
test::minimal::hash<test::minimal::assignable> hash(x);
test::minimal::equal_to<test::minimal::assignable> equal_to(x);
std::cout << "Test unordered_set.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
boost::unordered_set<test::minimal::assignable,
test::minimal::hash<test::minimal::assignable>,
@ -183,7 +182,7 @@ UNORDERED_AUTO_TEST(test2)
unordered_copyable_test(set, assignable, assignable, hash, equal_to);
unordered_set_member_test(set, assignable);
std::cout << "Test unordered_multiset.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
boost::unordered_multiset<test::minimal::assignable,
test::minimal::hash<test::minimal::assignable>,
@ -205,7 +204,7 @@ UNORDERED_AUTO_TEST(movable1_tests)
test::minimal::hash<test::minimal::movable1> hash(x);
test::minimal::equal_to<test::minimal::movable1> equal_to(x);
std::cout << "Test unordered_set.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
boost::unordered_set<test::minimal::movable1,
test::minimal::hash<test::minimal::movable1>,
@ -217,7 +216,7 @@ UNORDERED_AUTO_TEST(movable1_tests)
unordered_set_test(set, movable1);
unordered_movable_test(set, movable1, movable1, hash, equal_to);
std::cout << "Test unordered_multiset.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
boost::unordered_multiset<test::minimal::movable1,
test::minimal::hash<test::minimal::movable1>,
@ -238,7 +237,7 @@ UNORDERED_AUTO_TEST(movable2_tests)
test::minimal::hash<test::minimal::movable2> hash(x);
test::minimal::equal_to<test::minimal::movable2> equal_to(x);
std::cout << "Test unordered_set.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
boost::unordered_set<test::minimal::movable2,
test::minimal::hash<test::minimal::movable2>,
@ -250,7 +249,7 @@ UNORDERED_AUTO_TEST(movable2_tests)
unordered_set_test(set, movable2);
unordered_movable_test(set, movable2, movable2, hash, equal_to);
std::cout << "Test unordered_multiset.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
boost::unordered_multiset<test::minimal::movable2,
test::minimal::hash<test::minimal::movable2>,
@ -271,7 +270,7 @@ UNORDERED_AUTO_TEST(destructible_tests)
test::minimal::hash<test::minimal::destructible> hash(x);
test::minimal::equal_to<test::minimal::destructible> equal_to(x);
std::cout << "Test unordered_set.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
boost::unordered_set<test::minimal::destructible,
test::minimal::hash<test::minimal::destructible>,
@ -280,7 +279,7 @@ UNORDERED_AUTO_TEST(destructible_tests)
unordered_destructible_test(set);
std::cout << "Test unordered_multiset.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
boost::unordered_multiset<test::minimal::destructible,
test::minimal::hash<test::minimal::destructible>,

58
test/unordered/constructor_tests.cpp
View File

@ -28,7 +28,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
BOOST_DEDUCED_TYPENAME T::key_equal eq;
BOOST_DEDUCED_TYPENAME T::allocator_type al;
std::cerr << "Construct 1\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 1\n";
{
test::check_instances check_;
@ -40,7 +40,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 2\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 2\n";
{
test::check_instances check_;
@ -53,7 +53,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 3\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 3\n";
{
test::check_instances check_;
@ -66,7 +66,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 4\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 4\n";
{
test::check_instances check_;
@ -78,7 +78,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 5\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 5\n";
{
test::check_instances check_;
@ -92,7 +92,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 6\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 6\n";
{
test::check_instances check_;
@ -106,7 +106,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 7\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 7\n";
{
test::check_instances check_;
@ -120,7 +120,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 8\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 8\n";
{
test::check_instances check_;
@ -133,7 +133,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 9\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 9\n";
{
test::check_instances check_;
@ -145,7 +145,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 10\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 10\n";
{
test::check_instances check_;
@ -159,7 +159,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 11\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 11\n";
{
test::check_instances check_;
@ -185,7 +185,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
std::cerr << "Construct 1\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 1\n";
{
test::check_instances check_;
T x(10000, hf1, eq1);
@ -196,7 +196,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 2\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 2\n";
{
test::check_instances check_;
T x(100, hf1);
@ -208,7 +208,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 3\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 3\n";
{
test::check_instances check_;
test::random_values<T> v(100, generator);
@ -220,7 +220,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 4\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 4\n";
{
test::check_instances check_;
test::random_values<T> v(5, generator);
@ -233,7 +233,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
test::check_equivalent_keys(x);
}
std::cerr << "Construct 5\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 5\n";
{
test::check_instances check_;
test::random_values<T> v(100, generator);
@ -245,7 +245,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
test::check_equivalent_keys(y);
}
std::cerr << "Construct 6\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 6\n";
{
test::check_instances check_;
test::random_values<T> v(100, generator);
@ -257,7 +257,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
test::check_equivalent_keys(y);
}
std::cerr << "Construct 7\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 7\n";
{
test::check_instances check_;
test::random_values<T> v(100, generator);
@ -269,7 +269,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
test::check_equivalent_keys(y);
}
std::cerr << "Construct 8 - from input iterator\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 8 - from input iterator\n";
{
test::check_instances check_;
test::random_values<T> v(100, generator);
@ -288,7 +288,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
test::check_equivalent_keys(y);
}
std::cerr << "Construct 8.5 - from copy iterator\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 8.5 - from copy iterator\n";
{
test::check_instances check_;
test::random_values<T> v(100, generator);
@ -302,7 +302,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
test::check_equivalent_keys(y);
}
std::cerr << "Construct 9\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 9\n";
{
test::check_instances check_;
@ -320,7 +320,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
std::initializer_list<BOOST_DEDUCED_TYPENAME T::value_type> list;
std::cerr << "Initializer list construct 1\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 1\n";
{
test::check_instances check_;
@ -331,7 +331,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
BOOST_TEST(test::equivalent(x.get_allocator(), al));
}
std::cerr << "Initializer list construct 2\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 2\n";
{
test::check_instances check_;
@ -343,7 +343,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
BOOST_TEST(test::equivalent(x.get_allocator(), al));
}
std::cerr << "Initializer list construct 3\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 3\n";
{
test::check_instances check_;
@ -355,7 +355,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
BOOST_TEST(test::equivalent(x.get_allocator(), al));
}
std::cerr << "Initializer list construct 4\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 4\n";
{
test::check_instances check_;
@ -367,7 +367,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
BOOST_TEST(test::equivalent(x.get_allocator(), al));
}
std::cerr << "Initializer list construct 5\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 5\n";
{
test::check_instances check_;
@ -384,7 +384,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
template <class T>
void map_constructor_test(T*, test::random_generator const& generator)
{
std::cerr << "map_constructor_test\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "map_constructor_test\n";
typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME T::key_type,
BOOST_DEDUCED_TYPENAME T::mapped_type> >
@ -429,7 +429,7 @@ UNORDERED_TEST(map_constructor_test,
UNORDERED_AUTO_TEST(test_default_initializer_list)
{
std::cerr << "Initializer List Tests\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
std::initializer_list<int> init;
boost::unordered_set<int> x1 = init;
BOOST_TEST(x1.empty());
@ -441,7 +441,7 @@ UNORDERED_AUTO_TEST(test_default_initializer_list)
UNORDERED_AUTO_TEST(test_initializer_list)
{
std::cerr << "Initializer List Tests\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
boost::unordered_set<int> x1 = {2, 10, 45, -5};
BOOST_TEST(x1.find(10) != x1.end());
BOOST_TEST(x1.find(46) == x1.end());

2
test/unordered/detail_tests.cpp
View File

@ -3,8 +3,6 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
// clang-format off
#include "../helpers/prefix.hpp"
#include <boost/unordered_map.hpp>

2
test/unordered/equivalent_keys_tests.cpp
View File

@ -17,8 +17,6 @@
#include "../helpers/tracker.hpp"
#include "../helpers/invariants.hpp"
#include <iostream>
template <class Container, class Iterator>
void test_equal_insertion(Iterator begin, Iterator end)
{

25
test/unordered/erase_equiv_tests.cpp
View File

@ -17,7 +17,6 @@
#include "../helpers/invariants.hpp"
#include "../helpers/helpers.hpp"
#include <set>
#include <iostream>
#include <iterator>
#include "../objects/test.hpp"
@ -31,14 +30,15 @@ struct write_pair_type
template <class X1, class X2>
void operator()(std::pair<X1, X2> const& x) const
{
std::cout << "(" << x.first << "," << x.second << ")";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "(" << x.first << "," << x.second
<< ")";
}
} write_pair;
template <class Container> void write_container(Container const& x)
{
std::for_each(x.begin(), x.end(), write_pair);
std::cout << "\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
}
// Make everything collide - for testing erase in a single bucket.
@ -165,8 +165,8 @@ template <class Container> void erase_subrange_tests(Container const& x)
collide_list init(y.begin(), y.end());
if (!general_erase_range_test(y, position, position + length)) {
BOOST_ERROR("general_erase_range_test failed.");
std::cout << "Erase: [" << position << "," << position + length
<< ")\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Erase: [" << position << ","
<< position + length << ")\n";
write_container(init);
write_container(y);
}
@ -185,7 +185,8 @@ void x_by_y_erase_range_tests(Container*, int values, int duplicates)
}
}
std::cout << "Values: " << values << ", Duplicates: " << duplicates << "\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Values: " << values
<< ", Duplicates: " << duplicates << "\n";
erase_subrange_tests(y);
}
@ -201,24 +202,24 @@ void exhaustive_erase_tests(Container* x, int num_values, int num_duplicated)
UNORDERED_AUTO_TEST(exhaustive_collide_tests)
{
std::cout << "exhaustive_collide_tests:\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide_tests:\n";
collide_map m;
exhaustive_erase_tests((collide_map*)0, 4, 4);
std::cout << "\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
}
UNORDERED_AUTO_TEST(exhaustive_collide2_tests)
{
std::cout << "exhaustive_collide2_tests:\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide2_tests:\n";
exhaustive_erase_tests((collide_map2*)0, 8, 4);
std::cout << "\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
}
UNORDERED_AUTO_TEST(exhaustive_collide3_tests)
{
std::cout << "exhaustive_collide3_tests:\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide3_tests:\n";
exhaustive_erase_tests((collide_map3*)0, 8, 4);
std::cout << "\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
}
RUN_TESTS()

25
test/unordered/erase_tests.cpp
View File

@ -18,7 +18,6 @@
#include "../helpers/helpers.hpp"
#include "../helpers/invariants.hpp"
#include <vector>
#include <iostream>
#include <cstdlib>
namespace erase_tests {
@ -31,7 +30,7 @@ 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";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Erase by key.\n";
{
test::check_instances check_;
@ -52,7 +51,7 @@ void erase_tests1(Container*, test::random_generator generator)
}
}
std::cerr << "erase(begin()).\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(begin()).\n";
{
test::check_instances check_;
@ -75,7 +74,7 @@ void erase_tests1(Container*, test::random_generator generator)
BOOST_TEST(x.empty());
}
std::cerr << "erase(random position).\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(random position).\n";
{
test::check_instances check_;
@ -104,7 +103,8 @@ void erase_tests1(Container*, test::random_generator generator)
index == 0 ? next == x.begin() : next == test::next(prev));
BOOST_TEST(x.count(key) == count - 1);
if (x.count(key) != count - 1) {
std::cerr << count << " => " << x.count(key) << std::endl;
BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => "
<< x.count(key) << std::endl;
}
BOOST_TEST(x.size() == size);
if (++iterations % 20 == 0)
@ -113,7 +113,7 @@ void erase_tests1(Container*, test::random_generator generator)
BOOST_TEST(x.empty());
}
std::cerr << "erase(ranges).\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(ranges).\n";
{
test::check_instances check_;
@ -140,7 +140,7 @@ void erase_tests1(Container*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "erase(random ranges).\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(random ranges).\n";
{
test::check_instances check_;
Container x;
@ -179,7 +179,7 @@ void erase_tests1(Container*, test::random_generator generator)
}
}
std::cerr << "quick_erase(begin()).\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "quick_erase(begin()).\n";
{
test::check_instances check_;
@ -201,7 +201,7 @@ void erase_tests1(Container*, test::random_generator generator)
BOOST_TEST(x.empty());
}
std::cerr << "quick_erase(random position).\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "quick_erase(random position).\n";
{
test::check_instances check_;
@ -230,7 +230,8 @@ void erase_tests1(Container*, test::random_generator generator)
index == 0 ? next == x.begin() : next == test::next(prev));
BOOST_TEST(x.count(key) == count - 1);
if (x.count(key) != count - 1) {
std::cerr << count << " => " << x.count(key) << std::endl;
BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => "
<< x.count(key) << std::endl;
}
BOOST_TEST(x.size() == size);
if (++iterations % 20 == 0)
@ -239,7 +240,7 @@ void erase_tests1(Container*, test::random_generator generator)
BOOST_TEST(x.empty());
}
std::cerr << "clear().\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "clear().\n";
{
test::check_instances check_;
@ -250,7 +251,7 @@ void erase_tests1(Container*, test::random_generator generator)
BOOST_TEST(x.begin() == x.end());
}
std::cerr << "\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
}
boost::unordered_set<test::object, test::hash, test::equal_to,

10
test/unordered/extract_tests.cpp
View File

@ -19,8 +19,6 @@
#include "../objects/test.hpp"
#include <boost/next_prior.hpp>
#include <iostream>
namespace extract_tests {
test::seed_t initialize_seed(85638);
@ -28,7 +26,7 @@ test::seed_t initialize_seed(85638);
template <class Container>
void extract_tests1(Container*, test::random_generator generator)
{
std::cerr << "Extract by key.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Extract by key.\n";
{
test::check_instances check_;
@ -58,7 +56,7 @@ void extract_tests1(Container*, test::random_generator generator)
BOOST_TEST(x.empty());
}
std::cerr << "extract(begin()).\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "extract(begin()).\n";
{
test::check_instances check_;
@ -81,7 +79,7 @@ void extract_tests1(Container*, test::random_generator generator)
BOOST_TEST(x.empty());
}
std::cerr << "extract(random position).\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "extract(random position).\n";
{
test::check_instances check_;
@ -117,7 +115,7 @@ void extract_tests1(Container*, test::random_generator generator)
BOOST_TEST(x.empty());
}
std::cerr << "\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
}
boost::unordered_set<test::object, test::hash, test::equal_to,

1
test/unordered/insert_hint_tests.cpp
View File

@ -15,7 +15,6 @@
#include <map>
#include <set>
#include <iostream>
namespace insert_hint {
UNORDERED_AUTO_TEST(insert_hint_empty)

2
test/unordered/insert_stable_tests.cpp
View File

@ -12,8 +12,6 @@
#include "../helpers/test.hpp"
#include <iostream>
namespace insert_stable {
struct member
{

69
test/unordered/insert_tests.cpp
View File

@ -21,8 +21,6 @@
#include "../helpers/input_iterator.hpp"
#include "../helpers/helpers.hpp"
#include <iostream>
namespace insert_tests {
test::seed_t initialize_seed(243432);
@ -35,7 +33,8 @@ void unique_insert_tests1(X*, test::random_generator generator)
typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
typedef test::ordered<X> ordered;
std::cerr << "insert(value) tests for containers with unique keys.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM
<< "insert(value) tests for containers with unique keys.\n";
{
X x;
@ -68,7 +67,8 @@ void unique_insert_tests1(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert(rvalue) tests for containers with unique keys.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM
<< "insert(rvalue) tests for containers with unique keys.\n";
{
X x;
@ -108,7 +108,8 @@ void equivalent_insert_tests1(X*, test::random_generator generator)
{
test::check_instances check_;
std::cerr << "insert(value) tests for containers with equivalent keys.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM
<< "insert(value) tests for containers with equivalent keys.\n";
{
X x;
@ -138,7 +139,8 @@ void equivalent_insert_tests1(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert(rvalue) tests for containers with equivalent keys.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM
<< "insert(rvalue) tests for containers with equivalent keys.\n";
{
X x;
@ -178,7 +180,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
typedef BOOST_DEDUCED_TYPENAME tracker_type::iterator tracker_iterator;
std::cerr << "insert(begin(), value) tests.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(begin(), value) tests.\n";
{
test::check_instances check_;
@ -208,7 +210,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert(end(), value) tests.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(end(), value) tests.\n";
{
test::check_instances check_;
@ -239,7 +241,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert(pos, value) tests.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(pos, value) tests.\n";
{
test::check_instances check_;
@ -270,7 +272,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert(pos, rvalue) tests.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(pos, rvalue) tests.\n";
{
test::check_instances check_;
@ -302,7 +304,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert single item range tests.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert single item range tests.\n";
{
test::check_instances check_;
@ -331,7 +333,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert range tests.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert range tests.\n";
{
test::check_instances check_;
@ -345,7 +347,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert range with rehash tests.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert range with rehash tests.\n";
{
test::check_instances check_;
@ -363,7 +365,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert input iterator range tests.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert input iterator range tests.\n";
{
test::check_instances check_;
@ -380,7 +382,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert copy iterator range tests.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert copy iterator range tests.\n";
{
test::check_instances check_;
@ -394,7 +396,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert copy iterator range test 2.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert copy iterator range test 2.\n";
{
test::check_instances check_;
@ -411,7 +413,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert various ranges.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert various ranges.\n";
{
for (int i = 0; i < 100; ++i) {
@ -458,7 +460,8 @@ void unique_emplace_tests1(X*, test::random_generator generator)
typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
typedef test::ordered<X> ordered;
std::cerr << "emplace(value) tests for containers with unique keys.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM
<< "emplace(value) tests for containers with unique keys.\n";
X x;
test::ordered<X> tracker = test::create_ordered(x);
@ -492,7 +495,8 @@ void unique_emplace_tests1(X*, test::random_generator generator)
template <class X>
void equivalent_emplace_tests1(X*, test::random_generator generator)
{
std::cerr << "emplace(value) tests for containers with equivalent keys.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM
<< "emplace(value) tests for containers with equivalent keys.\n";
X x;
test::ordered<X> tracker = test::create_ordered(x);
@ -522,7 +526,7 @@ void equivalent_emplace_tests1(X*, test::random_generator generator)
template <class X> void move_emplace_tests(X*, test::random_generator generator)
{
std::cerr
BOOST_LIGHTWEIGHT_TEST_OSTREAM
<< "emplace(move(value)) tests for containers with unique keys.\n";
X x;
@ -553,7 +557,7 @@ template <class X> void move_emplace_tests(X*, test::random_generator generator)
template <class X> void default_emplace_tests(X*, test::random_generator)
{
#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
std::cerr << "emplace() tests.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "emplace() tests.\n";
bool is_unique = test::has_unique_keys<X>::value;
X x;
@ -588,7 +592,7 @@ template <class X> void default_emplace_tests(X*, test::random_generator)
template <class X> void map_tests(X*, test::random_generator generator)
{
std::cerr << "map tests.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "map tests.\n";
X x;
test::ordered<X> tracker = test::create_ordered(x);
@ -616,7 +620,7 @@ template <class X> void map_tests(X*, test::random_generator generator)
template <class X> void map_tests2(X*, test::random_generator generator)
{
typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
std::cerr << "insert_or_assign\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign\n";
{
test::check_instances check_;
@ -648,7 +652,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert_or_assign(begin)\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign(begin)\n";
{
test::check_instances check_;
@ -679,7 +683,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert_or_assign(end)\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign(end)\n";
{
test::check_instances check_;
@ -710,7 +714,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "insert_or_assign(last)\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign(last)\n";
{
test::check_instances check_;
@ -747,7 +751,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
template <class X> void try_emplace_tests(X*, test::random_generator generator)
{
std::cerr << "try_emplace(key, value)\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(key, value)\n";
typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
@ -790,7 +794,7 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "try_emplace(begin(), key, value)\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(begin(), key, value)\n";
typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
@ -830,7 +834,7 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "try_emplace(end(), key, value)\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(end(), key, value)\n";
typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
@ -870,7 +874,7 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
test::check_equivalent_keys(x);
}
std::cerr << "try_emplace(pos, key, value)\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(pos, key, value)\n";
typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
@ -916,7 +920,7 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
template <class X>
void map_insert_range_test1(X*, test::random_generator generator)
{
std::cerr << "map_insert_range_test1\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "map_insert_range_test1\n";
test::check_instances check_;
@ -935,7 +939,7 @@ void map_insert_range_test1(X*, test::random_generator generator)
template <class X>
void map_insert_range_test2(X*, test::random_generator generator)
{
std::cerr << "map_insert_range_test2\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "map_insert_range_test2\n";
test::check_instances check_;
@ -1391,7 +1395,6 @@ UNORDERED_AUTO_TEST(set_emplace_test2)
#include "./insert_tests.cpp"
#endif
}
RUN_TESTS()

3
test/unordered/noexcept_tests.cpp
View File

@ -36,7 +36,8 @@ bool throwing_test_exception = false;
void test_throw(char const* name)
{
if (throwing_test_exception) {
std::cerr << "Throw exception in: " << name << std::endl;
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Throw exception in: " << name
<< std::endl;
throw test_exception();
}
}

8
test/unordered/simple_tests.cpp
View File

@ -93,7 +93,7 @@ UNORDERED_AUTO_TEST(simple_tests)
using namespace std;
srand(14878);
std::cout << "Test unordered_set.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
boost::unordered_set<int> set;
simple_test(set);
@ -102,7 +102,7 @@ UNORDERED_AUTO_TEST(simple_tests)
set.insert(1456);
simple_test(set);
std::cout << "Test unordered_multiset.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
boost::unordered_multiset<int> multiset;
simple_test(multiset);
@ -113,7 +113,7 @@ UNORDERED_AUTO_TEST(simple_tests)
}
simple_test(multiset);
std::cout << "Test unordered_map.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
boost::unordered_map<int, int> map;
for (int i2 = 0; i2 < 1000; ++i2) {
@ -121,7 +121,7 @@ UNORDERED_AUTO_TEST(simple_tests)
}
simple_test(map);
std::cout << "Test unordered_multimap.\n";
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
boost::unordered_multimap<int, int> multimap;
for (int i3 = 0; i3 < 1000; ++i3) {

29
test/unordered/unnecessary_copy_tests.cpp
View File

@ -10,7 +10,6 @@
#include "../helpers/postfix.hpp"
// clang-format on
#include <iostream>
#include "../helpers/test.hpp"
namespace unnecessary_copy_tests {
@ -138,32 +137,36 @@ std::size_t hash_value(unnecessary_copy_tests::count_copies const& x)
#define COPY_COUNT(n) \
if (::unnecessary_copy_tests::count_copies::copies != n) { \
BOOST_ERROR("Wrong number of copies."); \
std::cerr << "Number of copies: " \
<< ::unnecessary_copy_tests::count_copies::copies \
<< " expecting: " << n << std::endl; \
BOOST_LIGHTWEIGHT_TEST_OSTREAM \
<< "Number of copies: " \
<< ::unnecessary_copy_tests::count_copies::copies \
<< " expecting: " << n << std::endl; \
}
#define MOVE_COUNT(n) \
if (::unnecessary_copy_tests::count_copies::moves != n) { \
BOOST_ERROR("Wrong number of moves."); \
std::cerr << "Number of moves: " \
<< ::unnecessary_copy_tests::count_copies::moves \
<< " expecting: " << n << std::endl; \
BOOST_LIGHTWEIGHT_TEST_OSTREAM \
<< "Number of moves: " \
<< ::unnecessary_copy_tests::count_copies::moves \
<< " expecting: " << n << std::endl; \
}
#define COPY_COUNT_RANGE(a, b) \
if (::unnecessary_copy_tests::count_copies::copies < a || \
::unnecessary_copy_tests::count_copies::copies > b) { \
BOOST_ERROR("Wrong number of copies."); \
std::cerr << "Number of copies: " \
<< ::unnecessary_copy_tests::count_copies::copies \
<< " expecting: [" << a << ", " << b << "]" << std::endl; \
BOOST_LIGHTWEIGHT_TEST_OSTREAM \
<< "Number of copies: " \
<< ::unnecessary_copy_tests::count_copies::copies \
<< " expecting: [" << a << ", " << b << "]" << std::endl; \
}
#define MOVE_COUNT_RANGE(a, b) \
if (::unnecessary_copy_tests::count_copies::moves < a || \
::unnecessary_copy_tests::count_copies::moves > b) { \
BOOST_ERROR("Wrong number of moves."); \
std::cerr << "Number of moves: " \
<< ::unnecessary_copy_tests::count_copies::moves \
<< " expecting: [" << a << ", " << b << "]" << std::endl; \
BOOST_LIGHTWEIGHT_TEST_OSTREAM \
<< "Number of moves: " \
<< ::unnecessary_copy_tests::count_copies::moves \
<< " expecting: [" << a << ", " << b << "]" << std::endl; \
}
#define COPY_COUNT_EXTRA(a, b) COPY_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)
#define MOVE_COUNT_EXTRA(a, b) MOVE_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)