From a822b27efcb2b35be02101db2caf82517a27721b Mon Sep 17 00:00:00 2001 From: Daniel James Date: Sat, 25 Aug 2012 21:56:16 +0000 Subject: [PATCH] Unordered: Weaken requirements in compile tests. Assigning a container requires that its elements can be assignable. Could split the tests up so that other tests aren't assignable, but it doesn't seem worth the hassle. [SVN r80228] --- test/objects/minimal.hpp | 22 +++++++++++++--------- test/unordered/compile_map.cpp | 30 +++++++++++++++--------------- 2 files changed, 28 insertions(+), 24 deletions(-) diff --git a/test/objects/minimal.hpp b/test/objects/minimal.hpp index 0d9ae8b2..ba32167a 100644 --- a/test/objects/minimal.hpp +++ b/test/objects/minimal.hpp @@ -26,7 +26,7 @@ namespace minimal class destructible; class copy_constructible; class copy_constructible_equality_comparable; - class default_copy_constructible; + class default_assignable; class assignable; struct ampersand_operator_used {}; @@ -99,26 +99,29 @@ namespace minimal return false; } - class default_copy_constructible + class default_assignable { public: - default_copy_constructible(constructor_param const&) {} + default_assignable(constructor_param const&) {} - default_copy_constructible() + default_assignable() { } - default_copy_constructible(default_copy_constructible const&) + default_assignable(default_assignable const&) { } - ~default_copy_constructible() + default_assignable& operator=(default_assignable const&) + { + return *this; + } + + ~default_assignable() { } private: - default_copy_constructible& operator=( - default_copy_constructible const&); ampersand_operator_used operator&() const { return ampersand_operator_used(); } }; @@ -148,7 +151,7 @@ namespace minimal movable1() {} explicit movable1(movable_init) {} movable1(BOOST_RV_REF(movable1)) {} - movable1& operator=(BOOST_RV_REF(movable1)); + movable1& operator=(BOOST_RV_REF(movable1)) { return *this; } ~movable1() {} }; @@ -160,6 +163,7 @@ namespace minimal explicit movable2(movable_init) {} movable2(movable2&&) {} ~movable2() {} + movable2& operator=(movable2&&) { return *this; } private: movable2() {} movable2(movable2 const&); diff --git a/test/unordered/compile_map.cpp b/test/unordered/compile_map.cpp index 6cd3c503..317607c7 100644 --- a/test/unordered/compile_map.cpp +++ b/test/unordered/compile_map.cpp @@ -32,13 +32,13 @@ template class boost::unordered_multimap< template class boost::unordered_map< test::minimal::assignable, - test::minimal::default_copy_constructible, + test::minimal::default_assignable, test::minimal::hash, test::minimal::equal_to, test::minimal::allocator >; template class boost::unordered_multimap< test::minimal::assignable, - test::minimal::copy_constructible, + test::minimal::assignable, test::minimal::hash, test::minimal::equal_to, test::minimal::allocator >; @@ -48,7 +48,7 @@ UNORDERED_AUTO_TEST(test0) test::minimal::constructor_param x; typedef std::pair value_type; + test::minimal::assignable> value_type; value_type value(x, x); std::cout<<"Test unordered_map.\n"; @@ -62,7 +62,7 @@ UNORDERED_AUTO_TEST(test0) boost::unordered_map< test::minimal::assignable, - test::minimal::copy_constructible, + test::minimal::assignable, test::minimal::hash, test::minimal::equal_to, test::minimal::allocator > map; @@ -82,7 +82,7 @@ UNORDERED_AUTO_TEST(test0) boost::unordered_multimap< test::minimal::assignable, - test::minimal::copy_constructible, + test::minimal::assignable, test::minimal::hash, test::minimal::equal_to, test::minimal::allocator > multimap; @@ -95,7 +95,7 @@ UNORDERED_AUTO_TEST(test0) UNORDERED_AUTO_TEST(equality_tests) { typedef std::pair< test::minimal::copy_constructible_equality_comparable const, - test::minimal::copy_constructible> value_type; + test::minimal::copy_constructible_equality_comparable> value_type; boost::unordered_map int_map; @@ -187,44 +187,44 @@ UNORDERED_AUTO_TEST(test2) test::minimal::equal_to equal_to(x); typedef std::pair map_value_type; - map_value_type map_value(assignable, copy_constructible); + test::minimal::assignable> map_value_type; + map_value_type map_value(assignable, assignable); std::cout<<"Test unordered_map.\n"; boost::unordered_map< test::minimal::assignable, - test::minimal::copy_constructible, + test::minimal::assignable, test::minimal::hash, test::minimal::equal_to, test::minimal::allocator > map; unordered_unique_test(map, map_value); - unordered_map_test(map, assignable, copy_constructible); + unordered_map_test(map, assignable, assignable); unordered_copyable_test(map, assignable, map_value, hash, equal_to); boost::unordered_map< test::minimal::assignable, - test::minimal::default_copy_constructible, + test::minimal::default_assignable, test::minimal::hash, test::minimal::equal_to, test::minimal::allocator > map2; - test::minimal::default_copy_constructible default_copy_constructible; + test::minimal::default_assignable default_assignable; - unordered_map_functions(map2, assignable, default_copy_constructible); + unordered_map_functions(map2, assignable, default_assignable); std::cout<<"Test unordered_multimap.\n"; boost::unordered_multimap< test::minimal::assignable, - test::minimal::copy_constructible, + test::minimal::assignable, test::minimal::hash, test::minimal::equal_to, test::minimal::allocator > multimap; unordered_equivalent_test(multimap, map_value); - unordered_map_test(multimap, assignable, copy_constructible); + unordered_map_test(multimap, assignable, assignable); unordered_copyable_test(multimap, assignable, map_value, hash, equal_to); }