Unordered: Merge to release.

Using Boost.Move and better C++11 support.


[SVN r73987]

test/unordered/compile_set.cpp

@@ -16,7 +16,18 @@
 #include "./compile_tests.hpp"
 
 // Explicit instantiation to catch compile-time errors
-
+/*
+template class boost::unordered_set<
+    int,
+    boost::hash<int>,
+    std::equal_to<int>,
+    test::minimal::allocator<int> >;
+template class boost::unordered_multiset<
+    int,
+    boost::hash<int>,
+    std::equal_to<int>,
+    test::minimal::allocator<int> >;
+*/
 template class boost::unordered_set<
     test::minimal::assignable,
     test::minimal::hash<test::minimal::assignable>,
@@ -30,10 +41,19 @@ template class boost::unordered_multiset<
 
 UNORDERED_AUTO_TEST(test0)
 {
-    test::minimal::assignable assignable = test::minimal::assignable::create();
+    test::minimal::constructor_param x;
+
+    test::minimal::assignable assignable(x);
 
     std::cout<<"Test unordered_set.\n";
+
     boost::unordered_set<int> int_set;
+
+    boost::unordered_set<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > int_set2;
+
     boost::unordered_set<
         test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
@@ -41,10 +61,18 @@ UNORDERED_AUTO_TEST(test0)
         test::minimal::allocator<test::minimal::assignable> > set;
 
     container_test(int_set, 0);
+    container_test(int_set2, 0);
     container_test(set, assignable);
 
     std::cout<<"Test unordered_multiset.\n";
+
     boost::unordered_multiset<int> int_multiset;
+
+    boost::unordered_multiset<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > int_multiset2;
+
     boost::unordered_multiset<
         test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
@@ -52,32 +80,45 @@ UNORDERED_AUTO_TEST(test0)
         test::minimal::allocator<test::minimal::assignable> > multiset;
 
     container_test(int_multiset, 0);
+    container_test(int_multiset2, 0);
     container_test(multiset, assignable);
 }
 
 UNORDERED_AUTO_TEST(equality_tests) {
-    typedef test::minimal::assignable value_type;
+    typedef test::minimal::copy_constructible_equality_comparable value_type;
 
     boost::unordered_set<int> int_set;
 
+    boost::unordered_set<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > int_set2;
+
     boost::unordered_set<
-        test::minimal::assignable,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::copy_constructible_equality_comparable,
+        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
         test::minimal::allocator<value_type> > set;
 
     equality_test(int_set);
+    equality_test(int_set2);
     equality_test(set);
 
     boost::unordered_multiset<int> int_multiset;
 
+    boost::unordered_multiset<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > int_multiset2;
+
     boost::unordered_multiset<
-        test::minimal::assignable,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::copy_constructible_equality_comparable,
+        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
         test::minimal::allocator<value_type> > multiset;
 
     equality_test(int_multiset);
+    equality_test(int_multiset2);
     equality_test(multiset);
 }
 
@@ -91,29 +132,45 @@ UNORDERED_AUTO_TEST(test1)
 
     boost::unordered_set<int> set;
     
+    boost::unordered_set<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > set2;
+
     unordered_unique_test(set, value);
     unordered_set_test(set, value);
-    unordered_test(set, value, value, hash, equal_to);
+    unordered_copyable_test(set, value, value, hash, equal_to);
+
+    unordered_unique_test(set2, value);
+    unordered_set_test(set2, value);
+    unordered_copyable_test(set2, value, value, hash, equal_to);
 
     std::cout<<"Test unordered_multiset.\n";
 
     boost::unordered_multiset<int> multiset;
     
+    boost::unordered_multiset<int,
+        boost::hash<int>, std::equal_to<int>,
+        test::minimal::cxx11_allocator<int>
+        > multiset2;
+
     unordered_equivalent_test(multiset, value);
     unordered_set_test(multiset, value);
-    unordered_test(multiset, value, value, hash, equal_to);
+    unordered_copyable_test(multiset, value, value, hash, equal_to);
+
+    unordered_equivalent_test(multiset2, value);
+    unordered_set_test(multiset2, value);
+    unordered_copyable_test(multiset2, value, value, hash, equal_to);
 }
 
 UNORDERED_AUTO_TEST(test2)
 {
-    test::minimal::assignable assignable
-        = test::minimal::assignable::create();
-    test::minimal::copy_constructible copy_constructible
-        = test::minimal::copy_constructible::create();
-    test::minimal::hash<test::minimal::assignable> hash
-        = test::minimal::hash<test::minimal::assignable>::create();
-    test::minimal::equal_to<test::minimal::assignable> equal_to
-        = test::minimal::equal_to<test::minimal::assignable>::create();
+    test::minimal::constructor_param x;
+ 
+    test::minimal::assignable assignable(x);
+    test::minimal::copy_constructible copy_constructible(x);
+    test::minimal::hash<test::minimal::assignable> hash(x);
+    test::minimal::equal_to<test::minimal::assignable> equal_to(x);
 
     std::cout<<"Test unordered_set.\n";
 
@@ -125,7 +182,7 @@ UNORDERED_AUTO_TEST(test2)
 
     unordered_unique_test(set, assignable);
     unordered_set_test(set, assignable);
-    unordered_test(set, assignable, assignable, hash, equal_to);
+    unordered_copyable_test(set, assignable, assignable, hash, equal_to);
 
     std::cout<<"Test unordered_multiset.\n";
 
@@ -137,7 +194,100 @@ UNORDERED_AUTO_TEST(test2)
 
     unordered_equivalent_test(multiset, assignable);
     unordered_set_test(multiset, assignable);
-    unordered_test(multiset, assignable, assignable, hash, equal_to);
+    unordered_copyable_test(multiset, assignable, assignable, hash, equal_to);
+}
+
+UNORDERED_AUTO_TEST(movable1_tests)
+{
+    test::minimal::constructor_param x;
+
+    test::minimal::movable1 movable1(x);
+    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::unordered_set<
+        test::minimal::movable1,
+        test::minimal::hash<test::minimal::movable1>,
+        test::minimal::equal_to<test::minimal::movable1>,
+        test::minimal::allocator<test::minimal::movable1> > set;
+
+    //unordered_unique_test(set, movable1);
+    unordered_set_test(set, movable1);
+    unordered_movable_test(set, movable1, movable1, hash, equal_to);
+
+    std::cout<<"Test unordered_multiset.\n";
+
+    boost::unordered_multiset<
+        test::minimal::movable1,
+        test::minimal::hash<test::minimal::movable1>,
+        test::minimal::equal_to<test::minimal::movable1>,
+        test::minimal::allocator<test::minimal::movable1> > multiset;
+
+    //unordered_equivalent_test(multiset, movable1);
+    unordered_set_test(multiset, movable1);
+    unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
+}
+
+UNORDERED_AUTO_TEST(movable2_tests)
+{
+    test::minimal::constructor_param x;
+
+    test::minimal::movable2 movable2(x);
+    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::unordered_set<
+        test::minimal::movable2,
+        test::minimal::hash<test::minimal::movable2>,
+        test::minimal::equal_to<test::minimal::movable2>,
+        test::minimal::allocator<test::minimal::movable2> > set;
+
+    //unordered_unique_test(set, movable2);
+    unordered_set_test(set, movable2);
+    unordered_movable_test(set, movable2, movable2, hash, equal_to);
+
+    std::cout<<"Test unordered_multiset.\n";
+
+    boost::unordered_multiset<
+        test::minimal::movable2,
+        test::minimal::hash<test::minimal::movable2>,
+        test::minimal::equal_to<test::minimal::movable2>,
+        test::minimal::allocator<test::minimal::movable2> > multiset;
+
+    //unordered_equivalent_test(multiset, movable2);
+    unordered_set_test(multiset, movable2);
+    unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
+}
+
+UNORDERED_AUTO_TEST(destructible_tests)
+{
+    test::minimal::constructor_param x;
+
+    test::minimal::destructible destructible(x);
+    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::unordered_set<
+        test::minimal::destructible,
+        test::minimal::hash<test::minimal::destructible>,
+        test::minimal::equal_to<test::minimal::destructible> > set;
+
+    unordered_destructible_test(set);
+
+    std::cout<<"Test unordered_multiset.\n";
+
+    boost::unordered_multiset<
+        test::minimal::destructible,
+        test::minimal::hash<test::minimal::destructible>,
+        test::minimal::equal_to<test::minimal::destructible> > multiset;
+
+    unordered_destructible_test(multiset);
 }
 
 RUN_TESTS()