From cafd236a1880f2efcb27d8845142e1afa68cf6e5 Mon Sep 17 00:00:00 2001
From: Daniel James <daniel@calamity.org.uk>
Date: Tue, 18 Apr 2017 10:14:26 +0100
Subject: [PATCH] Test more memory tracking

---
 test/helpers/memory.hpp         |   2 +
 test/objects/test.hpp           |  13 ++-
 test/unordered/insert_tests.cpp | 150 ++++++++++++++++++++++----------
 3 files changed, 118 insertions(+), 47 deletions(-)

diff --git a/test/helpers/memory.hpp b/test/helpers/memory.hpp
index 84822b4a..16837e77 100644
--- a/test/helpers/memory.hpp
+++ b/test/helpers/memory.hpp
@@ -66,6 +66,8 @@ struct memory_tracker
     {
     }
 
+    ~memory_tracker() { BOOST_TEST(count_allocators == 0); }
+
     void allocator_ref()
     {
         if (count_allocators == 0) {
diff --git a/test/objects/test.hpp b/test/objects/test.hpp
index ab346806..aba215f0 100644
--- a/test/objects/test.hpp
+++ b/test/objects/test.hpp
@@ -391,16 +391,23 @@ template <class T> class allocator1
         ::operator delete((void*)p);
     }
 
+#if BOOST_UNORDERED_CXX11_CONSTRUCTION
+    template <typename... Args> void construct(T* p, Args&&... args)
+    {
+        detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+        new (p) T(boost::forward<Args>(args)...);
+    }
+#else
     void construct(T* p, T const& t)
     {
-        // Don't count constructions here as it isn't always called.
-        // detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+        detail::tracker.track_construct((void*)p, sizeof(T), tag_);
         new (p) T(t);
     }
+#endif
 
     void destroy(T* p)
     {
-        // detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
+        detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
         p->~T();
 
         // Work around MSVC buggy unused parameter warning.
diff --git a/test/unordered/insert_tests.cpp b/test/unordered/insert_tests.cpp
index ae50fa18..332a9b0f 100644
--- a/test/unordered/insert_tests.cpp
+++ b/test/unordered/insert_tests.cpp
@@ -1030,21 +1030,43 @@ struct overloaded_constructor
 
 UNORDERED_AUTO_TEST(map_emplace_test)
 {
-    boost::unordered_map<int, overloaded_constructor> x;
+    {
+        boost::unordered_map<int, overloaded_constructor, test::hash,
+            test::equal_to,
+            test::allocator1<std::pair<int const, overloaded_constructor> > >
+            x;
 
 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
-    x.emplace();
-    BOOST_TEST(
-        x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
+        x.emplace();
+        BOOST_TEST(x.find(0) != x.end() &&
+                   x.find(0)->second == overloaded_constructor());
 #endif
 
-    x.emplace(2, 3);
-    BOOST_TEST(
-        x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
+        x.emplace(2, 3);
+        BOOST_TEST(x.find(2) != x.end() &&
+                   x.find(2)->second == overloaded_constructor(3));
 
-    x.try_emplace(5);
-    BOOST_TEST(
-        x.find(5) != x.end() && x.find(5)->second == overloaded_constructor());
+        x.try_emplace(5);
+        BOOST_TEST(x.find(5) != x.end() &&
+                   x.find(5)->second == overloaded_constructor());
+    }
+
+    {
+        boost::unordered_multimap<int, overloaded_constructor, test::hash,
+            test::equal_to,
+            test::allocator1<std::pair<int const, overloaded_constructor> > >
+            x;
+
+#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
+        x.emplace();
+        BOOST_TEST(x.find(0) != x.end() &&
+                   x.find(0)->second == overloaded_constructor());
+#endif
+
+        x.emplace(2, 3);
+        BOOST_TEST(x.find(2) != x.end() &&
+                   x.find(2)->second == overloaded_constructor(3));
+    }
 }
 
 UNORDERED_AUTO_TEST(set_emplace_test)
@@ -1098,48 +1120,88 @@ struct convertible_to_piecewise
 
 UNORDERED_AUTO_TEST(map_emplace_test2)
 {
-    boost::unordered_map<overloaded_constructor, overloaded_constructor> x;
+    {
+        boost::unordered_map<overloaded_constructor, overloaded_constructor,
+            boost::hash<overloaded_constructor>,
+            std::equal_to<overloaded_constructor>,
+            test::allocator1<std::pair<overloaded_constructor const,
+                overloaded_constructor> > >
+            x;
 
-    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
-        boost::make_tuple());
-    BOOST_TEST(
-        x.find(overloaded_constructor()) != x.end() &&
-        x.find(overloaded_constructor())->second == overloaded_constructor());
+        x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
+            boost::make_tuple());
+        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+                   x.find(overloaded_constructor())->second ==
+                       overloaded_constructor());
 
-    x.emplace(
-        convertible_to_piecewise(), boost::make_tuple(1), boost::make_tuple());
-    BOOST_TEST(
-        x.find(overloaded_constructor(1)) != x.end() &&
-        x.find(overloaded_constructor(1))->second == overloaded_constructor());
+        x.emplace(convertible_to_piecewise(), boost::make_tuple(1),
+            boost::make_tuple());
+        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+                   x.find(overloaded_constructor(1))->second ==
+                       overloaded_constructor());
 
-    x.emplace(piecewise_rvalue(), boost::make_tuple(2, 3),
-        boost::make_tuple(4, 5, 6));
-    BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
-               x.find(overloaded_constructor(2, 3))->second ==
-                   overloaded_constructor(4, 5, 6));
+        x.emplace(piecewise_rvalue(), boost::make_tuple(2, 3),
+            boost::make_tuple(4, 5, 6));
+        BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+                   x.find(overloaded_constructor(2, 3))->second ==
+                       overloaded_constructor(4, 5, 6));
 
-    derived_from_piecewise_construct_t d;
-    x.emplace(d, boost::make_tuple(9, 3, 1), boost::make_tuple(10));
-    BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
-               x.find(overloaded_constructor(9, 3, 1))->second ==
-                   overloaded_constructor(10));
+        derived_from_piecewise_construct_t d;
+        x.emplace(d, boost::make_tuple(9, 3, 1), boost::make_tuple(10));
+        BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
+                   x.find(overloaded_constructor(9, 3, 1))->second ==
+                       overloaded_constructor(10));
 
-    x.clear();
+        x.clear();
 
-    x.try_emplace(overloaded_constructor());
-    BOOST_TEST(
-        x.find(overloaded_constructor()) != x.end() &&
-        x.find(overloaded_constructor())->second == overloaded_constructor());
+        x.try_emplace(overloaded_constructor());
+        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+                   x.find(overloaded_constructor())->second ==
+                       overloaded_constructor());
 
-    x.try_emplace(1);
-    BOOST_TEST(
-        x.find(overloaded_constructor(1)) != x.end() &&
-        x.find(overloaded_constructor(1))->second == overloaded_constructor());
+        x.try_emplace(1);
+        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+                   x.find(overloaded_constructor(1))->second ==
+                       overloaded_constructor());
 
-    x.try_emplace(overloaded_constructor(2, 3), 4, 5, 6);
-    BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
-               x.find(overloaded_constructor(2, 3))->second ==
-                   overloaded_constructor(4, 5, 6));
+        x.try_emplace(overloaded_constructor(2, 3), 4, 5, 6);
+        BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+                   x.find(overloaded_constructor(2, 3))->second ==
+                       overloaded_constructor(4, 5, 6));
+    }
+    {
+
+        boost::unordered_multimap<overloaded_constructor,
+            overloaded_constructor, boost::hash<overloaded_constructor>,
+            std::equal_to<overloaded_constructor>,
+            test::allocator1<std::pair<overloaded_constructor const,
+                overloaded_constructor> > >
+            x;
+
+        x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
+            boost::make_tuple());
+        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+                   x.find(overloaded_constructor())->second ==
+                       overloaded_constructor());
+
+        x.emplace(convertible_to_piecewise(), boost::make_tuple(1),
+            boost::make_tuple());
+        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+                   x.find(overloaded_constructor(1))->second ==
+                       overloaded_constructor());
+
+        x.emplace(piecewise_rvalue(), boost::make_tuple(2, 3),
+            boost::make_tuple(4, 5, 6));
+        BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+                   x.find(overloaded_constructor(2, 3))->second ==
+                       overloaded_constructor(4, 5, 6));
+
+        derived_from_piecewise_construct_t d;
+        x.emplace(d, boost::make_tuple(9, 3, 1), boost::make_tuple(10));
+        BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
+                   x.find(overloaded_constructor(9, 3, 1))->second ==
+                       overloaded_constructor(10));
+    }
 }
 
 UNORDERED_AUTO_TEST(set_emplace_test2)