Insert/emplace with hint.

test/unordered/insert_hint_tests.cpp

@@ -0,0 +1,118 @@
+
+// Copyright 2016 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)
+
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+
+#include "../helpers/test.hpp"
+#include "../helpers/invariants.hpp"
+
+#include <map>
+#include <set>
+#include <iostream>
+
+namespace insert_hint
+{
+UNORDERED_AUTO_TEST(insert_hint_empty) {
+    typedef boost::unordered_multiset<int> container;
+    container x;
+    x.insert(x.cbegin(), 10);
+    BOOST_TEST_EQ(x.size(), 1);
+    BOOST_TEST_EQ(x.count(10), 1);
+    test::check_equivalent_keys(x);
+}
+
+UNORDERED_AUTO_TEST(insert_hint_empty2) {
+    typedef boost::unordered_multimap<std::string, int> container;
+    container x;
+    x.emplace_hint(x.cbegin(), "hello", 50);
+    BOOST_TEST_EQ(x.size(), 1);
+    BOOST_TEST_EQ(x.count("hello"), 1);
+    BOOST_TEST_EQ(x.find("hello")->second, 50);
+    test::check_equivalent_keys(x);
+}
+
+UNORDERED_AUTO_TEST(insert_hint_single) {
+    typedef boost::unordered_multiset<std::string> container;
+    container x;
+    x.insert("equal");
+    x.insert(x.cbegin(), "equal");
+    BOOST_TEST_EQ(x.size(), 2);
+    BOOST_TEST_EQ(x.count("equal"), 2);
+    test::check_equivalent_keys(x);
+}
+
+UNORDERED_AUTO_TEST(insert_hint_single2) {
+    typedef boost::unordered_multimap<int, std::string> container;
+    container x;
+    x.emplace(10, "one");
+    x.emplace_hint(x.cbegin(), 10, "two");
+    BOOST_TEST_EQ(x.size(), 2);
+    BOOST_TEST_EQ(x.count(10), 2);
+
+    container::iterator it = x.find(10);
+    std::string v0 = (it++)->second;
+    std::string v1 = (it++)->second;
+
+    BOOST_TEST(v0 == "one" || v0 == "two");
+    BOOST_TEST(v1 == "one" || v1 == "two");
+    BOOST_TEST(v0 != v1);
+
+    test::check_equivalent_keys(x);
+}
+
+UNORDERED_AUTO_TEST(insert_hint_multiple) {
+    for (unsigned int size = 0; size < 10; ++size) {
+        for (unsigned int offset = 0; offset <= size;  ++offset) {
+            typedef boost::unordered_multiset<std::string> container;
+            container x;
+
+            for (unsigned int i = 0; i < size; ++i) { x.insert("multiple"); }
+
+            BOOST_TEST_EQ(x.size(), size);
+
+            container::const_iterator position = x.cbegin();
+            for (unsigned int i = 0; i < offset; ++i) { ++position; }
+
+            x.insert(position, "multiple");
+
+            BOOST_TEST_EQ(x.size(), size + 1);
+            BOOST_TEST_EQ(x.count("multiple"), size + 1);
+            test::check_equivalent_keys(x);
+        }
+    }
+}
+
+UNORDERED_AUTO_TEST(insert_hint_unique) {
+    typedef boost::unordered_set<int> container;
+    container x;
+    x.insert(x.cbegin(), 10);
+    BOOST_TEST_EQ(x.size(), 1);
+    BOOST_TEST_EQ(x.count(10), 1);
+    test::check_equivalent_keys(x);
+}
+
+UNORDERED_AUTO_TEST(insert_hint_unique_single) {
+    typedef boost::unordered_set<int> container;
+    container x;
+    x.insert(10);
+
+    x.insert(x.cbegin(), 10);
+    BOOST_TEST_EQ(x.size(), 1);
+    BOOST_TEST(x.count(10) == 1);
+    test::check_equivalent_keys(x);
+
+    x.insert(x.cbegin(), 20);
+    BOOST_TEST(x.size() == 2);
+    BOOST_TEST(x.count(10) == 1);
+    BOOST_TEST(x.count(20) == 1);
+    test::check_equivalent_keys(x);
+}
+
+}
+
+RUN_TESTS()

test/unordered/insert_stable_tests.cpp

@@ -49,6 +49,8 @@ UNORDERED_AUTO_TEST(stable_insert_test1) {
     x.insert(insert_stable::member(1,2));
     x.insert(insert_stable::member(1,3));
 
+    BOOST_TEST(x.count(insert_stable::member(1,4)) == 3);
+
     boost::unordered_multiset<insert_stable::member>::const_iterator
         it = x.begin(), end = x.end();
     BOOST_TEST(it != end);
@@ -66,10 +68,11 @@ UNORDERED_AUTO_TEST(stable_insert_test2) {
         boost::unordered_multimap<insert_stable::member, int>::const_iterator
         iterator;
 
-    iterator it
-        = x.insert(x.end(), std::make_pair(insert_stable::member(1,1), 1));
-    it = x.insert(it, std::make_pair(insert_stable::member(1,2), 2));
-    it = x.insert(it, std::make_pair(insert_stable::member(1,3), 3));
+    iterator it = x.emplace(insert_stable::member(1,1), 1);
+    it = x.emplace(insert_stable::member(1,2), 2);
+    it = x.emplace(insert_stable::member(1,3), 3);
+
+    BOOST_TEST(x.count(insert_stable::member(1,4)) == 3);
 
     it = x.begin();
     iterator end = x.end();