From e07e7e889dd22c7a070ed1dccd7240e8e0ed68da Mon Sep 17 00:00:00 2001 From: Daniel James Date: Mon, 24 Mar 2008 17:03:15 +0000 Subject: [PATCH] Merge new changes to unordered & hash. - Unordered tests can run lightweight test or Boost.Test (at least theoretically). - Workaround Open BSD's incorrect numeric_limits. - Move the hash extensions in their own file. - Various small improvements to the unordered docs. - Fix some unordered examples. Merged revisions 43117-43837 via svnmerge from https://svn.boost.org/svn/boost/branches/unordered/trunk [SVN r43838] --- doc/Jamfile.v2 | 13 ++- doc/comparison.qbk | 2 +- doc/hash_equality.qbk | 36 +++++---- doc/intro.qbk | 20 +---- doc/rationale.qbk | 2 +- .../{insensitive.cpp => dictionary.cpp} | 54 +++++++++---- doc/src_code/intro.cpp | 30 +++++++ doc/src_code/point1.cpp | 3 +- examples/hash_functions/fnv-1.hpp | 4 +- test/helpers/exception_test.hpp | 14 ++-- test/helpers/test.hpp | 81 ++++++++++++++++++- test/unordered/assign_tests.cpp | 44 +++++----- test/unordered/at_tests.cpp | 12 ++- test/unordered/bucket_tests.cpp | 19 +++-- test/unordered/compile_map.cpp | 18 ++--- test/unordered/compile_set.cpp | 16 ++-- test/unordered/constructor_tests.cpp | 67 +++++---------- test/unordered/copy_tests.cpp | 39 +++++---- test/unordered/equivalent_keys_tests.cpp | 14 +--- test/unordered/erase_equiv_tests.cpp | 24 ++---- test/unordered/erase_tests.cpp | 40 ++++----- test/unordered/find_tests.cpp | 32 ++++---- test/unordered/insert_stable_tests.cpp | 14 +--- test/unordered/insert_tests.cpp | 2 +- test/unordered/load_factor_tests.cpp | 29 ++++--- test/unordered/rehash_tests.cpp | 21 +++-- test/unordered/simple_tests.cpp | 8 +- test/unordered/swap_tests.cpp | 31 ++++--- test/unordered/unnecessary_copy_tests.cpp | 34 ++++---- 29 files changed, 399 insertions(+), 324 deletions(-) rename doc/src_code/{insensitive.cpp => dictionary.cpp} (57%) create mode 100644 doc/src_code/intro.cpp diff --git a/doc/Jamfile.v2 b/doc/Jamfile.v2 index 69761fde..83eb3016 100644 --- a/doc/Jamfile.v2 +++ b/doc/Jamfile.v2 @@ -12,4 +12,15 @@ boostbook standalone : unordered : chunk.section.depth=2 generate.section.toc.level=2 toc.section.depth=1 - toc.max.depth=1 ; + toc.max.depth=1 + + css + images + ; + +install css : [ glob $(BOOST_ROOT)/doc/src/*.css ] + : html ; +install images : [ glob $(BOOST_ROOT)/doc/src/images/*.png ] + : html/images ; +explicit css ; +explicit images ; diff --git a/doc/comparison.qbk b/doc/comparison.qbk index 689efd0f..d4abc604 100644 --- a/doc/comparison.qbk +++ b/doc/comparison.qbk @@ -83,7 +83,7 @@ ] [ [`erase` never throws an exception] - [The containers hash or predicate function can throw exceptions + [The containers' hash or predicate function can throw exceptions from `erase`] ] ] diff --git a/doc/hash_equality.qbk b/doc/hash_equality.qbk index 22e83573..bf454909 100644 --- a/doc/hash_equality.qbk +++ b/doc/hash_equality.qbk @@ -6,32 +6,35 @@ While the associative containers use an ordering relation to specify how the elements are stored, the unordered associative containers use an equality -predicate and a hash function. For example, [classref boost::unordered_set] +predicate and a hash function. For example, [classref boost::unordered_map] is declared as: - template, - typename Pred = std::equal_to, - typename Alloc = std::allocator > - class ``[classref boost::unordered_set unordered_set]``; + template < + class Key, class Mapped, + class Hash = ``[classref boost::hash]``, + class Pred = std::equal_to, + class Alloc = std::allocator > + class ``[classref boost::unordered_map unordered_map]``; The hash function comes first as you might want to change the hash function -but not the equality predicate, while if you were to change the behavior -of the equality predicate you would have to change the hash function to match -it. So, if you wanted to use the +but not the equality predicate. For example, if you wanted to use the [@http://www.isthe.com/chongo/tech/comp/fnv/ FNV-1 hash] you could write: - ``[classref boost::unordered_set]`` words; +[import src_code/dictionary.cpp] +[case_sensitive_dictionary_fnv] An example implementation of FNV-1, and some other hash functions are supplied in the examples directory. -Alternatively, you might wish to use a different equality function. If you do -this you will need to use a hash function that matches it. So to implement a -case-insensitive dictionary: +If you wish to use a different equality function, +you will also need to use a matching hash function. For +example, to implement a case insensitive dictionary you need to define a +case insensitive equality predicate and hash function: -[import src_code/insensitive.cpp] [case_insensitive_functions] + +Which you can then use in a case insensitive dictionary: + [case_insensitive_dictionary] This is a simplified version of the example at @@ -45,8 +48,9 @@ Similarly, a custom hash function can be used for custom types: [import src_code/point1.cpp] [point_example1] -Although, [link hash.custom extending boost::hash to support the type] is -probably a better solution: +Since the default hash function is [link hash Boost.Hash], +we can [link hash.custom extend it to support the type] +so that the hash function doesn't need to be explicitly given: [import src_code/point2.cpp] [point_example2] diff --git a/doc/intro.qbk b/doc/intro.qbk index 8d4476e0..23016445 100644 --- a/doc/intro.qbk +++ b/doc/intro.qbk @@ -84,32 +84,18 @@ When using Boost.TR1, these classes are included from `` and The containers are used in a similar manner to the normal associative containers: - #include <``[headerref boost/unordered_map.hpp]``> - #include - - int main() - { - boost::unordered_map x; - x["one"] = 1; - x["two"] = 2; - x["three"] = 3; - - assert(x["one"] == 1); - assert(x["missing"] == 0); - } +[import src_code/intro.cpp] +[intro_example1_2] But since the elements aren't ordered, the output of: - BOOST_FOREACH(map::value_type i, x) { - std::cout< #include #include +#include "../../examples/hash_functions/fnv-1.hpp" //[case_insensitive_functions struct iequal_to @@ -35,45 +36,68 @@ return seed; } }; - - struct word_info; //] - struct word_info { - int tag; - explicit word_info(int t = 0) : tag(t) {} - }; - int main() { +//[case_sensitive_dictionary_fnv + boost::unordered_map + dictionary; +//] + + BOOST_TEST(dictionary.empty()); + + dictionary["one"] = 1; + BOOST_TEST(dictionary.size() == 1); + BOOST_TEST(dictionary.find("ONE") == dictionary.end()); + + dictionary.insert(std::make_pair("ONE", 2)); + BOOST_TEST(dictionary.size() == 2); + BOOST_TEST(dictionary.find("ONE") != dictionary.end() && + dictionary.find("ONE")->first == "ONE" && + dictionary.find("ONE")->second == 2); + + dictionary["One"] = 3; + BOOST_TEST(dictionary.size() == 3); + BOOST_TEST(dictionary.find("One") != dictionary.end() && + dictionary.find("One")->first == "One" && + dictionary.find("One")->second == 3); + + dictionary["two"] = 4; + BOOST_TEST(dictionary.size() == 4); + BOOST_TEST(dictionary.find("Two") == dictionary.end() && + dictionary.find("two") != dictionary.end() && + dictionary.find("two")->second == 4); + + //[case_insensitive_dictionary - boost::unordered_map + boost::unordered_map idictionary; //] BOOST_TEST(idictionary.empty()); - idictionary["one"] = word_info(1); + idictionary["one"] = 1; BOOST_TEST(idictionary.size() == 1); BOOST_TEST(idictionary.find("ONE") != idictionary.end() && idictionary.find("ONE") == idictionary.find("one")); - idictionary.insert(std::make_pair("ONE", word_info(2))); + idictionary.insert(std::make_pair("ONE", 2)); BOOST_TEST(idictionary.size() == 1); BOOST_TEST(idictionary.find("ONE") != idictionary.end() && idictionary.find("ONE")->first == "one" && - idictionary.find("ONE")->second.tag == 1); + idictionary.find("ONE")->second == 1); - idictionary["One"] = word_info(3); + idictionary["One"] = 3; BOOST_TEST(idictionary.size() == 1); BOOST_TEST(idictionary.find("ONE") != idictionary.end() && idictionary.find("ONE")->first == "one" && - idictionary.find("ONE")->second.tag == 3); + idictionary.find("ONE")->second == 3); - idictionary["two"] = word_info(4); + idictionary["two"] = 4; BOOST_TEST(idictionary.size() == 2); BOOST_TEST(idictionary.find("two") != idictionary.end() && idictionary.find("TWO")->first == "two" && - idictionary.find("Two")->second.tag == 4); + idictionary.find("Two")->second == 4); return boost::report_errors(); } diff --git a/doc/src_code/intro.cpp b/doc/src_code/intro.cpp new file mode 100644 index 00000000..bb0e6a73 --- /dev/null +++ b/doc/src_code/intro.cpp @@ -0,0 +1,30 @@ + +// Copyright 2006-2008 Daniel James. +// 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) + +//[intro_example1_1 +#include +#include +#include +#include +//] + +int main() { +//[intro_example1_2 + typedef boost::unordered_map map; + map x; + x["one"] = 1; + x["two"] = 2; + x["three"] = 3; + + assert(x.at("one") == 1); + assert(x.find("missing") == x.end()); +//] + +//[intro_example1_3 + BOOST_FOREACH(map::value_type i, x) { + std::cout< > - points; + boost::unordered_multiset points; //] int main() { diff --git a/examples/hash_functions/fnv-1.hpp b/examples/hash_functions/fnv-1.hpp index fcfd8cdf..32f9d239 100644 --- a/examples/hash_functions/fnv-1.hpp +++ b/examples/hash_functions/fnv-1.hpp @@ -7,7 +7,7 @@ namespace hash template struct basic_fnv_1 { - std::size_t operator()(std::string const& text) + std::size_t operator()(std::string const& text) const { std::size_t hash = OffsetBias; for(std::string::const_iterator it = text.begin(), end = text.end(); @@ -24,7 +24,7 @@ namespace hash template struct basic_fnv_1a { - std::size_t operator()(std::string const& text) + std::size_t operator()(std::string const& text) const { std::size_t hash = OffsetBias; for(std::string::const_iterator it = text.begin(), end = text.end(); diff --git a/test/helpers/exception_test.hpp b/test/helpers/exception_test.hpp index 9d3bd799..d90db9a8 100644 --- a/test/helpers/exception_test.hpp +++ b/test/helpers/exception_test.hpp @@ -19,30 +19,28 @@ #include #if defined(BOOST_UNORDERED_USE_TEST) -# define UNORDERED_EXCEPTION_TEST_PREFIX # define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \ - BOOST_AUTO_TEST_CASE(name) \ + UNORDERED_AUTO_TEST(name) \ { \ test_func< type > fixture; \ ::test::exception_safety(fixture, BOOST_STRINGIZE(test_func)); \ } -# define UNORDERED_EXCEPTION_TEST_POSTFIX # define UNORDERED_EPOINT_IMPL BOOST_ITEST_EPOINT #else -# define UNORDERED_EXCEPTION_TEST_PREFIX int main() { -# define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \ +# define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \ + UNORDERED_AUTO_TEST(name) \ { \ test_func< type > fixture; \ ::test::lightweight::exception_safety(fixture, BOOST_STRINGIZE(test_func)); \ } -# define UNORDERED_EXCEPTION_TEST_POSTFIX return boost::report_errors(); } # define UNORDERED_EPOINT_IMPL ::test::lightweight::epoint #endif +#define UNORDERED_EXCEPTION_TEST_POSTFIX RUN_TESTS() + #define RUN_EXCEPTION_TESTS(test_seq, param_seq) \ - UNORDERED_EXCEPTION_TEST_PREFIX \ BOOST_PP_SEQ_FOR_EACH_PRODUCT(RUN_EXCEPTION_TESTS_OP, (test_seq)(param_seq)) \ - UNORDERED_EXCEPTION_TEST_POSTFIX + RUN_TESTS() #define RUN_EXCEPTION_TESTS_OP(r, product) \ UNORDERED_EXCEPTION_TEST_CASE( \ diff --git a/test/helpers/test.hpp b/test/helpers/test.hpp index 332dd87a..2999d4fa 100644 --- a/test/helpers/test.hpp +++ b/test/helpers/test.hpp @@ -7,13 +7,90 @@ #define BOOST_UNORDERED_TEST_TEST_HEADER #if defined(BOOST_UNORDERED_USE_TEST) + #include #define UNORDERED_CHECK(x) BOOST_CHECK(x) #define UNORDERED_REQUIRE(x) BOOST_REQUIRE(x) +#define UNORDERED_AUTO_TEST(x) BOOST_AUTO_TEST_CASE(x) +#define RUN_TESTS() + #else + #include +#include + #define UNORDERED_CHECK(x) BOOST_TEST(x) -#define UNORDERED_REQUIRE(x) if(!(x)) { BOOST_ERROR(BOOST_STRINGIZE(x)); throw test::lightweight::test_failure(); } -#endif +#define UNORDERED_REQUIRE(x) if(!(x)) { BOOST_ERROR(BOOST_STRINGIZE(x)); throw ::test::lightweight::test_failure(); } +#define UNORDERED_AUTO_TEST(x) \ + struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base { \ + BOOST_PP_CAT(x, _type)() { \ + ::test::test_list::add_test(this); \ + } \ + void run(); \ + }; \ + BOOST_PP_CAT(x, _type) x; \ + void BOOST_PP_CAT(x, _type)::run() +#define RUN_TESTS() int main() { ::test::test_list::run_tests(); return boost::report_errors(); } + +namespace test { + struct registered_test_base { + registered_test_base* next; + virtual void run() = 0; + virtual ~registered_test_base() {} + }; + + namespace test_list { + static inline registered_test_base*& first() { + static registered_test_base* ptr = 0; + return ptr; + } + + static inline registered_test_base*& last() { + static registered_test_base* ptr = 0; + return ptr; + } + + static inline void add_test(registered_test_base* test) { + if(last()) { + last()->next = test; + } + else { + first() = test; + } + + last() = test; + } + + static inline void run_tests() { + for(registered_test_base* i = first(); i; i = i->next) + i->run(); + } + }; +} + +#endif + +#include +#include +#include +#include +#include + +// Run test with every combination of the parameters (a sequence of sequences) +#define UNORDERED_TEST(name, parameters) \ + BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP, ((name)) parameters) + +#define UNORDERED_TEST_OP(r, product) \ + UNORDERED_TEST_OP2( \ + BOOST_PP_SEQ_HEAD(product), \ + BOOST_PP_SEQ_TAIL(product)) + +#define UNORDERED_TEST_OP2(name, params) \ + UNORDERED_AUTO_TEST(BOOST_PP_SEQ_FOLD_LEFT(UNORDERED_TEST_OP_JOIN, name, params)) { \ + name BOOST_PP_SEQ_TO_TUPLE(params); \ + } + +#define UNORDERED_TEST_OP_JOIN(s, state, elem) \ + BOOST_PP_CAT(state, BOOST_PP_CAT(_, elem)) #endif diff --git a/test/unordered/assign_tests.cpp b/test/unordered/assign_tests.cpp index 13a0a09d..5579e7fe 100644 --- a/test/unordered/assign_tests.cpp +++ b/test/unordered/assign_tests.cpp @@ -5,7 +5,7 @@ #include #include -#include +#include "../helpers/test.hpp" #include "../objects/test.hpp" #include "../helpers/random_values.hpp" #include "../helpers/tracker.hpp" @@ -13,6 +13,8 @@ #include +namespace assign_tests { + test::seed_t seed(96785); template @@ -83,32 +85,24 @@ void assign_tests2(T*, test::random_generator generator = test::default_generato } } -int main() -{ - boost::unordered_set >* test_set; - boost::unordered_multiset >* test_multiset; - boost::unordered_map >* test_map; - boost::unordered_multimap >* test_multimap; +boost::unordered_set >* test_set; +boost::unordered_multiset >* test_multiset; +boost::unordered_map >* test_map; +boost::unordered_multimap >* test_multimap; - assign_tests1(test_set); - assign_tests1(test_multiset); - assign_tests1(test_map); - assign_tests1(test_multimap); +using test::default_generator; +using test::generate_collisions; - assign_tests1(test_set, test::generate_collisions); - assign_tests1(test_multiset, test::generate_collisions); - assign_tests1(test_map, test::generate_collisions); - assign_tests1(test_multimap, test::generate_collisions); +UNORDERED_TEST(assign_tests1, + ((test_set)(test_multiset)(test_map)(test_multimap)) + ((default_generator)(generate_collisions)) +) - assign_tests2(test_set); - assign_tests2(test_multiset); - assign_tests2(test_map); - assign_tests2(test_multimap); +UNORDERED_TEST(assign_tests2, + ((test_set)(test_multiset)(test_map)(test_multimap)) + ((default_generator)(generate_collisions)) +) - assign_tests2(test_set, test::generate_collisions); - assign_tests2(test_multiset, test::generate_collisions); - assign_tests2(test_map, test::generate_collisions); - assign_tests2(test_multimap, test::generate_collisions); - - return boost::report_errors(); } + +RUN_TESTS() diff --git a/test/unordered/at_tests.cpp b/test/unordered/at_tests.cpp index 149a890c..83bc12ce 100644 --- a/test/unordered/at_tests.cpp +++ b/test/unordered/at_tests.cpp @@ -4,10 +4,12 @@ // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #include -#include +#include "../helpers/test.hpp" #include -int main() { +namespace at_tests { + +UNORDERED_AUTO_TEST(at_tests) { boost::unordered_map x; typedef boost::unordered_map::iterator iterator; @@ -23,6 +25,8 @@ int main() { } catch(std::out_of_range) { } - - return boost::report_errors(); } + +} + +RUN_TESTS() diff --git a/test/unordered/bucket_tests.cpp b/test/unordered/bucket_tests.cpp index 68e6560b..5a09b3db 100644 --- a/test/unordered/bucket_tests.cpp +++ b/test/unordered/bucket_tests.cpp @@ -5,12 +5,14 @@ #include #include -#include +#include "../helpers/test.hpp" #include #include "../objects/test.hpp" #include "../helpers/random_values.hpp" #include "../helpers/helpers.hpp" +namespace bucket_tests { + test::seed_t seed(54635); template @@ -48,12 +50,13 @@ void bucket_tests(X* = 0) } } -int main() -{ - bucket_tests((boost::unordered_set >*) 0); - bucket_tests((boost::unordered_multiset >*) 0); - bucket_tests((boost::unordered_map >*) 0); - bucket_tests((boost::unordered_multimap >*) 0); +boost::unordered_set >* test_set; +boost::unordered_multiset >* test_multiset; +boost::unordered_map >* test_map; +boost::unordered_multimap >* test_multimap; + +UNORDERED_TEST(bucket_tests, ((test_set)(test_multiset)(test_map)(test_multimap))) - return boost::report_errors(); } + +RUN_TESTS() diff --git a/test/unordered/compile_map.cpp b/test/unordered/compile_map.cpp index cdb785e9..51aabd2f 100644 --- a/test/unordered/compile_map.cpp +++ b/test/unordered/compile_map.cpp @@ -9,11 +9,11 @@ #include #include -#include +#include "../helpers/test.hpp" #include "../objects/minimal.hpp" #include "./compile_tests.hpp" -void test0() +UNORDERED_AUTO_TEST(test0) { typedef std::pair value_type; @@ -42,8 +42,7 @@ void test0() container_test(multimap, value); } -void test1() -{ +UNORDERED_AUTO_TEST(test1) { boost::hash hash; std::equal_to equal_to; int value = 0; @@ -67,7 +66,7 @@ void test1() unordered_test(multimap, value, map_value, hash, equal_to); } -void test2() +UNORDERED_AUTO_TEST(test2) { test::minimal::assignable assignable = test::minimal::assignable::create(); @@ -121,11 +120,4 @@ void test2() unordered_test(multimap, assignable, map_value, hash, equal_to); } -int main() -{ - test0(); - test1(); - test2(); - - return boost::report_errors(); -} +RUN_TESTS() diff --git a/test/unordered/compile_set.cpp b/test/unordered/compile_set.cpp index 099b8030..41a79f55 100644 --- a/test/unordered/compile_set.cpp +++ b/test/unordered/compile_set.cpp @@ -9,11 +9,11 @@ #include #include -#include +#include "../helpers/test.hpp" #include "../objects/minimal.hpp" #include "./compile_tests.hpp" -void test0() +UNORDERED_AUTO_TEST(test0) { test::minimal::assignable assignable = test::minimal::assignable::create(); @@ -36,7 +36,7 @@ void test0() container_test(multiset, assignable); } -void test1() +UNORDERED_AUTO_TEST(test1) { boost::hash hash; std::equal_to equal_to; @@ -59,7 +59,7 @@ void test1() unordered_test(multiset, value, value, hash, equal_to); } -void test2() +UNORDERED_AUTO_TEST(test2) { test::minimal::assignable assignable = test::minimal::assignable::create(); @@ -95,10 +95,4 @@ void test2() unordered_test(multiset, assignable, assignable, hash, equal_to); } -int main() { - test0(); - test1(); - test2(); - - return boost::report_errors(); -} +RUN_TESTS() diff --git a/test/unordered/constructor_tests.cpp b/test/unordered/constructor_tests.cpp index 3bd39aa6..f30f3736 100644 --- a/test/unordered/constructor_tests.cpp +++ b/test/unordered/constructor_tests.cpp @@ -5,7 +5,7 @@ #include #include -#include +#include "../helpers/test.hpp" #include "../objects/test.hpp" #include "../helpers/random_values.hpp" #include "../helpers/tracker.hpp" @@ -15,6 +15,8 @@ #include +namespace constructor_tests { + test::seed_t seed(356730); template @@ -255,53 +257,28 @@ void map_constructor_test(T* = 0) test::check_equivalent_keys(x); } -int main() -{ - boost::unordered_set >* test_set; - boost::unordered_multiset >* test_multiset; - boost::unordered_map >* test_map; - boost::unordered_multimap >* test_multimap; +boost::unordered_set >* test_set; +boost::unordered_multiset >* test_multiset; +boost::unordered_map >* test_map; +boost::unordered_multimap >* test_multimap; - std::cerr<<"Test1 test_set\n"; - constructor_tests1(test_set); - std::cerr<<"Test1 test_multiset\n"; - constructor_tests1(test_multiset); - std::cerr<<"Test1 test_map\n"; - constructor_tests1(test_map); - std::cerr<<"Test1 test_multimap\n"; - constructor_tests1(test_multimap); +using test::default_generator; +using test::generate_collisions; - std::cerr<<"Test1 test_set, collisions\n"; - constructor_tests1(test_set, test::generate_collisions); - std::cerr<<"Test1 test_multiset, collisions\n"; - constructor_tests1(test_multiset, test::generate_collisions); - std::cerr<<"Test1 test_map, collisions\n"; - constructor_tests1(test_map, test::generate_collisions); - std::cerr<<"Test1 test_multimap, collisions\n"; - constructor_tests1(test_multimap, test::generate_collisions); +UNORDERED_TEST(constructor_tests1, + ((test_set)(test_multiset)(test_map)(test_multimap)) + ((default_generator)(generate_collisions)) +) - std::cerr<<"Test2 test_set\n"; - constructor_tests2(test_set); - std::cerr<<"Test2 test_multiset\n"; - constructor_tests2(test_multiset); - std::cerr<<"Test2 test_map\n"; - constructor_tests2(test_map); - std::cerr<<"Test2 test_multimap\n"; - constructor_tests2(test_multimap); +UNORDERED_TEST(constructor_tests2, + ((test_set)(test_multiset)(test_map)(test_multimap)) + ((default_generator)(generate_collisions)) +) - std::cerr<<"Test2 test_set, collisions\n"; - constructor_tests2(test_set, test::generate_collisions); - std::cerr<<"Test2 test_multiset, collisions\n"; - constructor_tests2(test_multiset, test::generate_collisions); - std::cerr<<"Test2 test_map, collisions\n"; - constructor_tests2(test_map, test::generate_collisions); - std::cerr<<"Test2 test_multimap, collisions\n"; - constructor_tests2(test_multimap, test::generate_collisions); +UNORDERED_TEST(map_constructor_test, + ((test_map)(test_multimap)) +) - std::cerr<<"Map Test unordered_map\n"; - map_constructor_test(test_map); - std::cerr<<"Map Test unordered_multimap\n"; - map_constructor_test(test_multimap); - - return boost::report_errors(); } + +RUN_TESTS() diff --git a/test/unordered/copy_tests.cpp b/test/unordered/copy_tests.cpp index 853fc7a3..d7012693 100644 --- a/test/unordered/copy_tests.cpp +++ b/test/unordered/copy_tests.cpp @@ -5,7 +5,7 @@ #include #include -#include +#include "../helpers/test.hpp" #include "../objects/test.hpp" #include "../helpers/random_values.hpp" #include "../helpers/tracker.hpp" @@ -14,6 +14,9 @@ test::seed_t seed(9063); +namespace copy_tests +{ + template void copy_construct_tests1(T*, test::random_generator const& generator = test::default_generator) { @@ -90,27 +93,23 @@ void copy_construct_tests2(T* ptr, test::random_generator const& generator = tes } } -int main() -{ - boost::unordered_set >* test_set; - boost::unordered_multiset >* test_multiset; - boost::unordered_map >* test_map; - boost::unordered_multimap >* test_multimap; +boost::unordered_set >* test_set; +boost::unordered_multiset >* test_multiset; +boost::unordered_map >* test_map; +boost::unordered_multimap >* test_multimap; - copy_construct_tests1(test_set); - copy_construct_tests1(test_multiset); - copy_construct_tests1(test_map); - copy_construct_tests1(test_multimap); +using test::default_generator; +using test::generate_collisions; - copy_construct_tests2(test_set); - copy_construct_tests2(test_multiset); - copy_construct_tests2(test_map); - copy_construct_tests2(test_multimap); +UNORDERED_TEST(copy_construct_tests1, + ((test_set)(test_multiset)(test_map)(test_multimap)) +) - copy_construct_tests2(test_set, test::generate_collisions); - copy_construct_tests2(test_multiset, test::generate_collisions); - copy_construct_tests2(test_map, test::generate_collisions); - copy_construct_tests2(test_multimap, test::generate_collisions); +UNORDERED_TEST(copy_construct_tests2, + ((test_set)(test_multiset)(test_map)(test_multimap)) + ((default_generator)(generate_collisions)) +) - return boost::report_errors(); } + +RUN_TESTS() diff --git a/test/unordered/equivalent_keys_tests.cpp b/test/unordered/equivalent_keys_tests.cpp index eff90f80..7b6147bc 100644 --- a/test/unordered/equivalent_keys_tests.cpp +++ b/test/unordered/equivalent_keys_tests.cpp @@ -5,7 +5,7 @@ #include #include -#include +#include "../helpers/test.hpp" #include #include #include @@ -32,7 +32,7 @@ void test_equal_insertion(Iterator begin, Iterator end) test::check_equivalent_keys(x1); } -void set_tests() +UNORDERED_AUTO_TEST(set_tests) { int values[][5] = { {1}, @@ -55,7 +55,7 @@ void set_tests() test_equal_insertion >(values[4], values[4] + 3); } -void map_tests() +UNORDERED_AUTO_TEST(map_tests) { typedef std::list > values_type; values_type v[5]; @@ -76,10 +76,4 @@ void map_tests() v[i2].begin(), v[i2].end()); } -int main() -{ - set_tests(); - map_tests(); - - return boost::report_errors(); -} +RUN_TESTS() diff --git a/test/unordered/erase_equiv_tests.cpp b/test/unordered/erase_equiv_tests.cpp index 29f4756e..bd150cb3 100644 --- a/test/unordered/erase_equiv_tests.cpp +++ b/test/unordered/erase_equiv_tests.cpp @@ -7,7 +7,7 @@ // hairy with several tricky edge cases - so explicitly test each one. #include -#include +#include "../helpers/test.hpp" #include #include #include @@ -52,8 +52,7 @@ typedef boost::unordered_multimap collide_list; - -void empty_range_tests() +UNORDERED_AUTO_TEST(empty_range_tests) { collide_map x; x.erase(x.begin(), x.end()); @@ -61,7 +60,7 @@ void empty_range_tests() x.erase(x.end(), x.end()); } -void single_item_tests() +UNORDERED_AUTO_TEST(single_item_tests) { collide_list init; init.push_back(collide_value(1,1)); @@ -75,7 +74,7 @@ void single_item_tests() BOOST_TEST(x.count(1) == 0 && x.size() == 0); } -void two_equivalent_item_tests() +UNORDERED_AUTO_TEST(two_equivalent_item_tests) { collide_list init; init.push_back(collide_value(1,1)); @@ -172,7 +171,7 @@ void exhaustive_erase_tests(Container* x, int num_values, } } -void exhaustive_collide_tests() +UNORDERED_AUTO_TEST(exhaustive_collide_tests) { std::cout<<"exhaustive_collide_tests:\n"; collide_map m; @@ -180,20 +179,11 @@ void exhaustive_collide_tests() std::cout<<"\n"; } -void exhaustive_collide2_tests() +UNORDERED_AUTO_TEST(exhaustive_collide2_tests) { std::cout<<"exhaustive_collide2_tests:\n"; exhaustive_erase_tests((collide_map2*) 0, 8, 4); std::cout<<"\n"; } -int main() -{ - empty_range_tests(); - single_item_tests(); - two_equivalent_item_tests(); - exhaustive_collide_tests(); - exhaustive_collide2_tests(); - - return boost::report_errors(); -} +RUN_TESTS() diff --git a/test/unordered/erase_tests.cpp b/test/unordered/erase_tests.cpp index 95979370..c2b5ec74 100644 --- a/test/unordered/erase_tests.cpp +++ b/test/unordered/erase_tests.cpp @@ -5,7 +5,7 @@ #include #include -#include +#include "../helpers/test.hpp" #include #include "../objects/test.hpp" #include "../helpers/random_values.hpp" @@ -15,6 +15,9 @@ #include +namespace erase_tests +{ + test::seed_t seed(85638); template @@ -119,30 +122,19 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g std::cerr<<"\n"; } -int main() -{ - boost::unordered_set >* test_set; - boost::unordered_multiset >* test_multiset; - boost::unordered_map >* test_map; - boost::unordered_multimap >* test_multimap; +boost::unordered_set >* test_set; +boost::unordered_multiset >* test_multiset; +boost::unordered_map >* test_map; +boost::unordered_multimap >* test_multimap; - std::cerr<<"Erase test_set.\n"; - erase_tests1(test_set); - std::cerr<<"Erase test_multiset.\n"; - erase_tests1(test_multiset); - std::cerr<<"Erase test_map.\n"; - erase_tests1(test_map); - std::cerr<<"Erase test_multimap.\n"; - erase_tests1(test_multimap); +using test::default_generator; +using test::generate_collisions; - std::cerr<<"Erase test_set, collisions.\n"; - erase_tests1(test_set, test::generate_collisions); - std::cerr<<"Erase test_multiset, collisions.\n"; - erase_tests1(test_multiset, test::generate_collisions); - std::cerr<<"Erase test_map, collisions.\n"; - erase_tests1(test_map, test::generate_collisions); - std::cerr<<"Erase test_multimap, collisions.\n"; - erase_tests1(test_multimap, test::generate_collisions); +UNORDERED_TEST(erase_tests1, + ((test_set)(test_multiset)(test_map)(test_multimap)) + ((default_generator)(generate_collisions)) +) - return boost::report_errors(); } + +RUN_TESTS() diff --git a/test/unordered/find_tests.cpp b/test/unordered/find_tests.cpp index 501b5d64..1503f461 100644 --- a/test/unordered/find_tests.cpp +++ b/test/unordered/find_tests.cpp @@ -5,12 +5,15 @@ #include #include -#include +#include "../helpers/test.hpp" #include "../objects/test.hpp" #include "../helpers/random_values.hpp" #include "../helpers/tracker.hpp" #include "../helpers/helpers.hpp" +namespace find_tests +{ + test::seed_t seed(78937); template @@ -78,22 +81,19 @@ void find_tests1(X*, test::random_generator generator = test::default_generator) } } -int main() -{ - boost::unordered_set >* test_set; - boost::unordered_multiset >* test_multiset; - boost::unordered_map >* test_map; - boost::unordered_multimap >* test_multimap; +boost::unordered_set >* test_set; +boost::unordered_multiset >* test_multiset; +boost::unordered_map >* test_map; +boost::unordered_multimap >* test_multimap; - find_tests1(test_set); - find_tests1(test_multiset); - find_tests1(test_map); - find_tests1(test_multimap); +using test::default_generator; +using test::generate_collisions; - find_tests1(test_set, test::generate_collisions); - find_tests1(test_multiset, test::generate_collisions); - find_tests1(test_map, test::generate_collisions); - find_tests1(test_multimap, test::generate_collisions); +UNORDERED_TEST(find_tests1, + ((test_set)(test_multiset)(test_map)(test_multimap)) + ((default_generator)(generate_collisions)) +) - return 0; } + +RUN_TESTS() diff --git a/test/unordered/insert_stable_tests.cpp b/test/unordered/insert_stable_tests.cpp index aad31dd8..34d5bd00 100644 --- a/test/unordered/insert_stable_tests.cpp +++ b/test/unordered/insert_stable_tests.cpp @@ -5,7 +5,7 @@ #include #include -#include +#include "../helpers/test.hpp" #include @@ -39,7 +39,7 @@ namespace insert_stable } } -void stable_insert_test1() { +UNORDERED_AUTO_TEST(stable_insert_test1) { boost::unordered_multiset x; x.insert(insert_stable::member(1,1)); @@ -56,7 +56,7 @@ void stable_insert_test1() { BOOST_TEST(it == end); } -void stable_insert_test2() { +UNORDERED_AUTO_TEST(stable_insert_test2) { boost::unordered_multimap x; typedef boost::unordered_multimap::const_iterator iterator; @@ -75,10 +75,4 @@ void stable_insert_test2() { BOOST_TEST(it == end); } -int main() -{ - stable_insert_test1(); - stable_insert_test2(); - - return boost::report_errors(); -} +RUN_TESTS() diff --git a/test/unordered/insert_tests.cpp b/test/unordered/insert_tests.cpp index 2520209b..6295853b 100644 --- a/test/unordered/insert_tests.cpp +++ b/test/unordered/insert_tests.cpp @@ -5,7 +5,7 @@ #include #include -#include +#include "../helpers/test.hpp" #include #include "../objects/test.hpp" #include "../helpers/random_values.hpp" diff --git a/test/unordered/load_factor_tests.cpp b/test/unordered/load_factor_tests.cpp index 53f0b8fa..7ce9b248 100644 --- a/test/unordered/load_factor_tests.cpp +++ b/test/unordered/load_factor_tests.cpp @@ -5,7 +5,7 @@ #include #include -#include +#include "../helpers/test.hpp" #include #include "../helpers/random_values.hpp" @@ -14,6 +14,9 @@ #pragma warning(disable:4127) // conditional expression is constant #endif +namespace load_factor_tests +{ + test::seed_t seed(783656); template @@ -63,21 +66,23 @@ void load_factor_insert_tests(X* ptr = 0) insert_test(ptr, std::numeric_limits::infinity()); } -int main() -{ - load_factor_tests((boost::unordered_set*) 0); - load_factor_tests((boost::unordered_multiset*) 0); - load_factor_tests((boost::unordered_map*) 0); - load_factor_tests((boost::unordered_multimap*) 0); +boost::unordered_set* int_set_ptr; +boost::unordered_multiset* int_multiset_ptr; +boost::unordered_map* int_map_ptr; +boost::unordered_multimap* int_multimap_ptr; - load_factor_insert_tests((boost::unordered_set*) 0); - load_factor_insert_tests((boost::unordered_multiset*) 0); - load_factor_insert_tests((boost::unordered_map*) 0); - load_factor_insert_tests((boost::unordered_multimap*) 0); +UNORDERED_TEST(load_factor_tests, + ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)) +) + +UNORDERED_TEST(load_factor_insert_tests, + ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)) +) - return boost::report_errors(); } +RUN_TESTS() + #if defined(BOOST_MSVC) #pragma warning(pop) #pragma warning(disable:4127) // conditional expression is constant diff --git a/test/unordered/rehash_tests.cpp b/test/unordered/rehash_tests.cpp index f605cc59..2539952b 100644 --- a/test/unordered/rehash_tests.cpp +++ b/test/unordered/rehash_tests.cpp @@ -5,10 +5,13 @@ #include #include -#include +#include "../helpers/test.hpp" #include "../helpers/random_values.hpp" #include "../helpers/tracker.hpp" +namespace rehash_tests +{ + test::seed_t seed(2974); template @@ -59,11 +62,15 @@ void rehash_tests(X* ptr = 0) rehash_test1(ptr); } -int main() { - rehash_tests((boost::unordered_set*) 0); - rehash_tests((boost::unordered_multiset*) 0); - rehash_tests((boost::unordered_map*) 0); - rehash_tests((boost::unordered_multimap*) 0); +boost::unordered_set* int_set_ptr; +boost::unordered_multiset* int_multiset_ptr; +boost::unordered_map* int_map_ptr; +boost::unordered_multimap* int_multimap_ptr; + +UNORDERED_TEST(rehash_tests, + ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)) +) - return boost::report_errors(); } + +RUN_TESTS() diff --git a/test/unordered/simple_tests.cpp b/test/unordered/simple_tests.cpp index 4824cbd0..60f66fbb 100644 --- a/test/unordered/simple_tests.cpp +++ b/test/unordered/simple_tests.cpp @@ -7,7 +7,7 @@ #include #include -#include +#include "../helpers/test.hpp" #include #include #include "../helpers/equivalent.hpp" @@ -83,7 +83,7 @@ void simple_test(X const& a) } } -int main() +UNORDERED_AUTO_TEST(simple_tests) { using namespace std; srand(14878); @@ -123,6 +123,6 @@ int main() multimap.insert(std::pair(index, rand())); } simple_test(multimap); - - return boost::report_errors(); } + +RUN_TESTS() diff --git a/test/unordered/swap_tests.cpp b/test/unordered/swap_tests.cpp index 2e27a6a3..6ee9ba6f 100644 --- a/test/unordered/swap_tests.cpp +++ b/test/unordered/swap_tests.cpp @@ -8,12 +8,15 @@ #include #include #include -#include +#include "../helpers/test.hpp" #include "../objects/test.hpp" #include "../helpers/random_values.hpp" #include "../helpers/tracker.hpp" #include "../helpers/invariants.hpp" +namespace swap_tests +{ + test::seed_t seed(783472); template @@ -114,22 +117,18 @@ void swap_tests2(X* ptr = 0) #endif } -int main() -{ - boost::unordered_set >* test_set; - boost::unordered_multiset >* test_multiset; - boost::unordered_map >* test_map; - boost::unordered_multimap >* test_multimap; +boost::unordered_set >* test_set; +boost::unordered_multiset >* test_multiset; +boost::unordered_map >* test_map; +boost::unordered_multimap >* test_multimap; - swap_tests1(test_set); - swap_tests1(test_multiset); - swap_tests1(test_map); - swap_tests1(test_multimap); +UNORDERED_TEST(swap_tests1, + ((test_set)(test_multiset)(test_map)(test_multimap)) +) - swap_tests2(test_set); - swap_tests2(test_multiset); - swap_tests2(test_map); - swap_tests2(test_multimap); +UNORDERED_TEST(swap_tests2, + ((test_set)(test_multiset)(test_map)(test_multimap)) +) - return boost::report_errors(); } +RUN_TESTS() diff --git a/test/unordered/unnecessary_copy_tests.cpp b/test/unordered/unnecessary_copy_tests.cpp index f2e53dc5..55b13762 100644 --- a/test/unordered/unnecessary_copy_tests.cpp +++ b/test/unordered/unnecessary_copy_tests.cpp @@ -5,9 +5,10 @@ #include #include -#include +#include "../helpers/test.hpp" -namespace test { +namespace unnecessary_copy_tests +{ struct count_copies { static int count; @@ -17,22 +18,24 @@ namespace test { count_copies& operator=(count_copies const&); }; - bool operator==(test::count_copies const&, test::count_copies const&) { + bool operator==(count_copies const&, count_copies const&) { return true; } } #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) -namespace boost { +namespace boost #else -namespace test { +namespace unnecessary_copy_tests #endif - std::size_t hash_value(test::count_copies const&) { +{ + std::size_t hash_value(unnecessary_copy_tests::count_copies const&) { return 0; } } -namespace test { +namespace unnecessary_copy_tests +{ int count_copies::count; template @@ -45,14 +48,13 @@ namespace test { x.insert(a); BOOST_TEST(count_copies::count == 2); } + + boost::unordered_set* set; + boost::unordered_multiset* multiset; + boost::unordered_map* map; + boost::unordered_multimap* multimap; + + UNORDERED_TEST(unnecessary_copy_test, ((set)(multiset)(map)(multimap))) } -int main() -{ - test::unnecessary_copy_test((boost::unordered_set*) 0); - test::unnecessary_copy_test((boost::unordered_multiset*) 0); - test::unnecessary_copy_test((boost::unordered_map*) 0); - test::unnecessary_copy_test((boost::unordered_multimap*) 0); - - return boost::report_errors(); -} +RUN_TESTS()