More merge tests between compatible containers

test/unordered/merge_tests.cpp

@@ -139,12 +139,14 @@ UNORDERED_AUTO_TEST(merge_set_and_multiset)
     test::check_equivalent_keys(y);
 }
 
-template <class X> void merge_empty_test(X*, test::random_generator generator)
+template <class X1, class X2>
+void merge_empty_test(X1*, X2*, test::random_generator generator)
 {
     test::check_instances check_;
 
-    test::random_values<X> v(1000, generator);
+    test::random_values<X1> v(1000, generator);
-    X x1(v.begin(), v.end()), x2;
+    X1 x1(v.begin(), v.end());
+    X2 x2;
     x1.merge(x2);
     test::check_container(x1, v);
     BOOST_TEST(x2.empty());
@@ -158,7 +160,8 @@ void merge_into_empty_test(X*, test::random_generator generator)
     test::check_instances check_;
 
     test::random_values<X> v(1000, generator);
-    X x1, x2(v.begin(), v.end());
+    X x1;
+    X x2(v.begin(), v.end());
     x1.merge(x2);
     test::check_container(x1, v);
     BOOST_TEST(x2.empty());
@@ -166,24 +169,26 @@ void merge_into_empty_test(X*, test::random_generator generator)
     test::check_equivalent_keys(x2);
 }
 
-template <class X> void unique_merge_test(X*, test::random_generator generator)
+template <class X1, class X2>
+void merge_into_unique_keys_test(X1*, X2*, test::random_generator generator)
 {
     test::check_instances check_;
 
-    test::random_values<X> v1(1000, generator);
+    test::random_values<X1> v1(1000, generator);
-    test::random_values<X> v2(1000, generator);
+    test::random_values<X2> v2(1000, generator);
     v1.insert(v2.begin(), boost::next(v2.begin(), 100));
     v2.insert(v1.begin(), boost::next(v1.begin(), 100));
 
-    X x1(v1.begin(), v1.end()), x2(v2.begin(), v2.end());
+    X1 x1(v1.begin(), v1.end());
+    X2 x2(v2.begin(), v2.end());
     x1.merge(x2);
 
-    test::ordered<X> tracker1 = test::create_ordered(x1);
+    test::ordered<X1> tracker1 = test::create_ordered(x1);
-    test::ordered<X> tracker2 = test::create_ordered(x2);
+    test::ordered<X2> tracker2 = test::create_ordered(x2);
-    test::ordered<X> tracker_tmp = test::create_ordered(x2);
+    test::ordered<X2> tracker_tmp = test::create_ordered(x2);
     tracker1.insert(v1.begin(), v1.end());
     tracker_tmp.insert(v2.begin(), v2.end());
-    for (BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator it =
+    for (BOOST_DEDUCED_TYPENAME test::ordered<X2>::iterator it =
              tracker_tmp.begin();
          it != tracker_tmp.end(); ++it) {
         if (!tracker1.insert(*it).second) {
@@ -197,19 +202,21 @@ template <class X> void unique_merge_test(X*, test::random_generator generator)
     test::check_equivalent_keys(x2);
 }
 
-template <class X> void equiv_merge_test(X*, test::random_generator generator)
+template <class X1, class X2>
+void merge_into_equiv_keys_test(X1*, X2*, test::random_generator generator)
 {
     test::check_instances check_;
 
-    test::random_values<X> v1(1000, generator);
+    test::random_values<X1> v1(1000, generator);
-    test::random_values<X> v2(1000, generator);
+    test::random_values<X2> v2(1000, generator);
     v1.insert(v2.begin(), boost::next(v2.begin(), 100));
     v2.insert(v1.begin(), boost::next(v1.begin(), 100));
 
-    X x1(v1.begin(), v1.end()), x2(v2.begin(), v2.end());
+    X1 x1(v1.begin(), v1.end());
+    X2 x2(v2.begin(), v2.end());
     x1.merge(x2);
 
-    test::ordered<X> tracker1 = test::create_ordered(x1);
+    test::ordered<X1> tracker1 = test::create_ordered(x1);
     tracker1.insert(v1.begin(), v1.end());
     tracker1.insert(v2.begin(), v2.end());
 
@@ -221,34 +228,93 @@ template <class X> void equiv_merge_test(X*, test::random_generator generator)
 
 boost::unordered_set<test::movable, test::hash, test::equal_to,
     std::allocator<test::movable> >* test_set_std_alloc;
+boost::unordered_multiset<test::movable, test::hash, test::equal_to,
+    std::allocator<test::movable> >* test_multiset_std_alloc;
+
+boost::unordered_map<test::object, test::object, test::hash,
+    test::equal_to, std::allocator<test::object> >* test_map_std_alloc;
 boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, std::allocator<test::object> >* test_multimap_std_alloc;
 
 boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::movable, test::hash, test::equal_to,
+boost::unordered_multiset<test::object, test::hash, test::equal_to,
-    test::allocator2<test::movable> >* test_multiset;
+    test::allocator1<test::object> >* test_multiset;
+
 boost::unordered_map<test::movable, test::movable, test::hash, test::equal_to,
     test::allocator2<test::movable> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+boost::unordered_multimap<test::movable, test::movable, test::hash,
-    test::equal_to, test::allocator1<test::object> >* test_multimap;
+    test::equal_to, test::allocator2<test::movable> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
 
+// clang-format off
 UNORDERED_TEST(merge_empty_test,
-    ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_multiset)(
+    ((test_set_std_alloc)(test_multiset_std_alloc))
-        test_map)(test_multimap))((default_generator)(generate_collisions)))
+    ((test_set_std_alloc)(test_multiset_std_alloc))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_empty_test,
+    ((test_map_std_alloc)(test_multimap_std_alloc))
+    ((test_map_std_alloc)(test_multimap_std_alloc))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_empty_test,
+    ((test_set)(test_multiset))
+    ((test_set)(test_multiset))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_empty_test,
+    ((test_map)(test_multimap))
+    ((test_map)(test_multimap))
+    ((default_generator)(generate_collisions)))
 
 UNORDERED_TEST(merge_into_empty_test,
-    ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_multiset)(
+    ((test_set_std_alloc)(test_multiset_std_alloc))
-        test_map)(test_multimap))((default_generator)(generate_collisions)))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_empty_test,
+    ((test_map_std_alloc)(test_multimap_std_alloc))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_empty_test,
+    ((test_set)(test_multiset))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_empty_test,
+    ((test_map)(test_multimap))
+    ((default_generator)(generate_collisions)))
 
-UNORDERED_TEST(unique_merge_test,
+UNORDERED_TEST(merge_into_unique_keys_test,
-    ((test_set_std_alloc)(test_set)(test_map))((default_generator)))
+    ((test_set_std_alloc))
+    ((test_set_std_alloc)(test_multiset_std_alloc))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_unique_keys_test,
+    ((test_map_std_alloc))
+    ((test_map_std_alloc)(test_multimap_std_alloc))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_unique_keys_test,
+    ((test_set))
+    ((test_set)(test_multiset))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_unique_keys_test,
+    ((test_map))
+    ((test_map)(test_multimap))
+    ((default_generator)(generate_collisions)))
+
+UNORDERED_TEST(merge_into_equiv_keys_test,
+    ((test_multiset_std_alloc))
+    ((test_set_std_alloc)(test_multiset_std_alloc))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_equiv_keys_test,
+    ((test_multimap_std_alloc))
+    ((test_map_std_alloc)(test_multimap_std_alloc))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_equiv_keys_test,
+    ((test_multiset))
+    ((test_set)(test_multiset))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_equiv_keys_test,
+    ((test_multimap))
+    ((test_map)(test_multimap))
+    ((default_generator)(generate_collisions)))
+// clang-format on
 
-UNORDERED_TEST(equiv_merge_test, ((test_multimap_std_alloc)(test_multiset)(
-                                     test_multimap))((default_generator)))
 }
 
 RUN_TESTS()