[DEV] add v1.66.0

libs/unordered/test/unordered/allocator_traits.cpp

@@ -0,0 +1,280 @@
+
+// Copyright 2011 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 <boost/detail/lightweight_test.hpp>
+#include <boost/limits.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/unordered/detail/implementation.hpp>
+
+// Boilerplate
+
+#define ALLOCATOR_METHODS(name)                                                \
+  template <typename U> struct rebind                                          \
+  {                                                                            \
+    typedef name<U> other;                                                     \
+  };                                                                           \
+                                                                               \
+  name() {}                                                                    \
+  template <typename Y> name(name<Y> const&) {}                                \
+  T* address(T& r) { return &r; }                                              \
+  T const* address(T const& r) { return &r; }                                  \
+  T* allocate(std::size_t n)                                                   \
+  {                                                                            \
+    return static_cast<T*>(::operator new(n * sizeof(T)));                     \
+  }                                                                            \
+  T* allocate(std::size_t n, void const*)                                      \
+  {                                                                            \
+    return static_cast<T*>(::operator new(n * sizeof(T)));                     \
+  }                                                                            \
+  void deallocate(T* p, std::size_t) { ::operator delete((void*)p); }          \
+  void construct(T* p, T const& t) { new (p) T(t); }                           \
+  void destroy(T* p) { p->~T(); }                                              \
+  std::size_t max_size() const                                                 \
+  {                                                                            \
+    return (std::numeric_limits<std::size_t>::max)();                          \
+  }                                                                            \
+  bool operator==(name<T> const&) { return true; }                             \
+  bool operator!=(name<T> const&) { return false; }                            \
+/**/
+
+#define ALLOCATOR_METHODS_TYPEDEFS(name)                                       \
+  template <typename U> struct rebind                                          \
+  {                                                                            \
+    typedef name<U> other;                                                     \
+  };                                                                           \
+                                                                               \
+  name() {}                                                                    \
+  template <typename Y> name(name<Y> const&) {}                                \
+  pointer address(T& r) { return &r; }                                         \
+  const_pointer address(T const& r) { return &r; }                             \
+  pointer allocate(std::size_t n)                                              \
+  {                                                                            \
+    return pointer(::operator new(n * sizeof(T)));                             \
+  }                                                                            \
+  pointer allocate(std::size_t n, void const*)                                 \
+  {                                                                            \
+    return pointer(::operator new(n * sizeof(T)));                             \
+  }                                                                            \
+  void deallocate(pointer p, std::size_t) { ::operator delete((void*)p); }     \
+  void construct(T* p, T const& t) { new (p) T(t); }                           \
+  void destroy(T* p) { p->~T(); }                                              \
+  size_type max_size() const                                                   \
+  {                                                                            \
+    return (std::numeric_limits<size_type>::max)();                            \
+  }                                                                            \
+  bool operator==(name<T> const&) { return true; }                             \
+  bool operator!=(name<T> const&) { return false; }                            \
+/**/
+
+struct yes_type
+{
+  enum
+  {
+    value = true
+  };
+};
+struct no_type
+{
+  enum
+  {
+    value = false
+  };
+};
+
+// For tracking calls...
+
+static int selected;
+void reset() { selected = 0; }
+
+template <typename Allocator> int call_select()
+{
+  typedef boost::unordered::detail::allocator_traits<Allocator> traits;
+  Allocator a;
+
+  reset();
+  BOOST_TEST(traits::select_on_container_copy_construction(a) == a);
+  return selected;
+}
+
+// Empty allocator test
+
+template <typename T> struct empty_allocator
+{
+  typedef T value_type;
+  ALLOCATOR_METHODS(empty_allocator)
+};
+
+void test_empty_allocator()
+{
+  typedef empty_allocator<int> allocator;
+  typedef boost::unordered::detail::allocator_traits<allocator> traits;
+#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
+  BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
+    std::make_unsigned<std::ptrdiff_t>::type>::value));
+#else
+  BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
+#endif
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, int*>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<traits::const_pointer, int const*>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
+  BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_swap::value);
+  BOOST_TEST(call_select<allocator>() == 0);
+}
+
+// allocator 1
+
+template <typename T> struct allocator1
+{
+  typedef T value_type;
+  ALLOCATOR_METHODS(allocator1)
+
+  typedef yes_type propagate_on_container_copy_assignment;
+  typedef yes_type propagate_on_container_move_assignment;
+  typedef yes_type propagate_on_container_swap;
+
+  allocator1<T> select_on_container_copy_construction() const
+  {
+    ++selected;
+    return allocator1<T>();
+  }
+};
+
+void test_allocator1()
+{
+  typedef allocator1<int> allocator;
+  typedef boost::unordered::detail::allocator_traits<allocator> traits;
+#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
+  BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
+    std::make_unsigned<std::ptrdiff_t>::type>::value));
+#else
+  BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
+#endif
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, int*>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<traits::const_pointer, int const*>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
+  BOOST_TEST(traits::propagate_on_container_copy_assignment::value);
+  BOOST_TEST(traits::propagate_on_container_move_assignment::value);
+  BOOST_TEST(traits::propagate_on_container_swap::value);
+  BOOST_TEST(call_select<allocator>() == 1);
+}
+
+// allocator 2
+
+template <typename Alloc> struct allocator2_base
+{
+  Alloc select_on_container_copy_construction() const
+  {
+    ++selected;
+    return Alloc();
+  }
+};
+
+template <typename T> struct allocator2 : allocator2_base<allocator2<T> >
+{
+  typedef T value_type;
+  typedef T* pointer;
+  typedef T const* const_pointer;
+  typedef std::size_t size_type;
+
+  ALLOCATOR_METHODS(allocator2)
+
+  typedef no_type propagate_on_container_copy_assignment;
+  typedef no_type propagate_on_container_move_assignment;
+  typedef no_type propagate_on_container_swap;
+};
+
+void test_allocator2()
+{
+  typedef allocator2<int> allocator;
+  typedef boost::unordered::detail::allocator_traits<allocator> traits;
+  BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, int*>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<traits::const_pointer, int const*>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
+  BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_swap::value);
+  BOOST_TEST(call_select<allocator>() == 1);
+}
+
+// allocator 3
+
+template <typename T> struct ptr
+{
+  T* value_;
+
+  ptr(void* v) : value_((T*)v) {}
+  T& operator*() const { return *value_; }
+};
+
+template <> struct ptr<void>
+{
+  void* value_;
+  ptr(void* v) : value_(v) {}
+};
+
+template <> struct ptr<const void>
+{
+  void const* value_;
+  ptr(void const* v) : value_(v) {}
+};
+
+template <typename T> struct allocator3
+{
+  typedef T value_type;
+  typedef ptr<T> pointer;
+  typedef ptr<T const> const_pointer;
+  typedef unsigned short size_type;
+
+  ALLOCATOR_METHODS_TYPEDEFS(allocator3)
+
+  typedef yes_type propagate_on_container_copy_assignment;
+  typedef no_type propagate_on_container_move_assignment;
+
+  allocator3<T> select_on_container_copy_construction() const
+  {
+    ++selected;
+    return allocator3<T>();
+  }
+};
+
+void test_allocator3()
+{
+  typedef allocator3<int> allocator;
+  typedef boost::unordered::detail::allocator_traits<allocator> traits;
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<traits::size_type, unsigned short>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, ptr<int> >::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<traits::const_pointer, ptr<int const> >::value));
+  BOOST_STATIC_ASSERT((boost::is_same<traits::value_type, int>::value));
+  BOOST_TEST(traits::propagate_on_container_copy_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_swap::value);
+  BOOST_TEST(call_select<allocator>() == 1);
+}
+
+int main()
+{
+  test_empty_allocator();
+  test_allocator1();
+  test_allocator2();
+  test_allocator3();
+  return boost::report_errors();
+}

libs/unordered/test/unordered/assign_tests.cpp

@@ -0,0 +1,297 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include "../objects/test.hpp"
+#include "../objects/cxx11_allocator.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+#include "../helpers/equivalent.hpp"
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable : 4127) // conditional expression is constant
+#endif
+
+namespace assign_tests {
+
+  test::seed_t initialize_seed(96785);
+
+  template <class T> void assign_tests1(T*, test::random_generator generator)
+  {
+    BOOST_DEDUCED_TYPENAME T::hasher hf;
+    BOOST_DEDUCED_TYPENAME T::key_equal eq;
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests1.1\n";
+    {
+      test::check_instances check_;
+
+      T x;
+      x = x;
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests1.2\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(1000, generator);
+      T x(v.begin(), v.end());
+
+      test::ordered<T> tracker = test::create_ordered(x);
+      tracker.insert_range(v.begin(), v.end());
+
+      x = x;
+      tracker.compare(x);
+
+      T y;
+      y.max_load_factor(x.max_load_factor() / 20);
+      float mlf = x.max_load_factor();
+      y = x;
+      tracker.compare(x);
+      tracker.compare(y);
+      BOOST_TEST(x.max_load_factor() == mlf);
+      BOOST_TEST(y.max_load_factor() == mlf);
+      BOOST_TEST(y.load_factor() <= y.max_load_factor());
+    }
+  }
+
+  template <class T> void assign_tests2(T*, test::random_generator generator)
+  {
+    BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
+    BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
+    BOOST_DEDUCED_TYPENAME T::key_equal eq1(1);
+    BOOST_DEDUCED_TYPENAME T::key_equal eq2(2);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
+
+    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.0 - empty container\n";
+    {
+      test::check_instances check_;
+
+      T x1(0, hf1, eq1);
+      T x2(0, hf2, eq2);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x1.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x1.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+      test::check_container(x1, x2);
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.1\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(1000, generator);
+      T x1(v.begin(), v.end(), 0, hf1, eq1);
+      T x2(0, hf2, eq2);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x1.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x1.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+      test::check_container(x1, v);
+      test::check_container(x2, v);
+      BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.1a\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v1(0, generator);
+      test::random_values<T> v2(1000, generator);
+      T x1(0, hf2, eq2);
+      T x2(v2.begin(), v2.end(), 0, hf1, eq1);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x1.hash_function(), hf2));
+      BOOST_TEST(test::equivalent(x1.key_eq(), eq2));
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf2));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq2));
+      test::check_container(x1, v1);
+      test::check_container(x2, v1);
+      BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.2\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v1(100, generator), v2(100, generator);
+      T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
+      T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+      if (allocator_type::is_propagate_on_assign) {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
+      } else {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
+      }
+      test::check_container(x1, v1);
+      test::check_container(x2, v1);
+      BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.3\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v1(100, generator), v2(1000, generator);
+      T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
+      T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+      if (allocator_type::is_propagate_on_assign) {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
+      } else {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
+      }
+      test::check_container(x1, v1);
+      test::check_container(x2, v1);
+      BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.4\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v1(1000, generator), v2(100, generator);
+      T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
+      T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
+      x2 = x1;
+      BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+      if (allocator_type::is_propagate_on_assign) {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
+      } else {
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
+        BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
+      }
+      test::check_container(x1, v1);
+      test::check_container(x2, v1);
+      BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
+    }
+  }
+
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    std::allocator<test::object> >* test_map_std_alloc;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_set;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multiset;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_map;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator1<test::object> >* test_multimap;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_assign> >*
+    test_set_prop_assign;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_assign> >*
+    test_multiset_prop_assign;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_assign> >*
+    test_map_prop_assign;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_assign> >*
+    test_multimap_prop_assign;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+    test_set_no_prop_assign;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+    test_multiset_no_prop_assign;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+    test_map_no_prop_assign;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_assign> >*
+    test_multimap_no_prop_assign;
+
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+  template <typename T> bool is_propagate(T*)
+  {
+    return T::allocator_type::is_propagate_on_assign;
+  }
+
+  UNORDERED_AUTO_TEST (check_traits) {
+    BOOST_TEST(!is_propagate(test_set));
+    BOOST_TEST(is_propagate(test_set_prop_assign));
+    BOOST_TEST(!is_propagate(test_set_no_prop_assign));
+  }
+
+  UNORDERED_TEST(assign_tests1,
+    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)(
+      test_set_prop_assign)(test_multiset_prop_assign)(test_map_prop_assign)(
+      test_multimap_prop_assign)(test_set_no_prop_assign)(
+      test_multiset_no_prop_assign)(test_map_no_prop_assign)(
+      test_multimap_no_prop_assign))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(
+    assign_tests2, ((test_set)(test_multiset)(test_map)(test_multimap)(
+                     test_set_prop_assign)(test_multiset_prop_assign)(
+                     test_map_prop_assign)(test_multimap_prop_assign)(
+                     test_set_no_prop_assign)(test_multiset_no_prop_assign)(
+                     test_map_no_prop_assign)(test_multimap_no_prop_assign))(
+                     (default_generator)(generate_collisions)(limited_range)))
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+
+  UNORDERED_AUTO_TEST (assign_default_initializer_list) {
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
+    std::initializer_list<std::pair<int const, int> > init;
+    boost::unordered_map<int, int> x1;
+    x1[25] = 3;
+    x1[16] = 10;
+    BOOST_TEST(!x1.empty());
+    x1 = init;
+    BOOST_TEST(x1.empty());
+  }
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  UNORDERED_AUTO_TEST (assign_initializer_list) {
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
+
+    boost::unordered_set<int> x;
+    x.insert(10);
+    x.insert(20);
+    x = {1, 2, -10};
+    BOOST_TEST(x.find(10) == x.end());
+    BOOST_TEST(x.find(-10) != x.end());
+  }
+
+#endif
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/at_tests.cpp

@@ -0,0 +1,67 @@
+
+// Copyright 2007-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include <string>
+
+namespace at_tests {
+
+  UNORDERED_AUTO_TEST (at_tests) {
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Create Map" << std::endl;
+
+    boost::unordered_map<std::string, int> x;
+    boost::unordered_map<std::string, int> const& x_const(x);
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check empty container" << std::endl;
+
+    try {
+      x.at("one");
+      BOOST_ERROR("Should have thrown.");
+    } catch (std::out_of_range) {
+    }
+
+    try {
+      x_const.at("one");
+      BOOST_ERROR("Should have thrown.");
+    } catch (std::out_of_range) {
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Add elements" << std::endl;
+
+    x["one"] = 1;
+    x["two"] = 2;
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check existing elements" << std::endl;
+
+    BOOST_TEST(x.at("one") == 1);
+    BOOST_TEST(x.at("two") == 2);
+    BOOST_TEST(x_const.at("one") == 1);
+    BOOST_TEST(x_const.at("two") == 2);
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check missing element" << std::endl;
+
+    try {
+      x.at("three");
+      BOOST_ERROR("Should have thrown.");
+    } catch (std::out_of_range) {
+    }
+
+    try {
+      x_const.at("three");
+      BOOST_ERROR("Should have thrown.");
+    } catch (std::out_of_range) {
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Finished" << std::endl;
+  }
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/bucket_tests.cpp

@@ -0,0 +1,95 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include <algorithm>
+#include "../objects/test.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/helpers.hpp"
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
+#pragma warning(disable : 4267) // conversion from 'size_t' to 'unsigned int',
+                                // possible loss of data.
+#endif
+
+namespace bucket_tests {
+
+  test::seed_t initialize_seed(54635);
+
+  template <class X> void tests(X*, test::random_generator generator)
+  {
+    test::check_instances check_;
+
+    typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
+    typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
+    test::random_values<X> v(1000, generator);
+
+    X x(v.begin(), v.end());
+
+    BOOST_TEST(x.bucket_count() <= x.max_bucket_count());
+    if (!(x.bucket_count() <= x.max_bucket_count())) {
+      BOOST_LIGHTWEIGHT_TEST_OSTREAM << x.bucket_count()
+                                     << "<=" << x.max_bucket_count() << "\n";
+    }
+
+    for (BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
+           it = v.begin(),
+           end = v.end();
+         it != end; ++it) {
+      size_type bucket = x.bucket(test::get_key<X>(*it));
+
+      BOOST_TEST(bucket < x.bucket_count());
+      if (bucket < x.bucket_count()) {
+        // lit? lend?? I need a new naming scheme.
+        const_local_iterator lit = x.begin(bucket), lend = x.end(bucket);
+        while (lit != lend && test::get_key<X>(*it) != test::get_key<X>(*lit)) {
+          ++lit;
+        }
+        BOOST_TEST(lit != lend);
+      }
+    }
+
+    for (size_type i = 0; i < x.bucket_count(); ++i) {
+      BOOST_TEST(x.bucket_size(i) ==
+                 static_cast<size_type>(std::distance(x.begin(i), x.end(i))));
+      BOOST_TEST(x.bucket_size(i) ==
+                 static_cast<size_type>(std::distance(x.cbegin(i), x.cend(i))));
+      X const& x_ref = x;
+      BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(std::distance(
+                                       x_ref.begin(i), x_ref.end(i))));
+      BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(std::distance(
+                                       x_ref.cbegin(i), x_ref.cend(i))));
+    }
+  }
+
+  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::allocator2<test::object> >* test_set;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_multiset;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_map;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator2<test::object> >* test_multimap;
+
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+  UNORDERED_TEST(tests,
+    ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(
+      test_multimap))((default_generator)(generate_collisions)(limited_range)))
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/compile_map.cpp

@@ -0,0 +1,248 @@
+
+// Copyright 2006-2009 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)
+
+// This test creates the containers with members that meet their minimum
+// requirements. Makes sure everything compiles and is defined correctly.
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include "../objects/minimal.hpp"
+#include "./compile_tests.hpp"
+
+// Explicit instantiation to catch compile-time errors
+
+#define INSTANTIATE(type)                                                      \
+  template class boost::unordered::detail::instantiate_##type
+
+INSTANTIATE(map)<int, int, boost::hash<int>, std::equal_to<int>,
+  test::minimal::allocator<int> >;
+INSTANTIATE(multimap)<int const, int const, boost::hash<int>,
+  std::equal_to<int>, test::minimal::allocator<int> >;
+
+INSTANTIATE(
+  map)<test::minimal::assignable const, test::minimal::default_assignable const,
+  test::minimal::hash<test::minimal::assignable>,
+  test::minimal::equal_to<test::minimal::assignable>,
+  test::minimal::allocator<int> >;
+INSTANTIATE(multimap)<test::minimal::assignable, test::minimal::assignable,
+  test::minimal::hash<test::minimal::assignable>,
+  test::minimal::equal_to<test::minimal::assignable>,
+  test::minimal::allocator<int> >;
+
+UNORDERED_AUTO_TEST (test0) {
+  test::minimal::constructor_param x;
+
+  typedef std::pair<test::minimal::assignable const, test::minimal::assignable>
+    value_type;
+  value_type value(x, x);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
+
+  boost::unordered_map<int, int> int_map;
+
+  boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<std::pair<int const, int> > >
+    int_map2;
+
+  boost::unordered_map<test::minimal::assignable, test::minimal::assignable,
+    test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<value_type> >
+    map;
+
+  container_test(int_map, std::pair<int const, int>(0, 0));
+  container_test(int_map2, std::pair<int const, int>(0, 0));
+  container_test(map, value);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+
+  boost::unordered_multimap<int, int> int_multimap;
+
+  boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<std::pair<int const, int> > >
+    int_multimap2;
+
+  boost::unordered_multimap<test::minimal::assignable,
+    test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<value_type> >
+    multimap;
+
+  container_test(int_multimap, std::pair<int const, int>(0, 0));
+  container_test(int_multimap2, std::pair<int const, int>(0, 0));
+  container_test(multimap, value);
+}
+
+UNORDERED_AUTO_TEST (equality_tests) {
+  typedef std::pair<test::minimal::copy_constructible_equality_comparable const,
+    test::minimal::copy_constructible_equality_comparable>
+    value_type;
+
+  boost::unordered_map<int, int> int_map;
+
+  boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<std::pair<int const, int> > >
+    int_map2;
+
+  boost::unordered_map<test::minimal::copy_constructible_equality_comparable,
+    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> >
+    map;
+
+  equality_test(int_map);
+  equality_test(int_map2);
+  equality_test(map);
+
+  boost::unordered_multimap<int, int> int_multimap;
+
+  boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<std::pair<int const, int> > >
+    int_multimap2;
+
+  boost::unordered_multimap<
+    test::minimal::copy_constructible_equality_comparable,
+    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> >
+    multimap;
+
+  equality_test(int_multimap);
+  equality_test(int_multimap2);
+  equality_test(multimap);
+}
+
+UNORDERED_AUTO_TEST (test1) {
+  boost::hash<int> hash;
+  std::equal_to<int> equal_to;
+  int value = 0;
+  std::pair<int const, int> map_value(0, 0);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
+
+  boost::unordered_map<int, int> map;
+
+  boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<std::pair<int const, int> > >
+    map2;
+
+  unordered_unique_test(map, map_value);
+  unordered_map_test(map, value, value);
+  unordered_copyable_test(map, value, map_value, hash, equal_to);
+  unordered_map_functions(map, value, value);
+
+  unordered_unique_test(map2, map_value);
+  unordered_map_test(map2, value, value);
+  unordered_copyable_test(map2, value, map_value, hash, equal_to);
+  unordered_map_functions(map2, value, value);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+
+  boost::unordered_multimap<int, int> multimap;
+
+  boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<std::pair<int const, int> > >
+    multimap2;
+
+  unordered_equivalent_test(multimap, map_value);
+  unordered_map_test(multimap, value, value);
+  unordered_copyable_test(multimap, value, map_value, hash, equal_to);
+
+  unordered_equivalent_test(multimap2, map_value);
+  unordered_map_test(multimap2, value, value);
+  unordered_copyable_test(multimap2, value, map_value, hash, equal_to);
+}
+
+UNORDERED_AUTO_TEST (test2) {
+  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);
+
+  typedef std::pair<test::minimal::assignable const, test::minimal::assignable>
+    map_value_type;
+  map_value_type map_value(assignable, assignable);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
+
+  boost::unordered_map<test::minimal::assignable, test::minimal::assignable,
+    test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<map_value_type> >
+    map;
+
+  unordered_unique_test(map, map_value);
+  unordered_map_test(map, assignable, assignable);
+  unordered_copyable_test(map, assignable, map_value, hash, equal_to);
+  unordered_map_member_test(map, map_value);
+
+  boost::unordered_map<test::minimal::assignable,
+    test::minimal::default_assignable,
+    test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<map_value_type> >
+    map2;
+
+  test::minimal::default_assignable default_assignable;
+
+  unordered_map_functions(map2, assignable, default_assignable);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+
+  boost::unordered_multimap<test::minimal::assignable,
+    test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<map_value_type> >
+    multimap;
+
+  unordered_equivalent_test(multimap, map_value);
+  unordered_map_test(multimap, assignable, assignable);
+  unordered_copyable_test(multimap, assignable, map_value, hash, equal_to);
+  unordered_map_member_test(multimap, map_value);
+}
+
+// Test for ambiguity when using key convertible from iterator
+// See LWG2059
+
+struct lwg2059_key
+{
+  int value;
+
+  template <typename T> lwg2059_key(T v) : value(v) {}
+};
+
+std::size_t hash_value(lwg2059_key x)
+{
+  return static_cast<std::size_t>(x.value);
+}
+
+bool operator==(lwg2059_key x, lwg2059_key y) { return x.value == y.value; }
+
+UNORDERED_AUTO_TEST (lwg2059) {
+  {
+    boost::unordered_map<lwg2059_key, int> x;
+    x.emplace(lwg2059_key(10), 5);
+    x.erase(x.begin());
+  }
+
+  {
+    boost::unordered_multimap<lwg2059_key, int> x;
+    x.emplace(lwg2059_key(10), 5);
+    x.erase(x.begin());
+  }
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/compile_set.cpp

@@ -0,0 +1,313 @@
+
+// Copyright 2006-2009 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)
+
+// This test creates the containers with members that meet their minimum
+// requirements. Makes sure everything compiles and is defined correctly.
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include "../objects/minimal.hpp"
+#include "./compile_tests.hpp"
+
+// Explicit instantiation to catch compile-time errors
+
+#define INSTANTIATE(type)                                                      \
+  template class boost::unordered::detail::instantiate_##type
+
+INSTANTIATE(set)<int, boost::hash<int>, std::equal_to<int>,
+  test::minimal::allocator<int> >;
+INSTANTIATE(multiset)<int const, boost::hash<int>, std::equal_to<int>,
+  test::minimal::allocator<int> >;
+
+INSTANTIATE(set)<test::minimal::assignable const,
+  test::minimal::hash<test::minimal::assignable>,
+  test::minimal::equal_to<test::minimal::assignable>,
+  test::minimal::allocator<int> >;
+INSTANTIATE(multiset)<test::minimal::assignable,
+  test::minimal::hash<test::minimal::assignable>,
+  test::minimal::equal_to<test::minimal::assignable>,
+  test::minimal::allocator<int> >;
+
+UNORDERED_AUTO_TEST (test0) {
+  test::minimal::constructor_param x;
+
+  test::minimal::assignable assignable(x);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "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>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<test::minimal::assignable> >
+    set;
+
+  container_test(int_set, 0);
+  container_test(int_set2, 0);
+  container_test(set, assignable);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "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>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    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::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::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::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);
+}
+
+UNORDERED_AUTO_TEST (test1) {
+  boost::hash<int> hash;
+  std::equal_to<int> equal_to;
+  int value = 0;
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set." << std::endl;
+
+  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_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);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset." << std::endl;
+
+  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_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::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);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+
+  boost::unordered_set<test::minimal::assignable,
+    test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<test::minimal::assignable> >
+    set;
+
+  unordered_unique_test(set, assignable);
+  unordered_set_test(set, assignable);
+  unordered_copyable_test(set, assignable, assignable, hash, equal_to);
+  unordered_set_member_test(set, assignable);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+
+  boost::unordered_multiset<test::minimal::assignable,
+    test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<test::minimal::assignable> >
+    multiset;
+
+  unordered_equivalent_test(multiset, assignable);
+  unordered_set_test(multiset, assignable);
+  unordered_copyable_test(multiset, assignable, assignable, hash, equal_to);
+  unordered_set_member_test(multiset, assignable);
+}
+
+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);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "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);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "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);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "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);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "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);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "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);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "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);
+}
+
+// Test for ambiguity when using key convertible from iterator
+// See LWG2059
+
+struct lwg2059_key
+{
+  int value;
+
+  template <typename T> lwg2059_key(T v) : value(v) {}
+};
+
+std::size_t hash_value(lwg2059_key x)
+{
+  return static_cast<std::size_t>(x.value);
+}
+
+bool operator==(lwg2059_key x, lwg2059_key y) { return x.value == y.value; }
+
+UNORDERED_AUTO_TEST (lwg2059) {
+  {
+    boost::unordered_set<lwg2059_key> x;
+    x.emplace(lwg2059_key(10));
+    x.erase(x.begin());
+  }
+
+  {
+    boost::unordered_multiset<lwg2059_key> x;
+    x.emplace(lwg2059_key(10));
+    x.erase(x.begin());
+  }
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/compile_tests.hpp

@@ -0,0 +1,840 @@
+
+// Copyright 2005-2009 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)
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable : 4100) // unreferenced formal parameter
+#pragma warning(disable : 4610) // class can never be instantiated
+#pragma warning(disable : 4510) // default constructor could not be generated
+#endif
+
+#include <boost/concept_check.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#include "../helpers/check_return_type.hpp"
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/limits.hpp>
+#include <boost/predef.h>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/cv_traits.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/utility/swap.hpp>
+
+typedef long double comparison_type;
+
+template <class T> void sink(T const&) {}
+template <class T> T rvalue(T const& v) { return v; }
+template <class T> T rvalue_default() { return T(); }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+template <class T> T implicit_construct() { return {}; }
+#else
+template <class T> int implicit_construct()
+{
+  T x;
+  sink(x);
+  return 0;
+}
+#endif
+
+#if !defined(BOOST_NO_CXX11_NOEXCEPT)
+#define TEST_NOEXCEPT_EXPR(x) BOOST_STATIC_ASSERT((BOOST_NOEXCEPT_EXPR(x)));
+#else
+#define TEST_NOEXCEPT_EXPR(x)
+#endif
+
+template <class X, class T> void container_test(X& r, T const&)
+{
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::difference_type difference_type;
+  typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
+
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<iterator>::type
+    iterator_value_type;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<const_iterator>::type
+    const_iterator_value_type;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<iterator>::type
+    iterator_difference_type;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<
+    const_iterator>::type const_iterator_difference_type;
+
+  typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
+  typedef BOOST_DEDUCED_TYPENAME X::reference reference;
+  typedef BOOST_DEDUCED_TYPENAME X::const_reference const_reference;
+
+  typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
+
+  typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+
+  // value_type
+
+  BOOST_STATIC_ASSERT((boost::is_same<T, value_type>::value));
+  boost::function_requires<boost::CopyConstructibleConcept<X> >();
+
+  // reference_type / const_reference_type
+
+  BOOST_STATIC_ASSERT((boost::is_same<T&, reference>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<T const&, const_reference>::value));
+
+  // iterator
+
+  boost::function_requires<boost::InputIteratorConcept<iterator> >();
+  BOOST_STATIC_ASSERT((boost::is_same<T, iterator_value_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_convertible<iterator, const_iterator>::value));
+
+  // const_iterator
+
+  boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
+  BOOST_STATIC_ASSERT((boost::is_same<T, const_iterator_value_type>::value));
+
+  // node_type
+
+  BOOST_STATIC_ASSERT((boost::is_same<allocator_type,
+    BOOST_DEDUCED_TYPENAME node_type::allocator_type>::value));
+
+  // difference_type
+
+  BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_signed);
+  BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_integer);
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<difference_type, iterator_difference_type>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<difference_type, const_iterator_difference_type>::value));
+
+  // size_type
+
+  BOOST_STATIC_ASSERT(!std::numeric_limits<size_type>::is_signed);
+  BOOST_STATIC_ASSERT(std::numeric_limits<size_type>::is_integer);
+
+  // size_type can represent any non-negative value type of difference_type
+  // I'm not sure about either of these tests...
+  size_type max_diff =
+    static_cast<size_type>((std::numeric_limits<difference_type>::max)());
+  difference_type converted_diff(static_cast<difference_type>(max_diff));
+  BOOST_TEST((std::numeric_limits<difference_type>::max)() == converted_diff);
+
+  BOOST_TEST(
+    static_cast<comparison_type>((std::numeric_limits<size_type>::max)()) >
+    static_cast<comparison_type>(
+      (std::numeric_limits<difference_type>::max)()));
+
+// Constructors
+
+// I don't test the runtime post-conditions here.
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  // It isn't specified in the container requirements that the no argument
+  // constructor is implicit, but it is defined that way in the concrete
+  // container specification.
+  X u_implicit = {};
+  sink(u_implicit);
+#endif
+
+  X u;
+  BOOST_TEST(u.size() == 0);
+  BOOST_TEST(X().size() == 0);
+
+  X a, b;
+  X a_const;
+
+  sink(X(a));
+  X u2(a);
+  X u3 = a;
+  X u4(rvalue(a_const));
+  X u5 = rvalue(a_const);
+
+  a.swap(b);
+  boost::swap(a, b);
+  test::check_return_type<X>::equals_ref(r = a);
+
+  // Allocator
+
+  test::check_return_type<allocator_type>::equals(a_const.get_allocator());
+
+  allocator_type m = a.get_allocator();
+  sink(X(m));
+  X c(m);
+  sink(X(a_const, m));
+  X c2(a_const, m);
+  sink(X(rvalue(a_const), m));
+  X c3(rvalue(a_const), m);
+
+  // node_type
+
+  implicit_construct<node_type const>();
+#if !BOOST_COMP_GNUC || BOOST_COMP_GNUC >= BOOST_VERSION_NUMBER(4, 8, 0)
+  TEST_NOEXCEPT_EXPR(node_type());
+#endif
+
+  node_type n1;
+  node_type n2(rvalue_default<node_type>());
+#if !BOOST_COMP_GNUC || BOOST_COMP_GNUC >= BOOST_VERSION_NUMBER(4, 8, 0)
+  TEST_NOEXCEPT_EXPR(node_type(boost::move(n1)));
+#endif
+  node_type n3;
+  n3 = boost::move(n2);
+  n1.swap(n3);
+  swap(n1, n3);
+  // TODO: noexcept for swap?
+  // value, key, mapped tests in map and set specific testing.
+
+  node_type const n_const;
+  BOOST_TEST(n_const ? 0 : 1);
+  TEST_NOEXCEPT_EXPR(n_const ? 0 : 1);
+  test::check_return_type<bool>::equals(!n_const);
+  test::check_return_type<bool>::equals(n_const.empty());
+  TEST_NOEXCEPT_EXPR(!n_const);
+  TEST_NOEXCEPT_EXPR(n_const.empty());
+
+  // Avoid unused variable warnings:
+
+  sink(u);
+  sink(u2);
+  sink(u3);
+  sink(u4);
+  sink(u5);
+  sink(c);
+  sink(c2);
+  sink(c3);
+}
+
+template <class X> void unordered_destructible_test(X&)
+{
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
+
+  X x1;
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+  X x2(rvalue_default<X>());
+  X x3 = rvalue_default<X>();
+// This can only be done if propagate_on_container_move_assignment::value
+// is true.
+// x2 = rvalue_default<X>();
+#endif
+
+  X* ptr = new X();
+  X& a1 = *ptr;
+  (&a1)->~X();
+  ::operator delete((void*)(&a1));
+
+  X a, b;
+  X const a_const;
+  test::check_return_type<iterator>::equals(a.begin());
+  test::check_return_type<const_iterator>::equals(a_const.begin());
+  test::check_return_type<const_iterator>::equals(a.cbegin());
+  test::check_return_type<const_iterator>::equals(a_const.cbegin());
+  test::check_return_type<iterator>::equals(a.end());
+  test::check_return_type<const_iterator>::equals(a_const.end());
+  test::check_return_type<const_iterator>::equals(a.cend());
+  test::check_return_type<const_iterator>::equals(a_const.cend());
+
+  a.swap(b);
+  boost::swap(a, b);
+
+  test::check_return_type<size_type>::equals(a.size());
+  test::check_return_type<size_type>::equals(a.max_size());
+  test::check_return_type<bool>::convertible(a.empty());
+
+  // Allocator
+
+  typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+  test::check_return_type<allocator_type>::equals(a_const.get_allocator());
+}
+
+template <class X, class Key> void unordered_set_test(X& r, Key const&)
+{
+  typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
+  typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
+
+  BOOST_STATIC_ASSERT((boost::is_same<value_type, key_type>::value));
+
+  // iterator pointer / const_pointer_type
+
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::local_iterator local_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<iterator>::type
+    iterator_pointer;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<const_iterator>::type
+    const_iterator_pointer;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<local_iterator>::type
+    local_iterator_pointer;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<
+    const_local_iterator>::type const_local_iterator_pointer;
+
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<value_type const*, iterator_pointer>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<value_type const*, const_iterator_pointer>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<value_type const*, local_iterator_pointer>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<value_type const*, const_local_iterator_pointer>::value));
+
+  typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME node_type::value_type node_value_type;
+  BOOST_STATIC_ASSERT((boost::is_same<value_type, node_value_type>::value));
+
+  // Call node_type functions.
+
+  test::minimal::constructor_param v;
+  Key k_lvalue(v);
+  r.emplace(boost::move(k_lvalue));
+  node_type n1 = r.extract(r.begin());
+  test::check_return_type<value_type>::equals_ref(n1.value());
+}
+
+template <class X, class Key, class T>
+void unordered_map_test(X& r, Key const& k, T const& v)
+{
+  typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
+  typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
+
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<value_type, std::pair<key_type const, T> >::value));
+
+  // iterator pointer / const_pointer_type
+
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::local_iterator local_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<iterator>::type
+    iterator_pointer;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<const_iterator>::type
+    const_iterator_pointer;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<local_iterator>::type
+    local_iterator_pointer;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<
+    const_local_iterator>::type const_local_iterator_pointer;
+
+  BOOST_STATIC_ASSERT((boost::is_same<value_type*, iterator_pointer>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<value_type const*, const_iterator_pointer>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<value_type*, local_iterator_pointer>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<value_type const*, const_local_iterator_pointer>::value));
+
+  typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME node_type::key_type node_key_type;
+  typedef BOOST_DEDUCED_TYPENAME node_type::mapped_type node_mapped_type;
+
+  BOOST_STATIC_ASSERT((boost::is_same<Key, node_key_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<T, node_mapped_type>::value));
+  // Superfluous,but just to make sure.
+  BOOST_STATIC_ASSERT((!boost::is_const<node_key_type>::value));
+
+  // Calling functions
+
+  r.insert(std::pair<Key const, T>(k, v));
+  r.insert(r.begin(), std::pair<Key const, T>(k, v));
+  std::pair<Key const, T> const value(k, v);
+  r.insert(value);
+  r.insert(r.end(), value);
+
+  Key k_lvalue(k);
+  T v_lvalue(v);
+
+  // Emplace
+
+  r.emplace(k, v);
+  r.emplace(k_lvalue, v_lvalue);
+  r.emplace(rvalue(k), rvalue(v));
+
+  r.emplace(boost::unordered::piecewise_construct, boost::make_tuple(k),
+    boost::make_tuple(v));
+
+  // Emplace with hint
+
+  r.emplace_hint(r.begin(), k, v);
+  r.emplace_hint(r.begin(), k_lvalue, v_lvalue);
+  r.emplace_hint(r.begin(), rvalue(k), rvalue(v));
+
+  r.emplace_hint(r.begin(), boost::unordered::piecewise_construct,
+    boost::make_tuple(k), boost::make_tuple(v));
+
+  // Extract
+
+  test::check_return_type<node_type>::equals(r.extract(r.begin()));
+
+  r.emplace(k, v);
+  test::check_return_type<node_type>::equals(r.extract(k));
+
+  r.emplace(k, v);
+  node_type n1 = r.extract(r.begin());
+  test::check_return_type<key_type>::equals_ref(n1.key());
+  test::check_return_type<T>::equals_ref(n1.mapped());
+
+  node_type n2 = boost::move(n1);
+  r.insert(boost::move(n2));
+  r.insert(r.extract(r.begin()));
+  n2 = r.extract(r.begin());
+  r.insert(r.begin(), boost::move(n2));
+  r.insert(r.end(), r.extract(r.begin()));
+
+  node_type n = r.extract(r.begin());
+  test::check_return_type<node_key_type>::equals_ref(n.key());
+  test::check_return_type<node_mapped_type>::equals_ref(n.mapped());
+}
+
+template <class X> void equality_test(X& r)
+{
+  X const a = r, b = r;
+
+  test::check_return_type<bool>::equals(a == b);
+  test::check_return_type<bool>::equals(a != b);
+  test::check_return_type<bool>::equals(boost::operator==(a, b));
+  test::check_return_type<bool>::equals(boost::operator!=(a, b));
+}
+
+template <class X, class T> void unordered_unique_test(X& r, T const& t)
+{
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  test::check_return_type<std::pair<iterator, bool> >::equals(r.insert(t));
+  test::check_return_type<std::pair<iterator, bool> >::equals(r.emplace(t));
+
+  typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME X::insert_return_type insert_return_type;
+
+  // insert_return_type
+
+  // TODO;
+  // boost::function_requires<
+  //     boost::MoveConstructibleConcept<insert_return_type>
+  // >();
+  // TODO;
+  // boost::function_requires<
+  //     boost::MoveAssignableConcept<insert_return_type>
+  // >();
+  boost::function_requires<
+    boost::DefaultConstructibleConcept<insert_return_type> >();
+  // TODO:
+  // boost::function_requires<
+  //     boost::DestructibleConcept<insert_return_type>
+  // >();
+  insert_return_type insert_return, insert_return2;
+  test::check_return_type<bool>::equals(insert_return.inserted);
+  test::check_return_type<iterator>::equals(insert_return.position);
+  test::check_return_type<node_type>::equals_ref(insert_return.node);
+  boost::swap(insert_return, insert_return2);
+}
+
+template <class X, class T> void unordered_equivalent_test(X& r, T const& t)
+{
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  test::check_return_type<iterator>::equals(r.insert(t));
+  test::check_return_type<iterator>::equals(r.emplace(t));
+}
+
+template <class X, class Key, class T>
+void unordered_map_functions(X&, Key const& k, T const& v)
+{
+  typedef BOOST_DEDUCED_TYPENAME X::mapped_type mapped_type;
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+
+  X a;
+  test::check_return_type<mapped_type>::equals_ref(a[k]);
+  test::check_return_type<mapped_type>::equals_ref(a[rvalue(k)]);
+  test::check_return_type<mapped_type>::equals_ref(a.at(k));
+  test::check_return_type<std::pair<iterator, bool> >::equals(
+    a.try_emplace(k, v));
+  test::check_return_type<std::pair<iterator, bool> >::equals(
+    a.try_emplace(rvalue(k), v));
+  test::check_return_type<iterator>::equals(a.try_emplace(a.begin(), k, v));
+  test::check_return_type<iterator>::equals(
+    a.try_emplace(a.begin(), rvalue(k), v));
+  test::check_return_type<std::pair<iterator, bool> >::equals(
+    a.insert_or_assign(k, v));
+  test::check_return_type<std::pair<iterator, bool> >::equals(
+    a.insert_or_assign(rvalue(k), v));
+  test::check_return_type<iterator>::equals(
+    a.insert_or_assign(a.begin(), k, v));
+  test::check_return_type<iterator>::equals(
+    a.insert_or_assign(a.begin(), rvalue(k), v));
+
+  X const b = a;
+  test::check_return_type<mapped_type const>::equals_ref(b.at(k));
+}
+
+template <class X, class Key, class Hash, class Pred>
+void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
+{
+  unordered_destructible_test(x);
+
+  typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
+  typedef BOOST_DEDUCED_TYPENAME X::hasher hasher;
+  typedef BOOST_DEDUCED_TYPENAME X::key_equal key_equal;
+  typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
+
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::local_iterator local_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
+
+  typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<iterator>::type
+    iterator_category;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<iterator>::type
+    iterator_difference;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<iterator>::type
+    iterator_pointer;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<iterator>::type
+    iterator_reference;
+
+  typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<
+    local_iterator>::type local_iterator_category;
+  typedef BOOST_DEDUCED_TYPENAME
+    boost::iterator_difference<local_iterator>::type local_iterator_difference;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<local_iterator>::type
+    local_iterator_pointer;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<local_iterator>::type
+    local_iterator_reference;
+
+  typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<
+    const_iterator>::type const_iterator_category;
+  typedef BOOST_DEDUCED_TYPENAME
+    boost::iterator_difference<const_iterator>::type const_iterator_difference;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<const_iterator>::type
+    const_iterator_pointer;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<const_iterator>::type
+    const_iterator_reference;
+
+  typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<
+    const_local_iterator>::type const_local_iterator_category;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<
+    const_local_iterator>::type const_local_iterator_difference;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<
+    const_local_iterator>::type const_local_iterator_pointer;
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<
+    const_local_iterator>::type const_local_iterator_reference;
+  typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+
+  BOOST_STATIC_ASSERT((boost::is_same<Key, key_type>::value));
+  // boost::function_requires<boost::CopyConstructibleConcept<key_type> >();
+  // boost::function_requires<boost::AssignableConcept<key_type> >();
+
+  BOOST_STATIC_ASSERT((boost::is_same<Hash, hasher>::value));
+  test::check_return_type<std::size_t>::equals(hf(k));
+
+  BOOST_STATIC_ASSERT((boost::is_same<Pred, key_equal>::value));
+  test::check_return_type<bool>::convertible(eq(k, k));
+
+  boost::function_requires<boost::InputIteratorConcept<local_iterator> >();
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<local_iterator_category, iterator_category>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<local_iterator_difference, iterator_difference>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<local_iterator_pointer, iterator_pointer>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<local_iterator_reference, iterator_reference>::value));
+
+  boost::function_requires<
+    boost::InputIteratorConcept<const_local_iterator> >();
+  BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_category,
+    const_iterator_category>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_difference,
+    const_iterator_difference>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_pointer,
+    const_iterator_pointer>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_reference,
+    const_iterator_reference>::value));
+
+  X a;
+  allocator_type m = a.get_allocator();
+
+  // Constructors
+
+  X(10, hf, eq);
+  X a1(10, hf, eq);
+  X(10, hf);
+  X a2(10, hf);
+  X(10);
+  X a3(10);
+  X();
+  X a4;
+
+  X(10, hf, eq, m);
+  X a1a(10, hf, eq, m);
+  X(10, hf, m);
+  X a2a(10, hf, m);
+  X(10, m);
+  X a3a(10, m);
+  (X(m));
+  X a4a(m);
+
+  test::check_return_type<size_type>::equals(a.erase(k));
+
+  const_iterator q1 = a.cbegin(), q2 = a.cend();
+  test::check_return_type<iterator>::equals(a.erase(q1, q2));
+
+  TEST_NOEXCEPT_EXPR(a.clear());
+  a.clear();
+
+  X const b;
+
+  test::check_return_type<hasher>::equals(b.hash_function());
+  test::check_return_type<key_equal>::equals(b.key_eq());
+
+  test::check_return_type<iterator>::equals(a.find(k));
+  test::check_return_type<const_iterator>::equals(b.find(k));
+  test::check_return_type<size_type>::equals(b.count(k));
+  test::check_return_type<std::pair<iterator, iterator> >::equals(
+    a.equal_range(k));
+  test::check_return_type<std::pair<const_iterator, const_iterator> >::equals(
+    b.equal_range(k));
+  test::check_return_type<size_type>::equals(b.bucket_count());
+  test::check_return_type<size_type>::equals(b.max_bucket_count());
+  test::check_return_type<size_type>::equals(b.bucket(k));
+  test::check_return_type<size_type>::equals(b.bucket_size(0));
+
+  test::check_return_type<local_iterator>::equals(a.begin(0));
+  test::check_return_type<const_local_iterator>::equals(b.begin(0));
+  test::check_return_type<local_iterator>::equals(a.end(0));
+  test::check_return_type<const_local_iterator>::equals(b.end(0));
+
+  test::check_return_type<const_local_iterator>::equals(a.cbegin(0));
+  test::check_return_type<const_local_iterator>::equals(b.cbegin(0));
+  test::check_return_type<const_local_iterator>::equals(a.cend(0));
+  test::check_return_type<const_local_iterator>::equals(b.cend(0));
+
+  test::check_return_type<float>::equals(b.load_factor());
+  test::check_return_type<float>::equals(b.max_load_factor());
+  a.max_load_factor((float)2.0);
+  a.rehash(100);
+
+  a.merge(a2);
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+  a.merge(rvalue_default<X>());
+#endif
+
+  // Avoid unused variable warnings:
+
+  sink(a);
+  sink(a1);
+  sink(a2);
+  sink(a3);
+  sink(a4);
+  sink(a1a);
+  sink(a2a);
+  sink(a3a);
+  sink(a4a);
+}
+
+template <class X, class Key, class T, class Hash, class Pred>
+void unordered_copyable_test(X& x, Key& k, T& t, Hash& hf, Pred& eq)
+{
+  unordered_test(x, k, hf, eq);
+
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+
+  X a;
+  allocator_type m = a.get_allocator();
+
+  BOOST_DEDUCED_TYPENAME X::value_type* i = 0;
+  BOOST_DEDUCED_TYPENAME X::value_type* j = 0;
+
+  // Constructors
+
+  X(i, j, 10, hf, eq);
+  X a5(i, j, 10, hf, eq);
+  X(i, j, 10, hf);
+  X a6(i, j, 10, hf);
+  X(i, j, 10);
+  X a7(i, j, 10);
+  X(i, j);
+  X a8(i, j);
+
+  X(i, j, 10, hf, eq, m);
+  X a5a(i, j, 10, hf, eq, m);
+  X(i, j, 10, hf, m);
+  X a6a(i, j, 10, hf, m);
+  X(i, j, 10, m);
+  X a7a(i, j, 10, m);
+
+// Not specified for some reason (maybe ambiguity with another constructor?)
+// X(i, j, m);
+// X a8a(i, j, m);
+// sink(a8a);
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  std::size_t min_buckets = 10;
+  X({t});
+  X({t}, min_buckets);
+  X({t}, min_buckets, hf);
+  X({t}, min_buckets, hf, eq);
+  // X({t}, m);
+  X({t}, min_buckets, m);
+  X({t}, min_buckets, hf, m);
+  X({t}, min_buckets, hf, eq, m);
+#endif
+
+  X const b;
+  sink(X(b));
+  X a9(b);
+  a = b;
+
+  sink(X(b, m));
+  X a9a(b, m);
+
+  X b1;
+  b1.insert(t);
+  X a9b(b1);
+  sink(a9b);
+  X a9c(b1, m);
+  sink(a9c);
+
+  const_iterator q = a.cbegin();
+
+  test::check_return_type<iterator>::equals(a.insert(q, t));
+  test::check_return_type<iterator>::equals(a.emplace_hint(q, t));
+
+  a.insert(i, j);
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  std::initializer_list<T> list = {t};
+  a.insert(list);
+  a.insert({t, t, t});
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1900) &&                                   \
+  (!defined(__clang__) || __clang_major__ >= 4 ||                              \
+    (__clang_major__ == 3 && __clang_minor__ >= 4))
+  a.insert({});
+  a.insert({t});
+  a.insert({t, t});
+#endif
+#endif
+
+  X a10;
+  a10.insert(t);
+  q = a10.cbegin();
+  test::check_return_type<iterator>::equals(a10.erase(q));
+
+  // Avoid unused variable warnings:
+
+  sink(a);
+  sink(a5);
+  sink(a6);
+  sink(a7);
+  sink(a8);
+  sink(a9);
+  sink(a5a);
+  sink(a6a);
+  sink(a7a);
+  sink(a9a);
+
+  typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+  node_type const n_const = a.extract(a.begin());
+  test::check_return_type<allocator_type>::equals(n_const.get_allocator());
+}
+
+template <class X, class Key, class T, class Hash, class Pred>
+void unordered_movable_test(X& x, Key& k, T& /* t */, Hash& hf, Pred& eq)
+{
+  unordered_test(x, k, hf, eq);
+
+  typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
+  typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+  X x1(rvalue_default<X>());
+  X x2(boost::move(x1));
+  x1 = rvalue_default<X>();
+  x2 = boost::move(x1);
+#endif
+
+  X a;
+  allocator_type m = a.get_allocator();
+
+  test::minimal::constructor_param* i = 0;
+  test::minimal::constructor_param* j = 0;
+
+  // Constructors
+
+  X(i, j, 10, hf, eq);
+  X a5(i, j, 10, hf, eq);
+  X(i, j, 10, hf);
+  X a6(i, j, 10, hf);
+  X(i, j, 10);
+  X a7(i, j, 10);
+  X(i, j);
+  X a8(i, j);
+
+  X(i, j, 10, hf, eq, m);
+  X a5a(i, j, 10, hf, eq, m);
+  X(i, j, 10, hf, m);
+  X a6a(i, j, 10, hf, m);
+  X(i, j, 10, m);
+  X a7a(i, j, 10, m);
+
+  // Not specified for some reason (maybe ambiguity with another constructor?)
+  // X(i, j, m);
+  // X a8a(i, j, m);
+  // sink(a8a);
+
+  const_iterator q = a.cbegin();
+
+  test::minimal::constructor_param v;
+  a.emplace(v);
+  test::check_return_type<iterator>::equals(a.emplace_hint(q, v));
+
+  T v1(v);
+  a.emplace(boost::move(v1));
+  T v2(v);
+  a.insert(boost::move(v2));
+  T v3(v);
+  test::check_return_type<iterator>::equals(a.emplace_hint(q, boost::move(v3)));
+  T v4(v);
+  test::check_return_type<iterator>::equals(a.insert(q, boost::move(v4)));
+
+  a.insert(i, j);
+
+  X a10;
+  T v5(v);
+  a10.insert(boost::move(v5));
+  q = a10.cbegin();
+  test::check_return_type<iterator>::equals(a10.erase(q));
+
+  // Avoid unused variable warnings:
+
+  sink(a);
+  sink(a5);
+  sink(a6);
+  sink(a7);
+  sink(a8);
+  sink(a5a);
+  sink(a6a);
+  sink(a7a);
+  sink(a10);
+}
+
+template <class X, class T> void unordered_set_member_test(X& x, T& t)
+{
+  X x1(x);
+  x1.insert(t);
+  x1.begin()->dummy_member();
+  x1.cbegin()->dummy_member();
+}
+
+template <class X, class T> void unordered_map_member_test(X& x, T& t)
+{
+  X x1(x);
+  x1.insert(t);
+  x1.begin()->first.dummy_member();
+  x1.cbegin()->first.dummy_member();
+  x1.begin()->second.dummy_member();
+  x1.cbegin()->second.dummy_member();
+}

libs/unordered/test/unordered/constructor_tests.cpp

@@ -0,0 +1,449 @@
+
+// Copyright 2006-2010 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include "../objects/test.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+#include "../helpers/equivalent.hpp"
+#include "../helpers/input_iterator.hpp"
+#include "../helpers/invariants.hpp"
+
+namespace constructor_tests {
+
+  test::seed_t initialize_seed(356730);
+
+  template <class T>
+  void constructor_tests1(T*, test::random_generator generator)
+  {
+    BOOST_DEDUCED_TYPENAME T::hasher hf;
+    BOOST_DEDUCED_TYPENAME T::key_equal eq;
+    BOOST_DEDUCED_TYPENAME T::allocator_type al;
+
+    UNORDERED_SUB_TEST("Construct 1")
+    {
+      test::check_instances check_;
+
+      T x(0, hf, eq);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 2")
+    {
+      test::check_instances check_;
+
+      T x(100, hf);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 100);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 3")
+    {
+      test::check_instances check_;
+
+      T x(2000);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 2000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 4")
+    {
+      test::check_instances check_;
+
+      T x;
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 5")
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(1000, generator);
+      T x(v.begin(), v.end(), 10000, hf, eq);
+      BOOST_TEST(x.bucket_count() >= 10000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 6")
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(10, generator);
+      T x(v.begin(), v.end(), 10000, hf);
+      BOOST_TEST(x.bucket_count() >= 10000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 7")
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(100, generator);
+      T x(v.begin(), v.end(), 100);
+      BOOST_TEST(x.bucket_count() >= 100);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 8")
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(1, generator);
+      T x(v.begin(), v.end());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 9")
+    {
+      test::check_instances check_;
+
+      T x(0, hf, eq, al);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 10")
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(1000, generator);
+      T x(v.begin(), v.end(), 10000, hf, eq, al);
+      BOOST_TEST(x.bucket_count() >= 10000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 11")
+    {
+      test::check_instances check_;
+
+      T x(al);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
+    }
+  }
+
+  template <class T>
+  void constructor_tests2(T*, test::random_generator const& generator)
+  {
+    BOOST_DEDUCED_TYPENAME T::hasher hf;
+    BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
+    BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
+    BOOST_DEDUCED_TYPENAME T::key_equal eq;
+    BOOST_DEDUCED_TYPENAME T::key_equal eq1(1);
+    BOOST_DEDUCED_TYPENAME T::key_equal eq2(2);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al;
+    BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
+
+    UNORDERED_SUB_TEST("Construct 1")
+    {
+      test::check_instances check_;
+      T x(10000, hf1, eq1);
+      BOOST_TEST(x.bucket_count() >= 10000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 2")
+    {
+      test::check_instances check_;
+      T x(100, hf1);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 100);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 3")
+    {
+      test::check_instances check_;
+      test::random_values<T> v(100, generator);
+      T x(v.begin(), v.end(), 0, hf1, eq1);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 4")
+    {
+      test::check_instances check_;
+      test::random_values<T> v(5, generator);
+      T x(v.begin(), v.end(), 1000, hf1);
+      BOOST_TEST(x.bucket_count() >= 1000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("Construct 5")
+    {
+      test::check_instances check_;
+      test::random_values<T> v(100, generator);
+      T x(v.begin(), v.end(), 0, hf, eq, al1);
+      T y(x.begin(), x.end(), 0, hf1, eq1, al2);
+      test::check_container(x, v);
+      test::check_container(y, x);
+      test::check_equivalent_keys(x);
+      test::check_equivalent_keys(y);
+    }
+
+    UNORDERED_SUB_TEST("Construct 6")
+    {
+      test::check_instances check_;
+      test::random_values<T> v(100, generator);
+      T x(v.begin(), v.end(), 0, hf1, eq1);
+      T y(x.begin(), x.end(), 0, hf, eq);
+      test::check_container(x, v);
+      test::check_container(y, x);
+      test::check_equivalent_keys(x);
+      test::check_equivalent_keys(y);
+    }
+
+    UNORDERED_SUB_TEST("Construct 7")
+    {
+      test::check_instances check_;
+      test::random_values<T> v(100, generator);
+      T x(v.begin(), v.end(), 0, hf1, eq1);
+      T y(x.begin(), x.end(), 0, hf2, eq2);
+      test::check_container(x, v);
+      test::check_container(y, x);
+      test::check_equivalent_keys(x);
+      test::check_equivalent_keys(y);
+    }
+
+    UNORDERED_SUB_TEST("Construct 8 - from input iterator")
+    {
+      test::check_instances check_;
+      test::random_values<T> v(100, generator);
+      BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator v_begin =
+                                                                      v.begin(),
+                                                                    v_end =
+                                                                      v.end();
+      T x(test::input_iterator(v_begin), test::input_iterator(v_end), 0, hf1,
+        eq1);
+      BOOST_DEDUCED_TYPENAME T::const_iterator x_begin = x.begin(),
+                                               x_end = x.end();
+      T y(test::input_iterator(x_begin), test::input_iterator(x_end), 0, hf2,
+        eq2);
+      test::check_container(x, v);
+      test::check_container(y, x);
+      test::check_equivalent_keys(x);
+      test::check_equivalent_keys(y);
+    }
+
+    UNORDERED_SUB_TEST("Construct 8.5 - from copy iterator")
+    {
+      test::check_instances check_;
+      test::random_values<T> v(100, generator);
+      T x(test::copy_iterator(v.begin()), test::copy_iterator(v.end()), 0, hf1,
+        eq1);
+      T y(test::copy_iterator(x.begin()), test::copy_iterator(x.end()), 0, hf2,
+        eq2);
+      test::check_container(x, v);
+      test::check_container(y, x);
+      test::check_equivalent_keys(x);
+      test::check_equivalent_keys(y);
+    }
+
+    UNORDERED_SUB_TEST("Construct 9")
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(100, generator);
+      T x(50);
+      BOOST_TEST(x.bucket_count() >= 50);
+      x.max_load_factor(10);
+      BOOST_TEST(x.bucket_count() >= 50);
+      x.insert(v.begin(), v.end());
+      BOOST_TEST(x.bucket_count() >= 50);
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+    std::initializer_list<BOOST_DEDUCED_TYPENAME T::value_type> list;
+
+    UNORDERED_SUB_TEST("Initializer list construct 1")
+    {
+      test::check_instances check_;
+
+      T x(list);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+    }
+
+    UNORDERED_SUB_TEST("Initializer list construct 2")
+    {
+      test::check_instances check_;
+
+      T x(list, 1000);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 1000);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+    }
+
+    UNORDERED_SUB_TEST("Initializer list construct 3")
+    {
+      test::check_instances check_;
+
+      T x(list, 10, hf1);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 10);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+    }
+
+    UNORDERED_SUB_TEST("Initializer list construct 4")
+    {
+      test::check_instances check_;
+
+      T x(list, 10, hf1, eq1);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 10);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al));
+    }
+
+    UNORDERED_SUB_TEST("Initializer list construct 5")
+    {
+      test::check_instances check_;
+
+      T x(list, 10, hf1, eq1, al1);
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.bucket_count() >= 10);
+      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
+      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
+      BOOST_TEST(test::equivalent(x.get_allocator(), al1));
+    }
+#endif
+  }
+
+  template <class T>
+  void map_constructor_test(T*, test::random_generator const& generator)
+  {
+    typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME T::key_type,
+      BOOST_DEDUCED_TYPENAME T::mapped_type> >
+      list;
+    test::random_values<T> v(1000, generator);
+    list l(v.begin(), v.end());
+    T x(l.begin(), l.end());
+
+    test::check_container(x, v);
+    test::check_equivalent_keys(x);
+  }
+
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    std::allocator<test::object> >* test_map_std_alloc;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_set;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multiset;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_map;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator1<test::object> >* test_multimap;
+
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+  UNORDERED_TEST(constructor_tests1,
+    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(constructor_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(map_constructor_test,
+    ((test_map_std_alloc)(test_map)(test_multimap))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+
+  UNORDERED_AUTO_TEST (test_default_initializer_list) {
+    std::initializer_list<int> init;
+    boost::unordered_set<int> x1 = init;
+    BOOST_TEST(x1.empty());
+  }
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+
+  UNORDERED_AUTO_TEST (test_initializer_list) {
+    boost::unordered_set<int> x1 = {2, 10, 45, -5};
+    BOOST_TEST(x1.find(10) != x1.end());
+    BOOST_TEST(x1.find(46) == x1.end());
+  }
+
+#endif
+}
+
+RUN_TESTS_QUIET()

libs/unordered/test/unordered/copy_tests.cpp

@@ -0,0 +1,209 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include "../objects/test.hpp"
+#include "../objects/cxx11_allocator.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+#include "../helpers/equivalent.hpp"
+#include "../helpers/invariants.hpp"
+
+test::seed_t initialize_seed(9063);
+
+namespace copy_tests {
+
+  template <class T>
+  void copy_construct_tests1(T*, test::random_generator const& generator)
+  {
+    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+
+    BOOST_DEDUCED_TYPENAME T::hasher hf;
+    BOOST_DEDUCED_TYPENAME T::key_equal eq;
+    BOOST_DEDUCED_TYPENAME T::allocator_type al;
+
+    {
+      test::check_instances check_;
+
+      T x;
+      T y(x);
+      BOOST_TEST(y.empty());
+      BOOST_TEST(test::equivalent(y.hash_function(), hf));
+      BOOST_TEST(test::equivalent(y.key_eq(), eq));
+      BOOST_TEST(test::equivalent(y.get_allocator(), al));
+      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+      BOOST_TEST(test::selected_count(y.get_allocator()) ==
+                 (allocator_type::is_select_on_copy));
+      test::check_equivalent_keys(y);
+    }
+
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(1000, generator);
+
+      T x(v.begin(), v.end());
+      T y(x);
+      test::unordered_equivalence_tester<T> equivalent(x);
+      BOOST_TEST(equivalent(y));
+      BOOST_TEST(test::selected_count(y.get_allocator()) ==
+                 (allocator_type::is_select_on_copy));
+      test::check_equivalent_keys(y);
+    }
+
+    {
+      test::check_instances check_;
+
+      // In this test I drop the original containers max load factor, so it
+      // is much lower than the load factor. The hash table is not allowed
+      // to rehash, but the destination container should probably allocate
+      // enough buckets to decrease the load factor appropriately.
+      test::random_values<T> v(1000, generator);
+      T x(v.begin(), v.end());
+      x.max_load_factor(x.load_factor() / 4);
+      T y(x);
+      test::unordered_equivalence_tester<T> equivalent(x);
+      BOOST_TEST(equivalent(y));
+      // This isn't guaranteed:
+      BOOST_TEST(y.load_factor() < y.max_load_factor());
+      BOOST_TEST(test::selected_count(y.get_allocator()) ==
+                 (allocator_type::is_select_on_copy));
+      test::check_equivalent_keys(y);
+    }
+  }
+
+  template <class T>
+  void copy_construct_tests2(T*, test::random_generator const& generator)
+  {
+    BOOST_DEDUCED_TYPENAME T::hasher hf(1);
+    BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
+
+    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+
+    {
+      test::check_instances check_;
+
+      T x(10000, hf, eq, al);
+      T y(x);
+      BOOST_TEST(y.empty());
+      BOOST_TEST(test::equivalent(y.hash_function(), hf));
+      BOOST_TEST(test::equivalent(y.key_eq(), eq));
+      BOOST_TEST(test::equivalent(y.get_allocator(), al));
+      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+      BOOST_TEST(test::selected_count(y.get_allocator()) ==
+                 (allocator_type::is_select_on_copy));
+      test::check_equivalent_keys(y);
+    }
+
+    {
+      test::check_instances check_;
+
+      T x(1000, hf, eq, al);
+      T y(x, al2);
+      BOOST_TEST(y.empty());
+      BOOST_TEST(test::equivalent(y.hash_function(), hf));
+      BOOST_TEST(test::equivalent(y.key_eq(), eq));
+      BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
+      test::check_equivalent_keys(y);
+    }
+
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(1000, generator);
+
+      T x(v.begin(), v.end(), 0, hf, eq, al);
+      T y(x);
+      test::unordered_equivalence_tester<T> equivalent(x);
+      BOOST_TEST(equivalent(y));
+      test::check_equivalent_keys(y);
+      BOOST_TEST(test::selected_count(y.get_allocator()) ==
+                 (allocator_type::is_select_on_copy));
+      BOOST_TEST(test::equivalent(y.get_allocator(), al));
+    }
+
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(500, generator);
+
+      T x(v.begin(), v.end(), 0, hf, eq, al);
+      T y(x, al2);
+      test::unordered_equivalence_tester<T> equivalent(x);
+      BOOST_TEST(equivalent(y));
+      test::check_equivalent_keys(y);
+      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
+      BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+    }
+  }
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_set;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multiset;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_map;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator2<test::object> >* test_multimap;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::select_copy> >*
+    test_set_select_copy;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::select_copy> >*
+    test_multiset_select_copy;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::select_copy> >*
+    test_map_select_copy;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::cxx11_allocator<test::object, test::select_copy> >*
+    test_multimap_select_copy;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_select_copy> >*
+    test_set_no_select_copy;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_select_copy> >*
+    test_multiset_no_select_copy;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_select_copy> >*
+    test_map_no_select_copy;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::cxx11_allocator<test::object, test::no_select_copy> >*
+    test_multimap_no_select_copy;
+
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+  UNORDERED_TEST(copy_construct_tests1,
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_select_copy)(
+      test_multiset_select_copy)(test_map_select_copy)(
+      test_multimap_select_copy)(test_set_no_select_copy)(
+      test_multiset_no_select_copy)(test_map_no_select_copy)(
+      test_multimap_no_select_copy))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(copy_construct_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_select_copy)(
+      test_multiset_select_copy)(test_map_select_copy)(
+      test_multimap_select_copy)(test_set_no_select_copy)(
+      test_multiset_no_select_copy)(test_map_no_select_copy)(
+      test_multimap_no_select_copy))(
+      (default_generator)(generate_collisions)(limited_range)))
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/detail_tests.cpp

@@ -0,0 +1,101 @@
+
+// Copyright 2017 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include <map>
+
+// Pretty inefficient, but the test is fast enough.
+// Might be too slow if we had larger primes?
+bool is_prime(std::size_t x)
+{
+  if (x == 2) {
+    return true;
+  } else if (x == 1 || x % 2 == 0) {
+    return false;
+  } else {
+    // y*y <= x had rounding errors, so instead use y <= (x/y).
+    for (std::size_t y = 3; y <= (x / y); y += 2) {
+      if (x % y == 0) {
+        return false;
+        break;
+      }
+    }
+
+    return true;
+  }
+}
+
+void test_next_prime(std::size_t value)
+{
+  std::size_t x = boost::unordered::detail::next_prime(value);
+  BOOST_TEST(is_prime(x));
+  BOOST_TEST(x >= value);
+}
+
+void test_prev_prime(std::size_t value)
+{
+  std::size_t x = boost::unordered::detail::prev_prime(value);
+  BOOST_TEST(is_prime(x));
+  BOOST_TEST(x <= value);
+  if (x > value) {
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << x << "," << value << std::endl;
+  }
+}
+
+UNORDERED_AUTO_TEST (next_prime_test) {
+  BOOST_TEST(!is_prime(0));
+  BOOST_TEST(!is_prime(1));
+  BOOST_TEST(is_prime(2));
+  BOOST_TEST(is_prime(3));
+  BOOST_TEST(is_prime(13));
+  BOOST_TEST(!is_prime(4));
+  BOOST_TEST(!is_prime(100));
+
+  BOOST_TEST(boost::unordered::detail::next_prime(0) > 0);
+
+  // test_prev_prime doesn't work for values less than 17.
+  // Which should be okay, unless an allocator has a really tiny
+  // max_size?
+  const std::size_t min_prime = 17;
+
+  // test_next_prime doesn't work for values greater than this,
+  // which might be a problem if you've got terrabytes of memory?
+  // I seriously doubt the container would work well at such sizes
+  // regardless.
+  const std::size_t max_prime = 4294967291ul;
+
+  std::size_t i;
+
+  BOOST_TEST(is_prime(min_prime));
+  BOOST_TEST(is_prime(max_prime));
+
+  for (i = 0; i < 10000; ++i) {
+    if (i < min_prime) {
+      BOOST_TEST(boost::unordered::detail::prev_prime(i) == min_prime);
+    } else {
+      test_prev_prime(i);
+    }
+    test_next_prime(i);
+  }
+
+  std::size_t last = i - 1;
+  for (; i > last; last = i, i += i / 5) {
+    if (i > max_prime) {
+      BOOST_TEST(boost::unordered::detail::next_prime(i) == max_prime);
+    } else {
+      test_next_prime(i);
+    }
+    test_prev_prime(i);
+  }
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/emplace_tests.cpp

@@ -0,0 +1,514 @@
+//
+// 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include <boost/functional/hash/hash.hpp>
+#include "../helpers/test.hpp"
+#include "../helpers/count.hpp"
+#include <string>
+
+// Test that various emplace methods work with different numbers of
+// arguments.
+
+namespace emplace_tests {
+  // Constructible with 2 to 10 arguments
+  struct emplace_value : private test::counted_object
+  {
+    typedef int A0;
+    typedef std::string A1;
+    typedef char A2;
+    typedef int A3;
+    typedef int A4;
+    typedef int A5;
+    typedef int A6;
+    typedef int A7;
+    typedef int A8;
+    typedef int A9;
+
+    int arg_count;
+
+    A0 a0;
+    A1 a1;
+    A2 a2;
+    A3 a3;
+    A4 a4;
+    A5 a5;
+    A6 a6;
+    A7 a7;
+    A8 a8;
+    A9 a9;
+
+    emplace_value(A0 const& b0, A1 const& b1) : arg_count(2), a0(b0), a1(b1) {}
+
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2)
+        : arg_count(3), a0(b0), a1(b1), a2(b2)
+    {
+    }
+
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3)
+        : arg_count(4), a0(b0), a1(b1), a2(b2), a3(b3)
+    {
+    }
+
+    emplace_value(
+      A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3, A4 const& b4)
+        : arg_count(5), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4)
+    {
+    }
+
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
+      A4 const& b4, A5 const& b5)
+        : arg_count(6), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4), a5(b5)
+    {
+    }
+
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
+      A4 const& b4, A5 const& b5, A6 const& b6)
+        : arg_count(7), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4), a5(b5), a6(b6)
+    {
+    }
+
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
+      A4 const& b4, A5 const& b5, A6 const& b6, A7 const& b7)
+        : arg_count(8), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4), a5(b5), a6(b6),
+          a7(b7)
+    {
+    }
+
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
+      A4 const& b4, A5 const& b5, A6 const& b6, A7 const& b7, A8 const& b8)
+        : arg_count(9), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4), a5(b5), a6(b6),
+          a7(b7), a8(b8)
+    {
+    }
+
+    emplace_value(A0 const& b0, A1 const& b1, A2 const& b2, A3 const& b3,
+      A4 const& b4, A5 const& b5, A6 const& b6, A7 const& b7, A8 const& b8,
+      A9 const& b9)
+        : arg_count(10), a0(b0), a1(b1), a2(b2), a3(b3), a4(b4), a5(b5), a6(b6),
+          a7(b7), a8(b8), a9(b9)
+    {
+    }
+
+    friend std::size_t hash_value(emplace_value const& x)
+    {
+      std::size_t r1 = 23894278u;
+      if (x.arg_count >= 1)
+        boost::hash_combine(r1, x.a0);
+      if (x.arg_count >= 2)
+        boost::hash_combine(r1, x.a1);
+      if (x.arg_count >= 3)
+        boost::hash_combine(r1, x.a2);
+      if (x.arg_count >= 4)
+        boost::hash_combine(r1, x.a3);
+      if (x.arg_count >= 5)
+        boost::hash_combine(r1, x.a4);
+      if (x.arg_count >= 6)
+        boost::hash_combine(r1, x.a5);
+      if (x.arg_count >= 7)
+        boost::hash_combine(r1, x.a6);
+      if (x.arg_count >= 8)
+        boost::hash_combine(r1, x.a7);
+      if (x.arg_count >= 9)
+        boost::hash_combine(r1, x.a8);
+      if (x.arg_count >= 10)
+        boost::hash_combine(r1, x.a9);
+      return r1;
+    }
+
+    friend bool operator==(emplace_value const& x, emplace_value const& y)
+    {
+      if (x.arg_count != y.arg_count) {
+        return false;
+      }
+      if (x.arg_count >= 1 && x.a0 != y.a0) {
+        return false;
+      }
+      if (x.arg_count >= 2 && x.a1 != y.a1) {
+        return false;
+      }
+      if (x.arg_count >= 3 && x.a2 != y.a2) {
+        return false;
+      }
+      if (x.arg_count >= 4 && x.a3 != y.a3) {
+        return false;
+      }
+      if (x.arg_count >= 5 && x.a4 != y.a4) {
+        return false;
+      }
+      if (x.arg_count >= 6 && x.a5 != y.a5) {
+        return false;
+      }
+      if (x.arg_count >= 7 && x.a6 != y.a6) {
+        return false;
+      }
+      if (x.arg_count >= 8 && x.a7 != y.a7) {
+        return false;
+      }
+      if (x.arg_count >= 9 && x.a8 != y.a8) {
+        return false;
+      }
+      if (x.arg_count >= 10 && x.a9 != y.a9) {
+        return false;
+      }
+      return true;
+    }
+
+  private:
+    emplace_value();
+    emplace_value(emplace_value const&);
+  };
+
+  UNORDERED_AUTO_TEST (emplace_set) {
+    test::check_instances check_;
+
+    typedef boost::unordered_set<emplace_value, boost::hash<emplace_value> >
+      container;
+    typedef container::iterator iterator;
+    typedef std::pair<iterator, bool> return_type;
+    container x(10);
+    iterator i1;
+    return_type r1, r2;
+
+    // 2 args
+
+    emplace_value v1(10, "x");
+    r1 = x.emplace(10, std::string("x"));
+    BOOST_TEST_EQ(x.size(), 1u);
+    BOOST_TEST(r1.second);
+    BOOST_TEST(*r1.first == v1);
+    BOOST_TEST(r1.first == x.find(v1));
+    BOOST_TEST_EQ(check_.instances(), 2);
+    BOOST_TEST_EQ(check_.constructions(), 2);
+
+    // 3 args
+
+    emplace_value v2(3, "foo", 'a');
+    r1 = x.emplace(3, "foo", 'a');
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST(r1.second);
+    BOOST_TEST(*r1.first == v2);
+    BOOST_TEST(r1.first == x.find(v2));
+    BOOST_TEST_EQ(check_.instances(), 4);
+    BOOST_TEST_EQ(check_.constructions(), 4);
+
+    // 7 args with hint + duplicate
+
+    emplace_value v3(25, "something", 'z', 4, 5, 6, 7);
+    i1 = x.emplace_hint(r1.first, 25, "something", 'z', 4, 5, 6, 7);
+    BOOST_TEST_EQ(x.size(), 3u);
+    BOOST_TEST(*i1 == v3);
+    BOOST_TEST(i1 == x.find(v3));
+    BOOST_TEST_EQ(check_.instances(), 6);
+    BOOST_TEST_EQ(check_.constructions(), 6);
+
+    r2 = x.emplace(25, "something", 'z', 4, 5, 6, 7);
+    BOOST_TEST_EQ(x.size(), 3u);
+    BOOST_TEST(!r2.second);
+    BOOST_TEST(i1 == r2.first);
+    // The container has to construct an object in order to check
+    // whether it can emplace, so there's an extra cosntruction
+    // here.
+    BOOST_TEST_EQ(check_.instances(), 6);
+    BOOST_TEST_EQ(check_.constructions(), 7);
+
+    // 10 args + hint duplicate
+
+    std::string s1;
+    emplace_value v4(10, s1, 'a', 4, 5, 6, 7, 8, 9, 10);
+    r1 = x.emplace(10, s1, 'a', 4, 5, 6, 7, 8, 9, 10);
+    BOOST_TEST_EQ(x.size(), 4u);
+    BOOST_TEST(r1.second);
+    BOOST_TEST(*r1.first == v4);
+    BOOST_TEST(r1.first == x.find(v4));
+    BOOST_TEST_EQ(check_.instances(), 8);
+    BOOST_TEST_EQ(check_.constructions(), 9);
+
+    BOOST_TEST(
+      r1.first == x.emplace_hint(r1.first, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
+    BOOST_TEST(
+      r1.first == x.emplace_hint(r2.first, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
+    BOOST_TEST(
+      r1.first == x.emplace_hint(x.end(), 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
+    BOOST_TEST_EQ(check_.instances(), 8);
+    BOOST_TEST_EQ(check_.constructions(), 12);
+
+    BOOST_TEST_EQ(x.size(), 4u);
+    BOOST_TEST(x.count(v1) == 1);
+    BOOST_TEST(x.count(v2) == 1);
+    BOOST_TEST(x.count(v3) == 1);
+    BOOST_TEST(x.count(v4) == 1);
+  }
+
+  UNORDERED_AUTO_TEST (emplace_multiset) {
+    test::check_instances check_;
+
+    typedef boost::unordered_multiset<emplace_value,
+      boost::hash<emplace_value> >
+      container;
+    typedef container::iterator iterator;
+    container x(10);
+    iterator i1, i2;
+
+    // 2 args.
+
+    emplace_value v1(10, "x");
+    i1 = x.emplace(10, std::string("x"));
+    BOOST_TEST_EQ(x.size(), 1u);
+    BOOST_TEST(i1 == x.find(v1));
+    BOOST_TEST_EQ(check_.instances(), 2);
+    BOOST_TEST_EQ(check_.constructions(), 2);
+
+    // 4 args + duplicate
+
+    emplace_value v2(4, "foo", 'a', 15);
+    i1 = x.emplace(4, "foo", 'a', 15);
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST(i1 == x.find(v2));
+    BOOST_TEST_EQ(check_.instances(), 4);
+    BOOST_TEST_EQ(check_.constructions(), 4);
+
+    i2 = x.emplace(4, "foo", 'a', 15);
+    BOOST_TEST_EQ(x.size(), 3u);
+    BOOST_TEST(i1 != i2);
+    BOOST_TEST(*i1 == *i2);
+    BOOST_TEST(x.count(*i1) == 2);
+    BOOST_TEST_EQ(check_.instances(), 5);
+    BOOST_TEST_EQ(check_.constructions(), 5);
+
+    // 7 args + duplicate using hint.
+
+    emplace_value v3(7, "", 'z', 4, 5, 6, 7);
+    i1 = x.emplace(7, "", 'z', 4, 5, 6, 7);
+    BOOST_TEST_EQ(x.size(), 4u);
+    BOOST_TEST_EQ(i1->a2, 'z');
+    BOOST_TEST(x.count(*i1) == 1);
+    BOOST_TEST(i1 == x.find(v3));
+    BOOST_TEST_EQ(check_.instances(), 7);
+    BOOST_TEST_EQ(check_.constructions(), 7);
+
+    i2 = x.emplace_hint(i1, 7, "", 'z', 4, 5, 6, 7);
+    BOOST_TEST_EQ(x.size(), 5u);
+    BOOST_TEST(*i1 == *i2);
+    BOOST_TEST(i1 != i2);
+    BOOST_TEST(x.count(*i1) == 2);
+    BOOST_TEST_EQ(check_.instances(), 8);
+    BOOST_TEST_EQ(check_.constructions(), 8);
+
+    // 10 args with bad hint + duplicate
+
+    emplace_value v4(10, "", 'a', 4, 5, 6, 7, 8, 9, 10);
+    i1 = x.emplace_hint(i2, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10);
+    BOOST_TEST_EQ(x.size(), 6u);
+    BOOST_TEST_EQ(i1->arg_count, 10);
+    BOOST_TEST(i1 == x.find(v4));
+    BOOST_TEST_EQ(check_.instances(), 10);
+    BOOST_TEST_EQ(check_.constructions(), 10);
+
+    i2 = x.emplace_hint(x.end(), 10, "", 'a', 4, 5, 6, 7, 8, 9, 10);
+    BOOST_TEST_EQ(x.size(), 7u);
+    BOOST_TEST(*i1 == *i2);
+    BOOST_TEST(i1 != i2);
+    BOOST_TEST(x.count(*i1) == 2);
+    BOOST_TEST_EQ(check_.instances(), 11);
+    BOOST_TEST_EQ(check_.constructions(), 11);
+
+    BOOST_TEST_EQ(x.count(v1), 1u);
+    BOOST_TEST_EQ(x.count(v2), 2u);
+    BOOST_TEST_EQ(x.count(v3), 2u);
+  }
+
+  UNORDERED_AUTO_TEST (emplace_map) {
+    test::check_instances check_;
+
+    typedef boost::unordered_map<emplace_value, emplace_value,
+      boost::hash<emplace_value> >
+      container;
+    typedef container::iterator iterator;
+    typedef std::pair<iterator, bool> return_type;
+    container x(10);
+    return_type r1, r2;
+
+    // 5/8 args + duplicate
+
+    emplace_value k1(5, "", 'b', 4, 5);
+    emplace_value m1(8, "xxx", 'z', 4, 5, 6, 7, 8);
+    r1 = x.emplace(boost::unordered::piecewise_construct,
+      boost::make_tuple(5, "", 'b', 4, 5),
+      boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
+    BOOST_TEST_EQ(x.size(), 1u);
+    BOOST_TEST(r1.second);
+    BOOST_TEST(x.find(k1) == r1.first);
+    BOOST_TEST(x.find(k1)->second == m1);
+    BOOST_TEST_EQ(check_.instances(), 4);
+    BOOST_TEST_EQ(check_.constructions(), 4);
+
+    r2 = x.emplace(boost::unordered::piecewise_construct,
+      boost::make_tuple(5, "", 'b', 4, 5),
+      boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
+    BOOST_TEST_EQ(x.size(), 1u);
+    BOOST_TEST(!r2.second);
+    BOOST_TEST(r1.first == r2.first);
+    BOOST_TEST(x.find(k1)->second == m1);
+    BOOST_TEST_EQ(check_.instances(), 4);
+    // constructions could possibly be 5 if the implementation only
+    // constructed the key.
+    BOOST_TEST_EQ(check_.constructions(), 6);
+
+    // 9/3 args + duplicates with hints, different mapped value.
+
+    emplace_value k2(9, "", 'b', 4, 5, 6, 7, 8, 9);
+    emplace_value m2(3, "aaa", 'm');
+    r1 = x.emplace(boost::unordered::piecewise_construct,
+      boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+      boost::make_tuple(3, "aaa", 'm'));
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST(r1.second);
+    BOOST_TEST(r1.first->first.arg_count == 9);
+    BOOST_TEST(r1.first->second.arg_count == 3);
+    BOOST_TEST(x.find(k2) == r1.first);
+    BOOST_TEST(x.find(k2)->second == m2);
+    BOOST_TEST_EQ(check_.instances(), 8);
+    BOOST_TEST_EQ(check_.constructions(), 10);
+
+    BOOST_TEST(r1.first ==
+               x.emplace_hint(r1.first, boost::unordered::piecewise_construct,
+                 boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+                 boost::make_tuple(15, "jkjk")));
+    BOOST_TEST(r1.first ==
+               x.emplace_hint(r2.first, boost::unordered::piecewise_construct,
+                 boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+                 boost::make_tuple(275, "xxx", 'm', 6)));
+    BOOST_TEST(r1.first ==
+               x.emplace_hint(x.end(), boost::unordered::piecewise_construct,
+                 boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+                 boost::make_tuple(-10, "blah blah", '\0')));
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST(x.find(k2)->second == m2);
+    BOOST_TEST_EQ(check_.instances(), 8);
+    BOOST_TEST_EQ(check_.constructions(), 16);
+  }
+
+  UNORDERED_AUTO_TEST (emplace_multimap) {
+    test::check_instances check_;
+
+    typedef boost::unordered_multimap<emplace_value, emplace_value,
+      boost::hash<emplace_value> >
+      container;
+    typedef container::iterator iterator;
+    container x(10);
+    iterator i1, i2, i3, i4;
+
+    // 5/8 args + duplicate
+
+    emplace_value k1(5, "", 'b', 4, 5);
+    emplace_value m1(8, "xxx", 'z', 4, 5, 6, 7, 8);
+    i1 = x.emplace(boost::unordered::piecewise_construct,
+      boost::make_tuple(5, "", 'b', 4, 5),
+      boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
+    BOOST_TEST_EQ(x.size(), 1u);
+    BOOST_TEST(x.find(k1) == i1);
+    BOOST_TEST(x.find(k1)->second == m1);
+    BOOST_TEST_EQ(check_.instances(), 4);
+    BOOST_TEST_EQ(check_.constructions(), 4);
+
+    emplace_value m1a(8, "xxx", 'z', 4, 5, 6, 7, 8);
+    i2 = x.emplace(boost::unordered::piecewise_construct,
+      boost::make_tuple(5, "", 'b', 4, 5),
+      boost::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST(i1 != i2);
+    BOOST_TEST(i1->second == m1);
+    BOOST_TEST(i2->second == m1a);
+    BOOST_TEST_EQ(check_.instances(), 7);
+    BOOST_TEST_EQ(check_.constructions(), 7);
+
+    // 9/3 args + duplicates with hints, different mapped value.
+
+    emplace_value k2(9, "", 'b', 4, 5, 6, 7, 8, 9);
+    emplace_value m2(3, "aaa", 'm');
+    i1 = x.emplace(boost::unordered::piecewise_construct,
+      boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+      boost::make_tuple(3, "aaa", 'm'));
+    BOOST_TEST_EQ(x.size(), 3u);
+    BOOST_TEST(i1->first.arg_count == 9);
+    BOOST_TEST(i1->second.arg_count == 3);
+    BOOST_TEST_EQ(check_.instances(), 11);
+    BOOST_TEST_EQ(check_.constructions(), 11);
+
+    emplace_value m2a(15, "jkjk");
+    i2 = x.emplace_hint(i2, boost::unordered::piecewise_construct,
+      boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+      boost::make_tuple(15, "jkjk"));
+    emplace_value m2b(275, "xxx", 'm', 6);
+    i3 = x.emplace_hint(i1, boost::unordered::piecewise_construct,
+      boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+      boost::make_tuple(275, "xxx", 'm', 6));
+    emplace_value m2c(-10, "blah blah", '\0');
+    i4 = x.emplace_hint(x.end(), boost::unordered::piecewise_construct,
+      boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+      boost::make_tuple(-10, "blah blah", '\0'));
+    BOOST_TEST_EQ(x.size(), 6u);
+    BOOST_TEST(x.find(k2)->second == m2);
+    BOOST_TEST_EQ(check_.instances(), 20);
+    BOOST_TEST_EQ(check_.constructions(), 20);
+  }
+
+  UNORDERED_AUTO_TEST (try_emplace) {
+    test::check_instances check_;
+
+    typedef boost::unordered_map<int, emplace_value> container;
+    typedef container::iterator iterator;
+    typedef std::pair<iterator, bool> return_type;
+    container x(10);
+    return_type r1, r2, r3;
+
+    int k1 = 3;
+    emplace_value m1(414, "grr");
+    r1 = x.try_emplace(3, 414, "grr");
+    BOOST_TEST(r1.second);
+    BOOST_TEST(r1.first->first == k1);
+    BOOST_TEST(r1.first->second == m1);
+    BOOST_TEST_EQ(x.size(), 1u);
+    BOOST_TEST_EQ(check_.instances(), 2);
+    BOOST_TEST_EQ(check_.constructions(), 2);
+
+    int k2 = 10;
+    emplace_value m2(25, "", 'z');
+    r2 = x.try_emplace(10, 25, std::string(""), 'z');
+    BOOST_TEST(r2.second);
+    BOOST_TEST(r2.first->first == k2);
+    BOOST_TEST(r2.first->second == m2);
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST_EQ(check_.instances(), 4);
+    BOOST_TEST_EQ(check_.constructions(), 4);
+
+    BOOST_TEST(x.find(k1)->second == m1);
+    BOOST_TEST(x.find(k2)->second == m2);
+
+    r3 = x.try_emplace(k2, 68, "jfeoj", 'p', 49309, 2323);
+    BOOST_TEST(!r3.second);
+    BOOST_TEST(r3.first == r2.first);
+    BOOST_TEST(r3.first->second == m2);
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST_EQ(check_.instances(), 4);
+    BOOST_TEST_EQ(check_.constructions(), 4);
+
+    BOOST_TEST(r2.first == x.try_emplace(r2.first, k2, 808709, "what"));
+    BOOST_TEST(
+      r2.first ==
+      x.try_emplace(r2.first, k2, 10, "xxx", 'a', 4, 5, 6, 7, 8, 9, 10));
+    BOOST_TEST(r2.first->second == m2);
+    BOOST_TEST_EQ(x.size(), 2u);
+  }
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/equality_tests.cpp

@@ -0,0 +1,157 @@
+
+// Copyright 2008-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include <boost/preprocessor/seq.hpp>
+#include <list>
+#include "../helpers/test.hpp"
+
+namespace equality_tests {
+  struct mod_compare
+  {
+    bool alt_hash_;
+
+    explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}
+
+    bool operator()(int x, int y) const { return x % 1000 == y % 1000; }
+
+    std::size_t operator()(int x) const
+    {
+      return alt_hash_ ? static_cast<std::size_t>(x % 250)
+                       : static_cast<std::size_t>((x + 5) % 250);
+    }
+  };
+
+#define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2)                            \
+  do {                                                                         \
+    boost::unordered_set<int, mod_compare, mod_compare> set1, set2;            \
+    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)                    \
+    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)                    \
+    BOOST_TEST(set1 op set2);                                                  \
+  } while (0)
+
+#define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2)                       \
+  do {                                                                         \
+    boost::unordered_multiset<int, mod_compare, mod_compare> set1, set2;       \
+    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)                    \
+    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)                    \
+    BOOST_TEST(set1 op set2);                                                  \
+  } while (0)
+
+#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2)                            \
+  do {                                                                         \
+    boost::unordered_map<int, int, mod_compare, mod_compare> map1, map2;       \
+    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)                    \
+    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)                    \
+    BOOST_TEST(map1 op map2);                                                  \
+  } while (0)
+
+#define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2)                       \
+  do {                                                                         \
+    boost::unordered_multimap<int, int, mod_compare, mod_compare> map1, map2;  \
+    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)                    \
+    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)                    \
+    BOOST_TEST(map1 op map2);                                                  \
+  } while (0)
+
+#define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
+#define UNORDERED_MAP_INSERT(r, map, item)                                     \
+  map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));
+
+  UNORDERED_AUTO_TEST (equality_size_tests) {
+    boost::unordered_set<int> x1, x2;
+    BOOST_TEST(x1 == x2);
+    BOOST_TEST(!(x1 != x2));
+
+    x1.insert(1);
+    BOOST_TEST(x1 != x2);
+    BOOST_TEST(!(x1 == x2));
+    BOOST_TEST(x2 != x1);
+    BOOST_TEST(!(x2 == x1));
+
+    x2.insert(1);
+    BOOST_TEST(x1 == x2);
+    BOOST_TEST(!(x1 != x2));
+
+    x2.insert(2);
+    BOOST_TEST(x1 != x2);
+    BOOST_TEST(!(x1 == x2));
+    BOOST_TEST(x2 != x1);
+    BOOST_TEST(!(x2 == x1));
+  }
+
+  UNORDERED_AUTO_TEST (equality_key_value_tests) {
+    UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2));
+    UNORDERED_EQUALITY_SET_TEST((2), ==, (2));
+    UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)));
+  }
+
+  UNORDERED_AUTO_TEST (equality_collision_test) {
+    UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (501));
+    UNORDERED_EQUALITY_MULTISET_TEST((1)(251), !=, (1)(501));
+    UNORDERED_EQUALITY_MULTIMAP_TEST(
+      ((251)(1))((1)(1)), !=, ((501)(1))((1)(1)));
+    UNORDERED_EQUALITY_MULTISET_TEST((1)(501), ==, (1)(501));
+    UNORDERED_EQUALITY_SET_TEST((1)(501), ==, (501)(1));
+  }
+
+  UNORDERED_AUTO_TEST (equality_group_size_test) {
+    UNORDERED_EQUALITY_MULTISET_TEST((10)(20)(20), !=, (10)(10)(20));
+    UNORDERED_EQUALITY_MULTIMAP_TEST(
+      ((10)(1))((20)(1))((20)(1)), !=, ((10)(1))((20)(1))((10)(1)));
+    UNORDERED_EQUALITY_MULTIMAP_TEST(
+      ((20)(1))((10)(1))((10)(1)), ==, ((10)(1))((20)(1))((10)(1)));
+  }
+
+  UNORDERED_AUTO_TEST (equality_map_value_test) {
+    UNORDERED_EQUALITY_MAP_TEST(((1)(1)), !=, ((1)(2)));
+    UNORDERED_EQUALITY_MAP_TEST(((1)(1)), ==, ((1)(1)));
+    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(1)), !=, ((1)(2)));
+    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(1))((1)(1)), !=, ((1)(1))((1)(2)));
+    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(2))((1)(1)), ==, ((1)(1))((1)(2)));
+    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(2))((1)(1)), !=, ((1)(1))((1)(3)));
+  }
+
+  UNORDERED_AUTO_TEST (equality_predicate_test) {
+    UNORDERED_EQUALITY_SET_TEST((1), !=, (1001));
+    UNORDERED_EQUALITY_MAP_TEST(((1)(2))((1001)(1)), !=, ((1001)(2))((1)(1)));
+  }
+
+  UNORDERED_AUTO_TEST (equality_multiple_group_test) {
+    UNORDERED_EQUALITY_MULTISET_TEST(
+      (1)(1)(1)(1001)(2001)(2001)(2)(1002)(3)(1003)(2003), ==,
+      (3)(1003)(2003)(1002)(2)(2001)(2001)(1)(1001)(1)(1));
+  }
+
+  // Test that equality still works when the two containers have
+  // different hash functions but the same equality predicate.
+
+  UNORDERED_AUTO_TEST (equality_different_hash_test) {
+    typedef boost::unordered_set<int, mod_compare, mod_compare> set;
+    set set1(0, mod_compare(false), mod_compare(false));
+    set set2(0, mod_compare(true), mod_compare(true));
+    BOOST_TEST(set1 == set2);
+    set1.insert(1);
+    set2.insert(2);
+    BOOST_TEST(set1 != set2);
+    set1.insert(2);
+    set2.insert(1);
+    BOOST_TEST(set1 == set2);
+    set1.insert(10);
+    set2.insert(20);
+    BOOST_TEST(set1 != set2);
+    set1.insert(20);
+    set2.insert(10);
+    BOOST_TEST(set1 == set2);
+  }
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/equivalent_keys_tests.cpp

@@ -0,0 +1,77 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include <algorithm>
+#include <map>
+#include "../helpers/list.hpp"
+#include "../helpers/tracker.hpp"
+#include "../helpers/invariants.hpp"
+
+template <class Container, class Iterator>
+void test_equal_insertion(Iterator begin, Iterator end)
+{
+  typedef test::ordered<Container> tracker;
+
+  Container x1;
+  tracker x2 = test::create_ordered(x1);
+
+  for (Iterator it = begin; it != end; ++it) {
+    x1.insert(*it);
+    x2.insert(*it);
+    x2.compare_key(x1, *it);
+  }
+
+  x2.compare(x1);
+  test::check_equivalent_keys(x1);
+}
+
+UNORDERED_AUTO_TEST (set_tests) {
+  int values[][5] = {{1}, {54, 23}, {-13, 65}, {77, 77}, {986, 25, 986}};
+
+  typedef boost::unordered_set<int> set;
+  typedef boost::unordered_multiset<int> multiset;
+
+  test_equal_insertion<set>(values[0], values[0] + 1);
+  test_equal_insertion<set>(values[1], values[1] + 2);
+  test_equal_insertion<set>(values[2], values[2] + 2);
+  test_equal_insertion<set>(values[3], values[3] + 2);
+  test_equal_insertion<set>(values[4], values[4] + 3);
+
+  test_equal_insertion<multiset>(values[0], values[0] + 1);
+  test_equal_insertion<multiset>(values[1], values[1] + 2);
+  test_equal_insertion<multiset>(values[2], values[2] + 2);
+  test_equal_insertion<multiset>(values[3], values[3] + 2);
+  test_equal_insertion<multiset>(values[4], values[4] + 3);
+}
+
+UNORDERED_AUTO_TEST (map_tests) {
+  typedef test::list<std::pair<int const, int> > values_type;
+  values_type v[5];
+  v[0].push_back(std::pair<int const, int>(1, 1));
+  v[1].push_back(std::pair<int const, int>(28, 34));
+  v[1].push_back(std::pair<int const, int>(16, 58));
+  v[1].push_back(std::pair<int const, int>(-124, 62));
+  v[2].push_back(std::pair<int const, int>(432, 12));
+  v[2].push_back(std::pair<int const, int>(9, 13));
+  v[2].push_back(std::pair<int const, int>(432, 24));
+
+  for (int i = 0; i < 5; ++i)
+    test_equal_insertion<boost::unordered_map<int, int> >(
+      v[i].begin(), v[i].end());
+
+  for (int i2 = 0; i2 < 5; ++i2)
+    test_equal_insertion<boost::unordered_multimap<int, int> >(
+      v[i2].begin(), v[i2].end());
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/erase_equiv_tests.cpp

@@ -0,0 +1,217 @@
+
+// Copyright 2006-2009 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)
+
+// The code for erasing elements from containers with equivalent keys is very
+// hairy with several tricky edge cases - so explicitly test each one.
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include "../helpers/list.hpp"
+#include "../helpers/invariants.hpp"
+#include "../helpers/helpers.hpp"
+#include <set>
+#include <iterator>
+#include "../objects/test.hpp"
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
+#pragma warning(disable : 4267) // conversion from 'size_t' to 'unsigned int',
+                                // possible loss of data.
+#endif
+
+struct write_pair_type
+{
+  template <class X1, class X2>
+  void operator()(std::pair<X1, X2> const& x) const
+  {
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "(" << x.first << "," << x.second << ")";
+  }
+} write_pair;
+
+template <class Container> void write_container(Container const& x)
+{
+  std::for_each(x.begin(), x.end(), write_pair);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
+}
+
+// Make everything collide - for testing erase in a single bucket.
+struct collision_hash
+{
+  std::size_t operator()(int) const { return 0; }
+};
+
+// For testing erase in 2 buckets.
+struct collision2_hash
+{
+  std::size_t operator()(int x) const
+  {
+    return static_cast<std::size_t>(x & 1);
+  }
+};
+
+// For testing erase in lots of buckets.
+struct collision3_hash
+{
+  std::size_t operator()(int x) const { return static_cast<std::size_t>(x); }
+};
+
+typedef boost::unordered_multimap<int, int, collision_hash, std::equal_to<int>,
+  test::allocator1<std::pair<int const, int> > >
+  collide_map;
+typedef boost::unordered_multimap<int, int, collision2_hash, std::equal_to<int>,
+  test::allocator2<std::pair<int const, int> > >
+  collide_map2;
+typedef boost::unordered_multimap<int, int, collision3_hash, std::equal_to<int>,
+  test::allocator2<std::pair<int const, int> > >
+  collide_map3;
+typedef collide_map::value_type collide_value;
+typedef test::list<collide_value> collide_list;
+
+UNORDERED_AUTO_TEST (empty_range_tests) {
+  collide_map x;
+  x.erase(x.begin(), x.end());
+  x.erase(x.begin(), x.begin());
+  x.erase(x.end(), x.end());
+  test::check_equivalent_keys(x);
+}
+
+UNORDERED_AUTO_TEST (single_item_tests) {
+  collide_list init;
+  init.push_back(collide_value(1, 1));
+
+  collide_map x(init.begin(), init.end());
+  x.erase(x.begin(), x.begin());
+  BOOST_TEST(x.count(1) == 1 && x.size() == 1);
+  test::check_equivalent_keys(x);
+  x.erase(x.end(), x.end());
+  BOOST_TEST(x.count(1) == 1 && x.size() == 1);
+  test::check_equivalent_keys(x);
+  x.erase(x.begin(), x.end());
+  BOOST_TEST(x.count(1) == 0 && x.size() == 0);
+  test::check_equivalent_keys(x);
+}
+
+UNORDERED_AUTO_TEST (two_equivalent_item_tests) {
+  collide_list init;
+  init.push_back(collide_value(1, 1));
+  init.push_back(collide_value(1, 2));
+
+  {
+    collide_map x(init.begin(), init.end());
+    x.erase(x.begin(), x.end());
+    BOOST_TEST(x.count(1) == 0 && x.size() == 0);
+    test::check_equivalent_keys(x);
+  }
+
+  {
+    collide_map x(init.begin(), init.end());
+    int value = test::next(x.begin())->second;
+    x.erase(x.begin(), test::next(x.begin()));
+    BOOST_TEST(x.count(1) == 1 && x.size() == 1 && x.begin()->first == 1 &&
+               x.begin()->second == value);
+    test::check_equivalent_keys(x);
+  }
+
+  {
+    collide_map x(init.begin(), init.end());
+    int value = x.begin()->second;
+    x.erase(test::next(x.begin()), x.end());
+    BOOST_TEST(x.count(1) == 1 && x.size() == 1 && x.begin()->first == 1 &&
+               x.begin()->second == value);
+    test::check_equivalent_keys(x);
+  }
+}
+
+// More automated tests...
+
+template <class Range1, class Range2>
+bool compare(Range1 const& x, Range2 const& y)
+{
+  collide_list a(x.begin(), x.end());
+  collide_list b(y.begin(), y.end());
+  a.sort();
+  b.sort();
+  return a == b;
+}
+
+template <class Container>
+bool general_erase_range_test(Container& x, std::size_t start, std::size_t end)
+{
+  collide_list l(x.begin(), x.end());
+
+  l.erase(test::next(l.begin(), start), test::next(l.begin(), end));
+  x.erase(test::next(x.begin(), start), test::next(x.begin(), end));
+
+  test::check_equivalent_keys(x);
+  return compare(l, x);
+}
+
+template <class Container> void erase_subrange_tests(Container const& x)
+{
+  for (std::size_t length = 0; length < x.size(); ++length) {
+    for (std::size_t position = 0; position < x.size() - length; ++position) {
+      Container y(x);
+      collide_list init(y.begin(), y.end());
+      if (!general_erase_range_test(y, position, position + length)) {
+        BOOST_ERROR("general_erase_range_test failed.");
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Erase: [" << position << ","
+                                       << position + length << ")\n";
+        write_container(init);
+        write_container(y);
+      }
+    }
+  }
+}
+
+template <class Container>
+void x_by_y_erase_range_tests(Container*, int values, int duplicates)
+{
+  Container y;
+
+  for (int i = 0; i < values; ++i) {
+    for (int j = 0; j < duplicates; ++j) {
+      y.insert(collide_value(i, j));
+    }
+  }
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Values: " << values
+                                 << ", Duplicates: " << duplicates << "\n";
+  erase_subrange_tests(y);
+}
+
+template <class Container>
+void exhaustive_erase_tests(Container* x, int num_values, int num_duplicated)
+{
+  for (int i = 0; i < num_values; ++i) {
+    for (int j = 0; j < num_duplicated; ++j) {
+      x_by_y_erase_range_tests(x, i, j);
+    }
+  }
+}
+
+UNORDERED_AUTO_TEST (exhaustive_collide_tests) {
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide_tests:\n";
+  collide_map m;
+  exhaustive_erase_tests((collide_map*)0, 4, 4);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
+}
+
+UNORDERED_AUTO_TEST (exhaustive_collide2_tests) {
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide2_tests:\n";
+  exhaustive_erase_tests((collide_map2*)0, 8, 4);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
+}
+
+UNORDERED_AUTO_TEST (exhaustive_collide3_tests) {
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide3_tests:\n";
+  exhaustive_erase_tests((collide_map3*)0, 8, 4);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/erase_tests.cpp

@@ -0,0 +1,272 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include "../objects/test.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+#include "../helpers/equivalent.hpp"
+#include "../helpers/helpers.hpp"
+#include "../helpers/invariants.hpp"
+#include <vector>
+#include <cstdlib>
+
+namespace erase_tests {
+
+  test::seed_t initialize_seed(85638);
+
+  template <class Container>
+  void erase_tests1(Container*, test::random_generator generator)
+  {
+    typedef BOOST_DEDUCED_TYPENAME Container::iterator iterator;
+    typedef BOOST_DEDUCED_TYPENAME Container::const_iterator c_iterator;
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Erase by key.\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<Container> v(1000, generator);
+      Container x(v.begin(), v.end());
+      int iterations = 0;
+      for (BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator it =
+             v.begin();
+           it != v.end(); ++it) {
+        std::size_t count = x.count(test::get_key<Container>(*it));
+        std::size_t old_size = x.size();
+        BOOST_TEST(count == x.erase(test::get_key<Container>(*it)));
+        BOOST_TEST(x.size() == old_size - count);
+        BOOST_TEST(x.count(test::get_key<Container>(*it)) == 0);
+        BOOST_TEST(x.find(test::get_key<Container>(*it)) == x.end());
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(begin()).\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<Container> v(1000, generator);
+      Container x(v.begin(), v.end());
+      std::size_t size = x.size();
+      int iterations = 0;
+      while (size > 0 && !x.empty()) {
+        BOOST_DEDUCED_TYPENAME Container::key_type key =
+          test::get_key<Container>(*x.begin());
+        std::size_t count = x.count(key);
+        iterator pos = x.erase(x.begin());
+        --size;
+        BOOST_TEST(pos == x.begin());
+        BOOST_TEST(x.count(key) == count - 1);
+        BOOST_TEST(x.size() == size);
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(random position).\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<Container> v(1000, generator);
+      Container x(v.begin(), v.end());
+      std::size_t size = x.size();
+      int iterations = 0;
+      while (size > 0 && !x.empty()) {
+        std::size_t index = test::random_value(x.size());
+        c_iterator prev, pos, next;
+        if (index == 0) {
+          prev = pos = x.begin();
+        } else {
+          prev = test::next(x.begin(), index - 1);
+          pos = test::next(prev);
+        }
+        next = test::next(pos);
+        BOOST_DEDUCED_TYPENAME Container::key_type key =
+          test::get_key<Container>(*pos);
+        std::size_t count = x.count(key);
+        BOOST_TEST(count > 0);
+        BOOST_TEST(next == x.erase(pos));
+        --size;
+        if (size > 0)
+          BOOST_TEST(index == 0 ? next == x.begin() : next == test::next(prev));
+        BOOST_TEST(x.count(key) == count - 1);
+        if (x.count(key) != count - 1) {
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => " << x.count(key)
+                                         << std::endl;
+        }
+        BOOST_TEST(x.size() == size);
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(ranges).\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<Container> v(500, generator);
+      Container x(v.begin(), v.end());
+
+      std::size_t size = x.size();
+
+      // I'm actually stretching it a little here, as the standard says it
+      // returns 'the iterator immediately following the erase elements'
+      // and if nothing is erased, then there's nothing to follow. But I
+      // think this is the only sensible option...
+      BOOST_TEST(x.erase(x.end(), x.end()) == x.end());
+      BOOST_TEST(x.erase(x.begin(), x.begin()) == x.begin());
+      BOOST_TEST(x.size() == size);
+      test::check_equivalent_keys(x);
+
+      BOOST_TEST(x.erase(x.begin(), x.end()) == x.end());
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.begin() == x.end());
+      test::check_equivalent_keys(x);
+
+      BOOST_TEST(x.erase(x.begin(), x.end()) == x.begin());
+      test::check_equivalent_keys(x);
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(random ranges).\n";
+    {
+      test::check_instances check_;
+      Container x;
+
+      for (int i = 0; i < 100; ++i) {
+        test::random_values<Container> v(1000, generator);
+        x.insert(v.begin(), v.end());
+
+        // Note that erase only invalidates the erased iterators.
+        std::vector<c_iterator> iterators;
+        for (c_iterator it = x.cbegin(); it != x.cend(); ++it) {
+          iterators.push_back(it);
+        }
+        iterators.push_back(x.cend());
+
+        while (iterators.size() > 1) {
+          std::size_t start = test::random_value(iterators.size());
+          std::size_t length = test::random_value(iterators.size() - start);
+          x.erase(iterators[start], iterators[start + length]);
+          iterators.erase(test::next(iterators.begin(), start),
+            test::next(iterators.begin(), start + length));
+
+          BOOST_TEST(x.size() == iterators.size() - 1);
+          BOOST_DEDUCED_TYPENAME std::vector<c_iterator>::const_iterator i2 =
+            iterators.begin();
+          for (c_iterator i1 = x.cbegin(); i1 != x.cend(); ++i1) {
+            BOOST_TEST(i1 == *i2);
+            ++i2;
+          }
+          BOOST_TEST(x.cend() == *i2);
+
+          test::check_equivalent_keys(x);
+        }
+        BOOST_TEST(x.empty());
+      }
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "quick_erase(begin()).\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<Container> v(1000, generator);
+      Container x(v.begin(), v.end());
+      std::size_t size = x.size();
+      int iterations = 0;
+      while (size > 0 && !x.empty()) {
+        BOOST_DEDUCED_TYPENAME Container::key_type key =
+          test::get_key<Container>(*x.begin());
+        std::size_t count = x.count(key);
+        x.quick_erase(x.begin());
+        --size;
+        BOOST_TEST(x.count(key) == count - 1);
+        BOOST_TEST(x.size() == size);
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "quick_erase(random position).\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<Container> v(1000, generator);
+      Container x(v.begin(), v.end());
+      std::size_t size = x.size();
+      int iterations = 0;
+      while (size > 0 && !x.empty()) {
+        std::size_t index = test::random_value(x.size());
+        BOOST_DEDUCED_TYPENAME Container::const_iterator prev, pos, next;
+        if (index == 0) {
+          prev = pos = x.begin();
+        } else {
+          prev = test::next(x.begin(), index - 1);
+          pos = test::next(prev);
+        }
+        next = test::next(pos);
+        BOOST_DEDUCED_TYPENAME Container::key_type key =
+          test::get_key<Container>(*pos);
+        std::size_t count = x.count(key);
+        BOOST_TEST(count > 0);
+        x.quick_erase(pos);
+        --size;
+        if (size > 0)
+          BOOST_TEST(index == 0 ? next == x.begin() : next == test::next(prev));
+        BOOST_TEST(x.count(key) == count - 1);
+        if (x.count(key) != count - 1) {
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => " << x.count(key)
+                                         << std::endl;
+        }
+        BOOST_TEST(x.size() == size);
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "clear().\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<Container> v(500, generator);
+      Container x(v.begin(), v.end());
+      x.clear();
+      BOOST_TEST(x.empty());
+      BOOST_TEST(x.begin() == x.end());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
+  }
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_set;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multiset;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_map;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator2<test::object> >* test_multimap;
+
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+  UNORDERED_TEST(
+    erase_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
+                    (default_generator)(generate_collisions)(limited_range)))
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/extract_tests.cpp

@@ -0,0 +1,138 @@
+
+// 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/equivalent.hpp"
+#include "../helpers/helpers.hpp"
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/test.hpp"
+#include "../helpers/tracker.hpp"
+#include "../objects/test.hpp"
+#include <boost/next_prior.hpp>
+
+namespace extract_tests {
+
+  test::seed_t initialize_seed(85638);
+
+  template <class Container>
+  void extract_tests1(Container*, test::random_generator generator)
+  {
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Extract by key.\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<Container> v(1000, generator);
+      Container x(v.begin(), v.end());
+      int iterations = 0;
+      for (BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator it =
+             v.begin();
+           it != v.end(); ++it) {
+        std::size_t count = x.count(test::get_key<Container>(*it));
+        std::size_t old_size = x.size();
+        std::size_t new_count = count ? count - 1 : count;
+        std::size_t new_size = count ? old_size - 1 : old_size;
+        typename Container::node_type n =
+          x.extract(test::get_key<Container>(*it));
+        BOOST_TEST((n ? true : false) == (count ? true : false));
+        BOOST_TEST(x.size() == new_size);
+        BOOST_TEST(x.count(test::get_key<Container>(*it)) == new_count);
+        if (!new_count) {
+          BOOST_TEST(x.find(test::get_key<Container>(*it)) == x.end());
+        } else {
+          BOOST_TEST(x.find(test::get_key<Container>(*it)) != x.end());
+        }
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "extract(begin()).\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<Container> v(1000, generator);
+      Container x(v.begin(), v.end());
+      std::size_t size = x.size();
+      int iterations = 0;
+      while (size > 0 && !x.empty()) {
+        BOOST_DEDUCED_TYPENAME Container::key_type key =
+          test::get_key<Container>(*x.begin());
+        std::size_t count = x.count(key);
+        typename Container::node_type n = x.extract(x.begin());
+        BOOST_TEST(n);
+        --size;
+        BOOST_TEST(x.count(key) == count - 1);
+        BOOST_TEST(x.size() == size);
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "extract(random position).\n";
+    {
+      test::check_instances check_;
+
+      test::random_values<Container> v(1000, generator);
+      Container x(v.begin(), v.end());
+      std::size_t size = x.size();
+      int iterations = 0;
+      while (size > 0 && !x.empty()) {
+        using namespace std;
+        int index = rand() % (int)x.size();
+        BOOST_DEDUCED_TYPENAME Container::const_iterator prev, pos, next;
+        if (index == 0) {
+          prev = pos = x.begin();
+        } else {
+          prev = boost::next(x.begin(), index - 1);
+          pos = boost::next(prev);
+        }
+        next = boost::next(pos);
+        BOOST_DEDUCED_TYPENAME Container::key_type key =
+          test::get_key<Container>(*pos);
+        std::size_t count = x.count(key);
+        typename Container::node_type n = x.extract(pos);
+        BOOST_TEST(n);
+        --size;
+        if (size > 0)
+          BOOST_TEST(
+            index == 0 ? next == x.begin() : next == boost::next(prev));
+        BOOST_TEST(x.count(key) == count - 1);
+        BOOST_TEST(x.size() == size);
+        if (++iterations % 20 == 0)
+          test::check_equivalent_keys(x);
+      }
+      BOOST_TEST(x.empty());
+    }
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
+  }
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_set;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multiset;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_map;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator2<test::object> >* test_multimap;
+
+  using test::default_generator;
+  using test::generate_collisions;
+
+  UNORDERED_TEST(
+    extract_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
+                      (default_generator)(generate_collisions)))
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/find_tests.cpp

@@ -0,0 +1,161 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include "../objects/test.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+#include "../helpers/helpers.hpp"
+
+namespace find_tests {
+
+  test::seed_t initialize_seed(78937);
+
+  template <class X> void find_tests1(X*, test::random_generator generator)
+  {
+    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
+
+    {
+      test::check_instances check_;
+
+      test::random_values<X> v(500, generator);
+      X x(v.begin(), v.end());
+      X const& x_const = x;
+      test::ordered<X> tracker = test::create_ordered(x);
+      tracker.insert_range(v.begin(), v.end());
+
+      for (BOOST_DEDUCED_TYPENAME test::ordered<X>::const_iterator it1 =
+             tracker.begin();
+           it1 != tracker.end(); ++it1) {
+        BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it1);
+        BOOST_DEDUCED_TYPENAME X::const_iterator const_pos = x_const.find(key);
+        iterator pos = x.find(key);
+        BOOST_TEST(const_pos != x_const.end());
+        BOOST_TEST(const_pos != x_const.end() &&
+                   x_const.key_eq()(key, test::get_key<X>(*const_pos)));
+        BOOST_TEST(pos != x.end());
+        BOOST_TEST(pos != x.end() && x.key_eq()(key, test::get_key<X>(*pos)));
+
+        BOOST_TEST(x.count(key) == tracker.count(key));
+
+        test::compare_pairs(x.equal_range(key), tracker.equal_range(key),
+          (BOOST_DEDUCED_TYPENAME X::value_type*)0);
+        test::compare_pairs(x_const.equal_range(key), tracker.equal_range(key),
+          (BOOST_DEDUCED_TYPENAME X::value_type*)0);
+      }
+
+      test::random_values<X> v2(500, generator);
+      for (BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator it2 =
+             v2.begin();
+           it2 != v2.end(); ++it2) {
+        BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it2);
+        if (tracker.find(test::get_key<X>(key)) == tracker.end()) {
+          BOOST_TEST(x.find(key) == x.end());
+          BOOST_TEST(x_const.find(key) == x_const.end());
+          BOOST_TEST(x.count(key) == 0);
+          std::pair<iterator, iterator> range = x.equal_range(key);
+          BOOST_TEST(range.first == range.second);
+        }
+      }
+    }
+
+    {
+      test::check_instances check_;
+
+      X x;
+
+      test::random_values<X> v2(5, generator);
+      for (BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator it3 =
+             v2.begin();
+           it3 != v2.end(); ++it3) {
+        BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it3);
+        BOOST_TEST(x.find(key) == x.end());
+        BOOST_TEST(x.count(key) == 0);
+        std::pair<iterator, iterator> range = x.equal_range(key);
+        BOOST_TEST(range.first == range.second);
+      }
+    }
+  }
+
+  struct compatible_key
+  {
+    test::object o_;
+
+    compatible_key(test::object const& o) : o_(o) {}
+  };
+
+  struct compatible_hash
+  {
+    test::hash hash_;
+
+    std::size_t operator()(compatible_key const& k) const
+    {
+      return hash_(k.o_);
+    }
+  };
+
+  struct compatible_predicate
+  {
+    test::equal_to equal_;
+
+    bool operator()(compatible_key const& k1, compatible_key const& k2) const
+    {
+      return equal_(k1.o_, k2.o_);
+    }
+  };
+
+  template <class X>
+  void find_compatible_keys_test(X*, test::random_generator generator)
+  {
+    typedef BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
+      value_iterator;
+    test::random_values<X> v(500, generator);
+    X x(v.begin(), v.end());
+
+    compatible_hash h;
+    compatible_predicate eq;
+
+    for (value_iterator it = v.begin(), end = v.end(); it != end; ++it) {
+      BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it);
+      BOOST_TEST(x.find(key) == x.find(compatible_key(key), h, eq));
+    }
+
+    test::random_values<X> v2(20, generator);
+
+    for (value_iterator it = v2.begin(), end = v2.end(); it != end; ++it) {
+      BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it);
+      BOOST_TEST(x.find(key) == x.find(compatible_key(key), h, eq));
+    }
+  }
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_set;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_multiset;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_map;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator1<test::object> >* test_multimap;
+
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+  UNORDERED_TEST(
+    find_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
+                   (default_generator)(generate_collisions)(limited_range)))
+  UNORDERED_TEST(find_compatible_keys_test,
+    ((test_set)(test_multiset)(test_map)(test_multimap))(
+      (default_generator)(generate_collisions)(limited_range)))
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/fwd_map_test.cpp

@@ -0,0 +1,81 @@
+
+// Copyright 2008-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered/unordered_map_fwd.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+template <typename T>
+void call_swap(boost::unordered_map<T, T>& x, boost::unordered_map<T, T>& y)
+{
+  swap(x, y);
+}
+
+template <typename T>
+bool call_equals(boost::unordered_map<T, T>& x, boost::unordered_map<T, T>& y)
+{
+  return x == y;
+}
+
+template <typename T>
+bool call_not_equals(
+  boost::unordered_map<T, T>& x, boost::unordered_map<T, T>& y)
+{
+  return x != y;
+}
+
+template <typename T>
+void call_swap(
+  boost::unordered_multimap<T, T>& x, boost::unordered_multimap<T, T>& y)
+{
+  swap(x, y);
+}
+
+template <typename T>
+bool call_equals(
+  boost::unordered_multimap<T, T>& x, boost::unordered_multimap<T, T>& y)
+{
+  return x == y;
+}
+
+template <typename T>
+bool call_not_equals(
+  boost::unordered_multimap<T, T>& x, boost::unordered_multimap<T, T>& y)
+{
+  return x != y;
+}
+
+#include <boost/unordered_map.hpp>
+#include "../helpers/test.hpp"
+
+typedef boost::unordered_map<int, int> int_map;
+typedef boost::unordered_multimap<int, int> int_multimap;
+
+UNORDERED_AUTO_TEST (use_map_fwd_declared_function) {
+  int_map x, y;
+  x[1] = 2;
+  y[2] = 1;
+  call_swap(x, y);
+
+  BOOST_TEST(y.find(1) != y.end() && y.find(1)->second == 2);
+  BOOST_TEST(y.find(2) == y.end());
+
+  BOOST_TEST(x.find(1) == x.end());
+  BOOST_TEST(x.find(2) != x.end() && x.find(2)->second == 1);
+
+  BOOST_TEST(!call_equals(x, y));
+  BOOST_TEST(call_not_equals(x, y));
+}
+
+UNORDERED_AUTO_TEST (use_multimap_fwd_declared_function) {
+  int_multimap x, y;
+  call_swap(x, y);
+  BOOST_TEST(call_equals(x, y));
+  BOOST_TEST(!call_not_equals(x, y));
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/fwd_set_test.cpp

@@ -0,0 +1,106 @@
+
+// Copyright 2008-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered/unordered_set_fwd.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+struct true_type
+{
+  char x[100];
+};
+struct false_type
+{
+  char x;
+};
+
+false_type is_unordered_set_impl(void*);
+
+template <class Value, class Hash, class Pred, class Alloc>
+true_type is_unordered_set_impl(
+  boost::unordered_set<Value, Hash, Pred, Alloc>*);
+
+template <typename T>
+void call_swap(boost::unordered_set<T>& x, boost::unordered_set<T>& y)
+{
+  swap(x, y);
+}
+
+template <typename T>
+bool call_equals(boost::unordered_set<T>& x, boost::unordered_set<T>& y)
+{
+  return x == y;
+}
+
+template <typename T>
+bool call_not_equals(boost::unordered_set<T>& x, boost::unordered_set<T>& y)
+{
+  return x != y;
+}
+
+template <typename T>
+void call_swap(boost::unordered_multiset<T>& x, boost::unordered_multiset<T>& y)
+{
+  swap(x, y);
+}
+
+template <typename T>
+bool call_equals(
+  boost::unordered_multiset<T>& x, boost::unordered_multiset<T>& y)
+{
+  return x == y;
+}
+
+template <typename T>
+bool call_not_equals(
+  boost::unordered_multiset<T>& x, boost::unordered_multiset<T>& y)
+{
+  return x != y;
+}
+
+#include "../helpers/test.hpp"
+
+typedef boost::unordered_set<int> int_set;
+typedef boost::unordered_multiset<int> int_multiset;
+
+UNORDERED_AUTO_TEST (use_fwd_declared_trait_without_definition) {
+  BOOST_TEST(sizeof(is_unordered_set_impl((int_set*)0)) == sizeof(true_type));
+}
+
+#include <boost/unordered_set.hpp>
+
+UNORDERED_AUTO_TEST (use_fwd_declared_trait) {
+  boost::unordered_set<int> x;
+  BOOST_TEST(sizeof(is_unordered_set_impl(&x)) == sizeof(true_type));
+
+  BOOST_TEST(sizeof(is_unordered_set_impl((int*)0)) == sizeof(false_type));
+}
+
+UNORDERED_AUTO_TEST (use_set_fwd_declared_function) {
+  int_set x, y;
+  x.insert(1);
+  y.insert(2);
+  call_swap(x, y);
+
+  BOOST_TEST(y.find(1) != y.end());
+  BOOST_TEST(y.find(2) == y.end());
+
+  BOOST_TEST(x.find(1) == x.end());
+  BOOST_TEST(x.find(2) != x.end());
+
+  BOOST_TEST(!call_equals(x, y));
+  BOOST_TEST(call_not_equals(x, y));
+}
+
+UNORDERED_AUTO_TEST (use_multiset_fwd_declared_function) {
+  int_multiset x, y;
+  call_swap(x, y);
+  BOOST_TEST(call_equals(x, y));
+  BOOST_TEST(!call_not_equals(x, y));
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/incomplete_test.cpp

@@ -0,0 +1,173 @@
+
+// Copyright 2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include <utility>
+
+namespace x {
+  struct D
+  {
+    boost::unordered_map<D, D> x;
+  };
+}
+
+namespace incomplete_test {
+  // Declare, but don't define some types.
+
+  struct value;
+  struct hash;
+  struct equals;
+  template <class T> struct allocator;
+
+  // Declare some instances
+
+  typedef boost::unordered_map<value, value, hash, equals,
+    allocator<std::pair<value const, value> > >
+    map;
+  typedef boost::unordered_multimap<value, value, hash, equals,
+    allocator<std::pair<value const, value> > >
+    multimap;
+  typedef boost::unordered_set<value, hash, equals, allocator<value> > set;
+  typedef boost::unordered_multiset<value, hash, equals, allocator<value> >
+    multiset;
+
+  // Now define the types which are stored as members, as they are needed for
+  // declaring struct members.
+
+  struct hash
+  {
+    template <typename T> std::size_t operator()(T const&) const { return 0; }
+  };
+
+  struct equals
+  {
+    template <typename T> bool operator()(T const&, T const&) const
+    {
+      return true;
+    }
+  };
+
+  // This is a dubious way to implement an allocator, but good enough
+  // for this test.
+  template <typename T> struct allocator : std::allocator<T>
+  {
+    allocator() {}
+
+    template <typename T2>
+    allocator(const allocator<T2>& other) : std::allocator<T>(other)
+    {
+    }
+
+    template <typename T2>
+    allocator(const std::allocator<T2>& other) : std::allocator<T>(other)
+    {
+    }
+  };
+
+  // Declare some members of a structs.
+  //
+  // Incomplete hash, equals and allocator aren't here supported at the
+  // moment.
+
+  struct struct1
+  {
+    boost::unordered_map<struct1, struct1, hash, equals,
+      allocator<std::pair<struct1 const, struct1> > >
+      x;
+  };
+  struct struct2
+  {
+    boost::unordered_multimap<struct2, struct2, hash, equals,
+      allocator<std::pair<struct2 const, struct2> > >
+      x;
+  };
+  struct struct3
+  {
+    boost::unordered_set<struct3, hash, equals, allocator<struct3> > x;
+  };
+  struct struct4
+  {
+    boost::unordered_multiset<struct4, hash, equals, allocator<struct4> > x;
+  };
+
+  // Now define the value type.
+
+  struct value
+  {
+  };
+
+  // Create some instances.
+
+  incomplete_test::map m1;
+  incomplete_test::multimap m2;
+  incomplete_test::set s1;
+  incomplete_test::multiset s2;
+
+  incomplete_test::struct1 c1;
+  incomplete_test::struct2 c2;
+  incomplete_test::struct3 c3;
+  incomplete_test::struct4 c4;
+
+  // Now declare, but don't define, the operators required for comparing
+  // elements.
+
+  std::size_t hash_value(value const&);
+  bool operator==(value const&, value const&);
+
+  std::size_t hash_value(struct1 const&);
+  std::size_t hash_value(struct2 const&);
+  std::size_t hash_value(struct3 const&);
+  std::size_t hash_value(struct4 const&);
+
+  bool operator==(struct1 const&, struct1 const&);
+  bool operator==(struct2 const&, struct2 const&);
+  bool operator==(struct3 const&, struct3 const&);
+  bool operator==(struct4 const&, struct4 const&);
+
+  // And finally use these
+
+  void use_types()
+  {
+    incomplete_test::value x;
+    m1[x] = x;
+    m2.insert(std::make_pair(x, x));
+    s1.insert(x);
+    s2.insert(x);
+
+    c1.x.insert(std::make_pair(c1, c1));
+    c2.x.insert(std::make_pair(c2, c2));
+    c3.x.insert(c3);
+    c4.x.insert(c4);
+  }
+
+  // And finally define the operators required for comparing elements.
+
+  std::size_t hash_value(value const&) { return 0; }
+  bool operator==(value const&, value const&) { return true; }
+
+  std::size_t hash_value(struct1 const&) { return 0; }
+  std::size_t hash_value(struct2 const&) { return 0; }
+  std::size_t hash_value(struct3 const&) { return 0; }
+  std::size_t hash_value(struct4 const&) { return 0; }
+
+  bool operator==(struct1 const&, struct1 const&) { return true; }
+  bool operator==(struct2 const&, struct2 const&) { return true; }
+  bool operator==(struct3 const&, struct3 const&) { return true; }
+  bool operator==(struct4 const&, struct4 const&) { return true; }
+}
+
+int main()
+{
+  // This could just be a compile test, but I like to be able to run these
+  // things. It's probably irrational, but I find it reassuring.
+
+  incomplete_test::use_types();
+}

libs/unordered/test/unordered/insert_hint_tests.cpp

@@ -0,0 +1,121 @@
+
+// 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include "../helpers/invariants.hpp"
+
+#include <map>
+#include <set>
+
+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(), 1u);
+    BOOST_TEST_EQ(x.count(10), 1u);
+    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(), 1u);
+    BOOST_TEST_EQ(x.count("hello"), 1u);
+    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(), 2u);
+    BOOST_TEST_EQ(x.count("equal"), 2u);
+    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(), 2u);
+    BOOST_TEST_EQ(x.count(10), 2u);
+
+    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 + 1u);
+        BOOST_TEST_EQ(x.count("multiple"), size + 1u);
+        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(), 1u);
+    BOOST_TEST_EQ(x.count(10), 1u);
+    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(), 1u);
+    BOOST_TEST_EQ(x.count(10), 1u);
+    test::check_equivalent_keys(x);
+
+    x.insert(x.cbegin(), 20);
+    BOOST_TEST_EQ(x.size(), 2u);
+    BOOST_TEST_EQ(x.count(10), 1u);
+    BOOST_TEST_EQ(x.count(20), 1u);
+    test::check_equivalent_keys(x);
+  }
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/insert_node_type_fail.cpp

@@ -0,0 +1,34 @@
+
+// Copyright 2017 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 <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+
+int main()
+{
+#if defined(UNORDERED_TEST_MAP)
+  typedef boost::unordered_map<int, int> container;
+  container x;
+  x.emplace(1, 1);
+#elif defined(UNORDERED_TEST_MULTIMAP)
+  typedef boost::unordered_multimap<int, int> container;
+  container x;
+#elif defined(UNORDERED_TEST_SET)
+  typedef boost::unordered_set<int> container;
+  container x;
+  x.emplace(1);
+#elif defined(UNORDERED_TEST_MULTISET)
+  typedef boost::unordered_multiset<int> container;
+  container x;
+  x.emplace(1);
+#else
+#define UNORDERED_ERROR
+#endif
+
+#if !defined(UNORDERED_ERROR)
+  container::node_type n = x.extract(x.begin());
+  x.insert(n);
+#endif
+}

libs/unordered/test/unordered/insert_stable_tests.cpp

@@ -0,0 +1,117 @@
+
+// Copyright 2007-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+
+namespace insert_stable {
+  struct member
+  {
+    int tag1_;
+    int tag2_;
+
+    member() : tag1_(0), tag2_(0) {}
+    member(int t1, int t2) : tag1_(t1), tag2_(t2) {}
+
+    friend bool operator==(member const& x, member const& y)
+    {
+      return x.tag1_ == y.tag1_;
+    }
+
+    friend bool operator!=(member const& x, member const& y)
+    {
+      return x.tag1_ != y.tag1_;
+    }
+  };
+}
+
+#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+namespace boost
+#else
+namespace insert_stable
+#endif
+{
+  std::size_t hash_value(insert_stable::member const& x)
+  {
+    return static_cast<std::size_t>(x.tag1_);
+  }
+}
+
+// This is no longer supported, as there's no longer an efficient way to get to
+// the end of a group of equivalent nodes.
+#if 0
+
+UNORDERED_AUTO_TEST(stable_insert_test1)
+{
+    boost::unordered_multiset<insert_stable::member> x;
+
+    x.insert(insert_stable::member(1, 1));
+    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);
+    if (it != end) {
+        BOOST_TEST(it->tag2_ == 1);
+        ++it;
+    }
+    BOOST_TEST(it != end);
+    if (it != end) {
+        BOOST_TEST(it->tag2_ == 2);
+        ++it;
+    }
+    BOOST_TEST(it != end);
+    if (it != end) {
+        BOOST_TEST(it->tag2_ == 3);
+        ++it;
+    }
+    BOOST_TEST(it == end);
+}
+
+UNORDERED_AUTO_TEST(stable_insert_test2)
+{
+    boost::unordered_multimap<insert_stable::member, int> x;
+    typedef boost::unordered_multimap<insert_stable::member,
+        int>::const_iterator iterator;
+
+    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();
+    BOOST_TEST(it != end);
+    if (it != end) {
+        BOOST_TEST(it->first.tag2_ == 1 && it->second == 1);
+        ++it;
+    }
+    BOOST_TEST(it != end);
+    if (it != end) {
+        BOOST_TEST(it->first.tag2_ == 2 && it->second == 2);
+        ++it;
+    }
+    BOOST_TEST(it != end);
+    if (it != end) {
+        BOOST_TEST(it->first.tag2_ == 3 && it->second == 3);
+        ++it;
+    }
+    BOOST_TEST(it == end);
+}
+
+#endif
+
+RUN_TESTS()

libs/unordered/test/unordered/link_test_1.cpp

@@ -0,0 +1,26 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+void foo(boost::unordered_set<int>&, boost::unordered_map<int, int>&,
+  boost::unordered_multiset<int>&, boost::unordered_multimap<int, int>&);
+
+int main()
+{
+  boost::unordered_set<int> x1;
+  boost::unordered_map<int, int> x2;
+  boost::unordered_multiset<int> x3;
+  boost::unordered_multimap<int, int> x4;
+
+  foo(x1, x2, x3, x4);
+
+  return 0;
+}

libs/unordered/test/unordered/link_test_2.cpp

@@ -0,0 +1,30 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+void foo(boost::unordered_set<int>& x1, boost::unordered_map<int, int>& x2,
+  boost::unordered_multiset<int>& x3, boost::unordered_multimap<int, int>& x4)
+{
+#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
+  struct dummy
+  {
+    boost::unordered_set<int> x1;
+    boost::unordered_map<int, int> x2;
+    boost::unordered_multiset<int> x3;
+    boost::unordered_multimap<int, int> x4;
+  };
+#endif
+
+  x1.insert(1);
+  x2[2] = 2;
+  x3.insert(3);
+  x4.insert(std::make_pair(4, 5));
+}

libs/unordered/test/unordered/load_factor_tests.cpp

@@ -0,0 +1,98 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include <boost/limits.hpp>
+#include "../helpers/random_values.hpp"
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable : 4127) // conditional expression is constant
+#endif
+
+namespace load_factor_tests {
+
+  test::seed_t initialize_seed(783656);
+
+  template <class X> void set_load_factor_tests(X*)
+  {
+    X x;
+
+    BOOST_TEST(x.max_load_factor() == 1.0);
+    BOOST_TEST(x.load_factor() == 0);
+
+    // A valid implementation could fail these tests, but I think they're
+    // reasonable.
+    x.max_load_factor(2.0);
+    BOOST_TEST(x.max_load_factor() == 2.0);
+    x.max_load_factor(0.5);
+    BOOST_TEST(x.max_load_factor() == 0.5);
+  }
+
+  template <class X>
+  void insert_test(X*, float mlf, test::random_generator generator)
+  {
+    X x;
+    x.max_load_factor(mlf);
+    float b = x.max_load_factor();
+
+    test::random_values<X> values(1000, generator);
+
+    for (BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
+           it = values.begin(),
+           end = values.end();
+         it != end; ++it) {
+      BOOST_DEDUCED_TYPENAME X::size_type old_size = x.size(),
+                                          old_bucket_count = x.bucket_count();
+      x.insert(*it);
+      if (static_cast<double>(old_size + 1) <=
+          b * static_cast<double>(old_bucket_count))
+        BOOST_TEST(x.bucket_count() == old_bucket_count);
+    }
+  }
+
+  template <class X>
+  void load_factor_insert_tests(X* ptr, test::random_generator generator)
+  {
+    insert_test(ptr, 1.0f, generator);
+    insert_test(ptr, 0.1f, generator);
+    insert_test(ptr, 100.0f, generator);
+
+    insert_test(ptr, (std::numeric_limits<float>::min)(), generator);
+
+    if (std::numeric_limits<float>::has_infinity)
+      insert_test(ptr, std::numeric_limits<float>::infinity(), generator);
+  }
+
+  boost::unordered_set<int>* int_set_ptr;
+  boost::unordered_multiset<int>* int_multiset_ptr;
+  boost::unordered_map<int, int>* int_map_ptr;
+  boost::unordered_multimap<int, int>* int_multimap_ptr;
+
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+  UNORDERED_TEST(set_load_factor_tests,
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)))
+
+  UNORDERED_TEST(load_factor_insert_tests,
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))(
+      (default_generator)(generate_collisions)(limited_range)))
+}
+
+RUN_TESTS()
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#pragma warning(disable : 4127) // conditional expression is constant
+#endif

libs/unordered/test/unordered/merge_tests.cpp

@@ -0,0 +1,338 @@
+
+// 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/postfix.hpp"
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+
+#include "../helpers/count.hpp"
+#include "../helpers/helpers.hpp"
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/test.hpp"
+#include "../helpers/tracker.hpp"
+#include "../objects/test.hpp"
+#include <boost/next_prior.hpp>
+
+namespace merge_tests {
+
+  UNORDERED_AUTO_TEST (merge_set) {
+    boost::unordered_set<int> x;
+    boost::unordered_set<int> y;
+
+    x.merge(y);
+    BOOST_TEST(x.empty());
+    BOOST_TEST(y.empty());
+
+    x.insert(10);
+    x.merge(y);
+    BOOST_TEST(x.size() == 1);
+    BOOST_TEST(x.count(10) == 1);
+    BOOST_TEST(y.empty());
+
+    y.merge(x);
+    BOOST_TEST(x.empty());
+    BOOST_TEST(y.size() == 1);
+    BOOST_TEST(y.count(10) == 1);
+
+    x.insert(10);
+    x.insert(50);
+    y.insert(70);
+    y.insert(80);
+    x.merge(y);
+    BOOST_TEST_EQ(x.size(), 4u);
+    BOOST_TEST_EQ(y.size(), 1u);
+    BOOST_TEST_EQ(x.count(10), 1u);
+    BOOST_TEST_EQ(x.count(50), 1u);
+    BOOST_TEST_EQ(x.count(70), 1u);
+    BOOST_TEST_EQ(x.count(80), 1u);
+    BOOST_TEST_EQ(y.count(10), 1u);
+    BOOST_TEST_EQ(y.count(50), 0u);
+    BOOST_TEST_EQ(y.count(70), 0u);
+    BOOST_TEST_EQ(y.count(80), 0u);
+
+    test::check_equivalent_keys(x);
+    test::check_equivalent_keys(y);
+  }
+
+  UNORDERED_AUTO_TEST (merge_multiset) {
+    boost::unordered_multiset<int> x;
+    boost::unordered_multiset<int> y;
+
+    x.merge(y);
+    BOOST_TEST(x.empty());
+    BOOST_TEST(y.empty());
+
+    x.insert(10);
+    x.merge(y);
+    BOOST_TEST(x.size() == 1);
+    BOOST_TEST(x.count(10) == 1);
+    BOOST_TEST(y.empty());
+
+    y.merge(x);
+    BOOST_TEST(x.empty());
+    BOOST_TEST(y.size() == 1);
+    BOOST_TEST(y.count(10) == 1);
+
+    x.insert(10);
+    x.insert(50);
+    y.insert(70);
+    y.insert(80);
+    x.merge(y);
+    BOOST_TEST_EQ(x.size(), 5u);
+    BOOST_TEST_EQ(y.size(), 0u);
+    BOOST_TEST_EQ(x.count(10), 2u);
+    BOOST_TEST_EQ(x.count(50), 1u);
+    BOOST_TEST_EQ(x.count(70), 1u);
+    BOOST_TEST_EQ(x.count(80), 1u);
+    BOOST_TEST_EQ(y.count(10), 0u);
+    BOOST_TEST_EQ(y.count(50), 0u);
+    BOOST_TEST_EQ(y.count(70), 0u);
+    BOOST_TEST_EQ(y.count(80), 0u);
+
+    test::check_equivalent_keys(x);
+    test::check_equivalent_keys(y);
+  }
+
+  UNORDERED_AUTO_TEST (merge_set_and_multiset) {
+    boost::unordered_set<int> x;
+    boost::unordered_multiset<int> y;
+
+    x.merge(y);
+    BOOST_TEST(x.empty());
+    BOOST_TEST(y.empty());
+
+    x.insert(10);
+    x.merge(y);
+    BOOST_TEST(x.size() == 1);
+    BOOST_TEST(x.count(10) == 1);
+    BOOST_TEST(y.empty());
+
+    y.merge(x);
+    BOOST_TEST(x.empty());
+    BOOST_TEST(y.size() == 1);
+    BOOST_TEST(y.count(10) == 1);
+
+    x.insert(10);
+    x.insert(50);
+    y.insert(70);
+    y.insert(80);
+    x.merge(y);
+    BOOST_TEST_EQ(x.size(), 4u);
+    BOOST_TEST_EQ(y.size(), 1u);
+    BOOST_TEST_EQ(x.count(10), 1u);
+    BOOST_TEST_EQ(x.count(50), 1u);
+    BOOST_TEST_EQ(x.count(70), 1u);
+    BOOST_TEST_EQ(x.count(80), 1u);
+    BOOST_TEST_EQ(y.count(10), 1u);
+    BOOST_TEST_EQ(y.count(50), 0u);
+    BOOST_TEST_EQ(y.count(70), 0u);
+    BOOST_TEST_EQ(y.count(80), 0u);
+
+    test::check_equivalent_keys(x);
+    test::check_equivalent_keys(y);
+  }
+
+  template <class X1, class X2>
+  void merge_empty_test(X1*, X2*, test::random_generator generator)
+  {
+    test::check_instances check_;
+
+    test::random_values<X1> v(1000, generator);
+    X1 x1(v.begin(), v.end());
+    X2 x2;
+    x1.merge(x2);
+    test::check_container(x1, v);
+    BOOST_TEST(x2.empty());
+    test::check_equivalent_keys(x1);
+    test::check_equivalent_keys(x2);
+  }
+
+  template <class X>
+  void merge_into_empty_test(X*, test::random_generator generator)
+  {
+    test::check_instances check_;
+
+    test::random_values<X> v(1000, generator);
+    X x1;
+    X x2(v.begin(), v.end());
+    x1.merge(x2);
+    test::check_container(x1, v);
+    BOOST_TEST(x2.empty());
+    test::check_equivalent_keys(x1);
+    test::check_equivalent_keys(x2);
+  }
+
+  template <class X1, class X2>
+  void merge_into_unique_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
+    test::random_generator generator)
+  {
+    test::check_instances check_;
+
+    test::random_values<X1> v1(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));
+
+    X1 x1(v1.begin(), v1.end(), 0, test::hash(hash_equal1),
+      test::equal_to(hash_equal1));
+    X2 x2(v2.begin(), v2.end(), 0, test::hash(hash_equal2),
+      test::equal_to(hash_equal2));
+
+    test::ordered<X1> tracker1 = test::create_ordered(x1);
+    test::ordered<X2> tracker2 = test::create_ordered(x2);
+    tracker1.insert(v1.begin(), v1.end());
+    for (typename X2::iterator it = x2.begin(); it != x2.end(); ++it) {
+      if (!tracker1.insert(*it).second) {
+        tracker2.insert(*it);
+      }
+    }
+
+    x1.merge(x2);
+
+    tracker1.compare(x1);
+    tracker2.compare(x2);
+    test::check_equivalent_keys(x1);
+    test::check_equivalent_keys(x2);
+  }
+
+  template <class X1, class X2>
+  void merge_into_equiv_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
+    test::random_generator generator)
+  {
+    test::check_instances check_;
+
+    test::random_values<X1> v1(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));
+
+    X1 x1(v1.begin(), v1.end(), 0, test::hash(hash_equal1),
+      test::equal_to(hash_equal1));
+    X2 x2(v2.begin(), v2.end(), 0, test::hash(hash_equal2),
+      test::equal_to(hash_equal2));
+    x1.merge(x2);
+
+    test::ordered<X1> tracker1 = test::create_ordered(x1);
+    test::ordered<X2> tracker2 = test::create_ordered(x2);
+    tracker1.insert(v1.begin(), v1.end());
+    tracker2.insert(v2.begin(), v2.end());
+    tracker1.insert(tracker2.begin(), tracker2.end());
+    tracker2.clear();
+
+    tracker1.compare(x1);
+    tracker2.compare(x2);
+    test::check_equivalent_keys(x1);
+    test::check_equivalent_keys(x2);
+  }
+
+  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::object, test::hash, test::equal_to,
+    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::movable, test::movable, test::hash,
+    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_multiset_std_alloc))
+    ((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_multiset_std_alloc))
+    ((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(merge_into_unique_keys_test,
+    ((test_set_std_alloc))
+    ((test_set_std_alloc)(test_multiset_std_alloc))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_unique_keys_test,
+    ((test_map_std_alloc))
+    ((test_map_std_alloc)(test_multimap_std_alloc))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_unique_keys_test,
+    ((test_set))
+    ((test_set)(test_multiset))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_unique_keys_test,
+    ((test_map))
+    ((test_map)(test_multimap))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+
+UNORDERED_TEST(merge_into_equiv_keys_test,
+    ((test_multiset_std_alloc))
+    ((test_set_std_alloc)(test_multiset_std_alloc))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_equiv_keys_test,
+    ((test_multimap_std_alloc))
+    ((test_map_std_alloc)(test_multimap_std_alloc))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_equiv_keys_test,
+    ((test_multiset))
+    ((test_set)(test_multiset))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_equiv_keys_test,
+    ((test_multimap))
+    ((test_map)(test_multimap))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+  // clang-format on
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/minimal_allocator.cpp

@@ -0,0 +1,92 @@
+
+// Copyright 2011 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 "../objects/test.hpp"
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/unordered/detail/implementation.hpp>
+
+template <class Tp> struct SimpleAllocator
+{
+  typedef Tp value_type;
+
+  SimpleAllocator() {}
+
+  template <class T> SimpleAllocator(const SimpleAllocator<T>&) {}
+
+  Tp* allocate(std::size_t n)
+  {
+    return static_cast<Tp*>(::operator new(n * sizeof(Tp)));
+  }
+
+  void deallocate(Tp* p, std::size_t) { ::operator delete((void*)p); }
+};
+
+template <typename T> void test_simple_allocator()
+{
+  test::check_instances check_;
+
+  typedef boost::unordered::detail::allocator_traits<SimpleAllocator<T> >
+    traits;
+
+  BOOST_STATIC_ASSERT((boost::is_same<typename traits::allocator_type,
+    SimpleAllocator<T> >::value));
+
+  BOOST_STATIC_ASSERT((boost::is_same<typename traits::value_type, T>::value));
+
+  BOOST_STATIC_ASSERT((boost::is_same<typename traits::pointer, T*>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<typename traits::const_pointer, T const*>::value));
+  // BOOST_STATIC_ASSERT((boost::is_same<typename traits::void_pointer, void*
+  // >::value));
+  // BOOST_STATIC_ASSERT((boost::is_same<typename traits::const_void_pointer,
+  // void const*>::value));
+
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<typename traits::difference_type, std::ptrdiff_t>::value));
+
+#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
+  BOOST_STATIC_ASSERT((boost::is_same<typename traits::size_type,
+    std::make_unsigned<std::ptrdiff_t>::type>::value));
+#else
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<typename traits::size_type, std::size_t>::value));
+#endif
+
+  BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
+  BOOST_TEST(!traits::propagate_on_container_swap::value);
+
+  // rebind_alloc
+  // rebind_traits
+
+  SimpleAllocator<T> a;
+
+  T* ptr1 = traits::allocate(a, 1);
+  // T* ptr2 = traits::allocate(a, 1, static_cast<void const*>(ptr1));
+
+  traits::construct(a, ptr1, T(10));
+  // traits::construct(a, ptr2, T(30), ptr1);
+
+  BOOST_TEST(*ptr1 == T(10));
+  // BOOST_TEST(*ptr2 == T(30));
+
+  traits::destroy(a, ptr1);
+  // traits::destroy(a, ptr2);
+
+  // traits::deallocate(a, ptr2, 1);
+  traits::deallocate(a, ptr1, 1);
+
+  traits::max_size(a);
+}
+
+int main()
+{
+  test_simple_allocator<int>();
+  test_simple_allocator<test::object>();
+
+  return boost::report_errors();
+}

libs/unordered/test/unordered/move_tests.cpp

@@ -0,0 +1,372 @@
+
+// Copyright 2008-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or move at http://www.boost.org/LICENSE_1_0.txt)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include "../objects/test.hpp"
+#include "../objects/cxx11_allocator.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+#include "../helpers/equivalent.hpp"
+#include "../helpers/invariants.hpp"
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable : 4127) // conditional expression is constant
+#endif
+
+namespace move_tests {
+  test::seed_t initialize_seed(98624);
+#if defined(BOOST_UNORDERED_USE_MOVE) ||                                       \
+  !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#define BOOST_UNORDERED_TEST_MOVING 1
+#else
+#define BOOST_UNORDERED_TEST_MOVING 0
+#endif
+
+  template <class T> T empty(T*) { return T(); }
+
+  template <class T>
+  T create(test::random_values<T> const& v, test::object_count& count)
+  {
+    T x(v.begin(), v.end());
+    count = test::global_object_count;
+    return x;
+  }
+
+  template <class T>
+  T create(test::random_values<T> const& v, test::object_count& count,
+    BOOST_DEDUCED_TYPENAME T::hasher hf, BOOST_DEDUCED_TYPENAME T::key_equal eq,
+    BOOST_DEDUCED_TYPENAME T::allocator_type al, float mlf)
+  {
+    T x(0, hf, eq, al);
+    x.max_load_factor(mlf);
+    x.insert(v.begin(), v.end());
+    count = test::global_object_count;
+    return x;
+  }
+
+  template <class T>
+  void move_construct_tests1(T* ptr, test::random_generator const& generator)
+  {
+    BOOST_DEDUCED_TYPENAME T::hasher hf;
+    BOOST_DEDUCED_TYPENAME T::key_equal eq;
+    BOOST_DEDUCED_TYPENAME T::allocator_type al;
+
+    {
+      test::check_instances check_;
+
+      T y(empty(ptr));
+      BOOST_TEST(y.empty());
+      BOOST_TEST(test::equivalent(y.hash_function(), hf));
+      BOOST_TEST(test::equivalent(y.key_eq(), eq));
+      BOOST_TEST(test::equivalent(y.get_allocator(), al));
+      BOOST_TEST(y.max_load_factor() == 1.0);
+      test::check_equivalent_keys(y);
+    }
+
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(1000, generator);
+      test::object_count count;
+      T y(create(v, count));
+#if defined(BOOST_HAS_NRVO)
+      BOOST_TEST(count == test::global_object_count);
+#endif
+      test::check_container(y, v);
+      test::check_equivalent_keys(y);
+    }
+  }
+
+  template <class T>
+  void move_assign_tests1(T*, test::random_generator const& generator)
+  {
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(500, generator);
+      test::object_count count;
+      T y;
+      y = create(v, count);
+#if BOOST_UNORDERED_TEST_MOVING && defined(BOOST_HAS_NRVO)
+      BOOST_TEST(count == test::global_object_count);
+#endif
+      test::check_container(y, v);
+      test::check_equivalent_keys(y);
+    }
+  }
+
+  template <class T>
+  void move_construct_tests2(T*, test::random_generator const& generator)
+  {
+    BOOST_DEDUCED_TYPENAME T::hasher hf(1);
+    BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
+
+    test::object_count count;
+
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(500, generator);
+      T y(create(v, count, hf, eq, al, 0.5));
+#if defined(BOOST_HAS_NRVO)
+      BOOST_TEST(count == test::global_object_count);
+#endif
+      test::check_container(y, v);
+      BOOST_TEST(test::equivalent(y.hash_function(), hf));
+      BOOST_TEST(test::equivalent(y.key_eq(), eq));
+      BOOST_TEST(test::equivalent(y.get_allocator(), al));
+      BOOST_TEST(y.max_load_factor() == 0.5); // Not necessarily required.
+      test::check_equivalent_keys(y);
+    }
+
+    {
+      test::check_instances check_;
+
+      // TODO: To do this correctly requires the fancy new allocator
+      // stuff.
+      test::random_values<T> v(500, generator);
+      T y(create(v, count, hf, eq, al, 2.0), al2);
+      BOOST_TEST(count != test::global_object_count);
+      test::check_container(y, v);
+      BOOST_TEST(test::equivalent(y.hash_function(), hf));
+      BOOST_TEST(test::equivalent(y.key_eq(), eq));
+      BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+      BOOST_TEST(y.max_load_factor() == 2.0); // Not necessarily required.
+      test::check_equivalent_keys(y);
+    }
+
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(25, generator);
+      T y(create(v, count, hf, eq, al, 1.0), al);
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+      BOOST_TEST(count == test::global_object_count);
+#elif defined(BOOST_HAS_NRVO)
+      BOOST_TEST(
+        static_cast<std::size_t>(
+          test::global_object_count.constructions - count.constructions) <=
+        (test::is_set<T>::value ? 1 : 2) *
+          (test::has_unique_keys<T>::value ? 25 : v.size()));
+      BOOST_TEST(count.instances == test::global_object_count.instances);
+#else
+      BOOST_TEST(
+        static_cast<std::size_t>(
+          test::global_object_count.constructions - count.constructions) <=
+        (test::is_set<T>::value ? 2 : 4) *
+          (test::has_unique_keys<T>::value ? 25 : v.size()));
+      BOOST_TEST(count.instances == test::global_object_count.instances);
+#endif
+      test::check_container(y, v);
+      BOOST_TEST(test::equivalent(y.hash_function(), hf));
+      BOOST_TEST(test::equivalent(y.key_eq(), eq));
+      BOOST_TEST(test::equivalent(y.get_allocator(), al));
+      BOOST_TEST(y.max_load_factor() == 1.0); // Not necessarily required.
+      test::check_equivalent_keys(y);
+    }
+  }
+
+  template <class T>
+  void move_assign_tests2(T*, test::random_generator const& generator)
+  {
+    BOOST_DEDUCED_TYPENAME T::hasher hf(1);
+    BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
+    BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
+    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+
+    {
+      test::random_values<T> v(500, generator);
+      test::random_values<T> v2(0, generator);
+      T y(v.begin(), v.end(), 0, hf, eq, al1);
+      test::object_count count;
+      y = create(v2, count, hf, eq, al2, 2.0);
+      BOOST_TEST(y.empty());
+      test::check_container(y, v2);
+      test::check_equivalent_keys(y);
+      BOOST_TEST(y.max_load_factor() == 2.0);
+
+#if defined(BOOST_HAS_NRVO)
+      if (BOOST_UNORDERED_TEST_MOVING
+            ? (bool)allocator_type::is_propagate_on_move
+            : (bool)allocator_type::is_propagate_on_assign) {
+        BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+      } else {
+        BOOST_TEST(test::equivalent(y.get_allocator(), al1));
+      }
+#endif
+    }
+
+    {
+      test::random_values<T> v(500, generator);
+      test::object_count count;
+      T y(0, hf, eq, al1);
+      y = create(v, count, hf, eq, al2, 0.5);
+#if defined(BOOST_HAS_NRVO)
+      if (BOOST_UNORDERED_TEST_MOVING && allocator_type::is_propagate_on_move) {
+        BOOST_TEST(count == test::global_object_count);
+      }
+#endif
+      test::check_container(y, v);
+      test::check_equivalent_keys(y);
+      BOOST_TEST(y.max_load_factor() == 0.5);
+
+#if defined(BOOST_HAS_NRVO)
+      if (BOOST_UNORDERED_TEST_MOVING
+            ? (bool)allocator_type::is_propagate_on_move
+            : (bool)allocator_type::is_propagate_on_assign) {
+        BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+      } else {
+        BOOST_TEST(test::equivalent(y.get_allocator(), al1));
+      }
+#endif
+    }
+
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v(500, generator);
+      T y(0, hf, eq, al1);
+
+      T x(0, hf, eq, al2);
+      x.max_load_factor(0.25);
+      x.insert(v.begin(), v.end());
+
+      test::object_count count = test::global_object_count;
+      y = boost::move(x);
+      if (BOOST_UNORDERED_TEST_MOVING && allocator_type::is_propagate_on_move) {
+        BOOST_TEST(count == test::global_object_count);
+      }
+      test::check_container(y, v);
+      test::check_equivalent_keys(y);
+      BOOST_TEST(y.max_load_factor() == 0.25);
+
+      if (BOOST_UNORDERED_TEST_MOVING
+            ? (bool)allocator_type::is_propagate_on_move
+            : (bool)allocator_type::is_propagate_on_assign) {
+        BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+      } else {
+        BOOST_TEST(test::equivalent(y.get_allocator(), al1));
+      }
+    }
+
+    {
+      test::check_instances check_;
+
+      test::random_values<T> v1(1000, generator);
+      test::random_values<T> v2(200, generator);
+
+      T x(0, hf, eq, al2);
+      x.max_load_factor(0.5);
+      x.insert(v2.begin(), v2.end());
+
+      test::object_count count1 = test::global_object_count;
+
+      T y(v1.begin(), v1.end(), 0, hf, eq, al1);
+      y = boost::move(x);
+
+      test::object_count count2 = test::global_object_count;
+
+      if (BOOST_UNORDERED_TEST_MOVING && allocator_type::is_propagate_on_move) {
+        BOOST_TEST(count1.instances == test::global_object_count.instances);
+        BOOST_TEST(
+          count2.constructions == test::global_object_count.constructions);
+      }
+
+      test::check_container(y, v2);
+      test::check_equivalent_keys(y);
+      BOOST_TEST(y.max_load_factor() == 0.5);
+
+      if (BOOST_UNORDERED_TEST_MOVING
+            ? (bool)allocator_type::is_propagate_on_move
+            : (bool)allocator_type::is_propagate_on_assign) {
+        BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+      } else {
+        BOOST_TEST(test::equivalent(y.get_allocator(), al1));
+      }
+    }
+  }
+
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    std::allocator<test::object> >* test_map_std_alloc;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_set;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_multiset;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_map;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator2<test::object> >* test_multimap;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_move> >*
+    test_set_prop_move;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_move> >*
+    test_multiset_prop_move;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_move> >*
+    test_map_prop_move;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::cxx11_allocator<test::object, test::propagate_move> >*
+    test_multimap_prop_move;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_move> >*
+    test_set_no_prop_move;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_move> >*
+    test_multiset_no_prop_move;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_move> >*
+    test_map_no_prop_move;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_move> >*
+    test_multimap_no_prop_move;
+
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+  UNORDERED_TEST(move_construct_tests1,
+    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)(
+      test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(
+      test_multimap_prop_move)(test_set_no_prop_move)(
+      test_multiset_no_prop_move)(test_map_no_prop_move)(
+      test_multimap_no_prop_move))(
+      (default_generator)(generate_collisions)(limited_range)))
+  UNORDERED_TEST(move_assign_tests1,
+    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)(
+      test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(
+      test_multimap_prop_move)(test_set_no_prop_move)(
+      test_multiset_no_prop_move)(test_map_no_prop_move)(
+      test_multimap_no_prop_move))(
+      (default_generator)(generate_collisions)(limited_range)))
+  UNORDERED_TEST(move_construct_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_prop_move)(
+      test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)(
+      test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(
+      test_multimap_no_prop_move))(
+      (default_generator)(generate_collisions)(limited_range)))
+  UNORDERED_TEST(move_assign_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_prop_move)(
+      test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)(
+      test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(
+      test_multimap_no_prop_move))(
+      (default_generator)(generate_collisions)(limited_range)))
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/node_handle_tests.cpp

@@ -0,0 +1,426 @@
+
+// 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/postfix.hpp"
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+
+#include "../helpers/helpers.hpp"
+#include "../helpers/metafunctions.hpp"
+#include "../helpers/test.hpp"
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <set>
+#include <string>
+
+UNORDERED_AUTO_TEST (example1) {
+  typedef boost::unordered_map<int, std::string>::insert_return_type
+    insert_return_type;
+
+  boost::unordered_map<int, std::string> src;
+  src.emplace(1, "one");
+  src.emplace(2, "two");
+  src.emplace(3, "buckle my shoe");
+  boost::unordered_map<int, std::string> dst;
+  dst.emplace(3, "three");
+
+  dst.insert(src.extract(src.find(1)));
+  dst.insert(src.extract(2));
+  insert_return_type r = dst.insert(src.extract(3));
+
+  BOOST_TEST(src.empty());
+  BOOST_TEST(dst.size() == 3);
+  BOOST_TEST(dst[1] == "one");
+  BOOST_TEST(dst[2] == "two");
+  BOOST_TEST(dst[3] == "three");
+  BOOST_TEST(!r.inserted);
+  BOOST_TEST(r.position == dst.find(3));
+  BOOST_TEST(r.node.mapped() == "buckle my shoe");
+}
+
+UNORDERED_AUTO_TEST (example2) {
+  boost::unordered_set<int> src;
+  src.insert(1);
+  src.insert(3);
+  src.insert(5);
+  boost::unordered_set<int> dst;
+  dst.insert(2);
+  dst.insert(4);
+  dst.insert(5);
+  // dst.merge(src);
+  // Merge src into dst.
+  // src == {5}
+  // dst == {1, 2, 3, 4, 5}
+}
+
+UNORDERED_AUTO_TEST (example3) {
+  typedef boost::unordered_set<int>::iterator iterator;
+
+  boost::unordered_set<int> src;
+  src.insert(1);
+  src.insert(3);
+  src.insert(5);
+  boost::unordered_set<int> dst;
+  dst.insert(2);
+  dst.insert(4);
+  dst.insert(5);
+  for (iterator i = src.begin(); i != src.end();) {
+    std::pair<iterator, iterator> p = dst.equal_range(*i);
+    if (p.first == p.second)
+      dst.insert(p.first, src.extract(i++));
+    else
+      ++i;
+  }
+  BOOST_TEST(src.size() == 1);
+  BOOST_TEST(*src.begin() == 5);
+
+  std::set<int> dst2(dst.begin(), dst.end());
+  std::set<int>::iterator it = dst2.begin();
+  BOOST_TEST(*it++ == 1);
+  BOOST_TEST(*it++ == 2);
+  BOOST_TEST(*it++ == 3);
+  BOOST_TEST(*it++ == 4);
+  BOOST_TEST(*it++ == 5);
+  BOOST_TEST(it == dst2.end());
+}
+
+UNORDERED_AUTO_TEST (failed_insertion_with_hint) {
+  {
+    boost::unordered_set<int> src;
+    boost::unordered_set<int> dst;
+    src.emplace(10);
+    src.emplace(20);
+    dst.emplace(10);
+    dst.emplace(20);
+
+    boost::unordered_set<int>::node_type nh = src.extract(10);
+
+    BOOST_TEST(dst.insert(dst.find(10), boost::move(nh)) == dst.find(10));
+    BOOST_TEST(nh);
+    BOOST_TEST(!nh.empty());
+    BOOST_TEST(nh.value() == 10);
+
+    BOOST_TEST(dst.insert(dst.find(20), boost::move(nh)) == dst.find(10));
+    BOOST_TEST(nh);
+    BOOST_TEST(!nh.empty());
+    BOOST_TEST(nh.value() == 10);
+
+    BOOST_TEST(src.count(10) == 0);
+    BOOST_TEST(src.count(20) == 1);
+    BOOST_TEST(dst.count(10) == 1);
+    BOOST_TEST(dst.count(20) == 1);
+  }
+
+  {
+    boost::unordered_map<int, int> src;
+    boost::unordered_map<int, int> dst;
+    src.emplace(10, 30);
+    src.emplace(20, 5);
+    dst.emplace(10, 20);
+    dst.emplace(20, 2);
+
+    boost::unordered_map<int, int>::node_type nh = src.extract(10);
+    BOOST_TEST(dst.insert(dst.find(10), boost::move(nh)) == dst.find(10));
+    BOOST_TEST(nh);
+    BOOST_TEST(!nh.empty());
+    BOOST_TEST(nh.key() == 10);
+    BOOST_TEST(nh.mapped() == 30);
+    BOOST_TEST(dst[10] == 20);
+
+    BOOST_TEST(dst.insert(dst.find(20), boost::move(nh)) == dst.find(10));
+    BOOST_TEST(nh);
+    BOOST_TEST(!nh.empty());
+    BOOST_TEST(nh.key() == 10);
+    BOOST_TEST(nh.mapped() == 30);
+    BOOST_TEST(dst[10] == 20);
+
+    BOOST_TEST(src.count(10) == 0);
+    BOOST_TEST(src.count(20) == 1);
+    BOOST_TEST(dst.count(10) == 1);
+    BOOST_TEST(dst.count(20) == 1);
+  }
+}
+
+template <typename NodeHandle>
+bool node_handle_compare(
+  NodeHandle const& nh, BOOST_DEDUCED_TYPENAME NodeHandle::value_type const& x)
+{
+  return x == nh.value();
+}
+
+template <typename NodeHandle>
+bool node_handle_compare(NodeHandle const& nh,
+  std::pair<BOOST_DEDUCED_TYPENAME NodeHandle::key_type const,
+    BOOST_DEDUCED_TYPENAME NodeHandle::mapped_type> const& x)
+{
+  return x.first == nh.key() && x.second == nh.mapped();
+}
+
+template <typename Container> void node_handle_tests_impl(Container& c)
+{
+  typedef BOOST_DEDUCED_TYPENAME Container::node_type node_type;
+
+  BOOST_DEDUCED_TYPENAME Container::value_type value = *c.begin();
+
+  node_type n1;
+  BOOST_TEST(!n1);
+  BOOST_TEST(n1.empty());
+
+  node_type n2 = c.extract(c.begin());
+  BOOST_TEST(n2);
+  BOOST_TEST(!n2.empty());
+  node_handle_compare(n2, value);
+
+  node_type n3 = boost::move(n2);
+  BOOST_TEST(n3);
+  BOOST_TEST(!n2);
+  node_handle_compare(n3, value);
+  // TODO: Check that n2 doesn't have an allocator?
+  //       Maybe by swapping and observing that the allocator is
+  //       swapped rather than moved?
+
+  n1 = boost::move(n3);
+  BOOST_TEST(n1);
+  BOOST_TEST(!n3);
+  node_handle_compare(n1, value);
+
+  // Self move-assignment empties the node_handle.
+  n1 = boost::move(n1);
+  BOOST_TEST(!n1);
+
+  n3 = boost::move(n3);
+  BOOST_TEST(!n3);
+
+  BOOST_DEDUCED_TYPENAME Container::value_type value1 = *c.begin();
+  n1 = c.extract(c.begin());
+  BOOST_DEDUCED_TYPENAME Container::value_type value2 = *c.begin();
+  n2 = c.extract(c.begin());
+  n3 = node_type();
+
+  node_handle_compare(n1, value1);
+  node_handle_compare(n2, value2);
+  n1.swap(n2);
+  BOOST_TEST(n1);
+  BOOST_TEST(n2);
+  node_handle_compare(n1, value2);
+  node_handle_compare(n2, value1);
+
+  BOOST_TEST(n1);
+  BOOST_TEST(!n3);
+  n1.swap(n3);
+  BOOST_TEST(!n1);
+  BOOST_TEST(n3);
+  node_handle_compare(n3, value2);
+
+  BOOST_TEST(!n1);
+  BOOST_TEST(n2);
+  n1.swap(n2);
+  BOOST_TEST(n1);
+  BOOST_TEST(!n2);
+  node_handle_compare(n1, value1);
+
+  node_type n4;
+  BOOST_TEST(!n2);
+  BOOST_TEST(!n4);
+  n2.swap(n4);
+  BOOST_TEST(!n2);
+  BOOST_TEST(!n4);
+}
+
+UNORDERED_AUTO_TEST (node_handle_tests) {
+  boost::unordered_set<int> x1;
+  x1.emplace(100);
+  x1.emplace(140);
+  x1.emplace(-55);
+  node_handle_tests_impl(x1);
+
+  boost::unordered_map<int, std::string> x2;
+  x2.emplace(10, "ten");
+  x2.emplace(-23, "twenty");
+  x2.emplace(-76, "thirty");
+  node_handle_tests_impl(x2);
+}
+
+template <typename Container1, typename Container2>
+void insert_node_handle_unique(Container1& c1, Container2& c2)
+{
+  typedef BOOST_DEDUCED_TYPENAME Container1::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_type;
+  BOOST_STATIC_ASSERT(boost::is_same<node_type,
+    BOOST_DEDUCED_TYPENAME Container2::node_type>::value);
+
+  typedef BOOST_DEDUCED_TYPENAME Container1::insert_return_type
+    insert_return_type1;
+  typedef BOOST_DEDUCED_TYPENAME Container2::insert_return_type
+    insert_return_type2;
+
+  insert_return_type1 r1 = c1.insert(node_type());
+  insert_return_type2 r2 = c2.insert(node_type());
+  BOOST_TEST(!r1.inserted);
+  BOOST_TEST(!r1.node);
+  BOOST_TEST(r1.position == c1.end());
+  BOOST_TEST(!r2.inserted);
+  BOOST_TEST(!r2.node);
+  BOOST_TEST(r2.position == c2.end());
+
+  while (!c1.empty()) {
+    value_type v = *c1.begin();
+    value_type const* v_ptr = boost::addressof(*c1.begin());
+    std::size_t count = c2.count(test::get_key<Container1>(v));
+    insert_return_type2 r = c2.insert(c1.extract(c1.begin()));
+    if (!count) {
+      BOOST_TEST(r.inserted);
+      BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count + 1);
+      BOOST_TEST(r.position != c2.end());
+      BOOST_TEST(boost::addressof(*r.position) == v_ptr);
+      BOOST_TEST(!r.node);
+    } else {
+      BOOST_TEST(!r.inserted);
+      BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count);
+      BOOST_TEST(r.position != c2.end());
+      BOOST_TEST(
+        test::get_key<Container2>(*r.position) == test::get_key<Container2>(v));
+      BOOST_TEST(r.node);
+      node_handle_compare(r.node, v);
+    }
+  }
+}
+
+template <typename Container1, typename Container2>
+void insert_node_handle_unique2(Container1& c1, Container2& c2)
+{
+  typedef BOOST_DEDUCED_TYPENAME Container1::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_type;
+  BOOST_STATIC_ASSERT(boost::is_same<node_type,
+    BOOST_DEDUCED_TYPENAME Container2::node_type>::value);
+
+  // typedef BOOST_DEDUCED_TYPENAME Container1::insert_return_type
+  // insert_return_type1;
+  typedef BOOST_DEDUCED_TYPENAME Container2::insert_return_type
+    insert_return_type2;
+
+  while (!c1.empty()) {
+    value_type v = *c1.begin();
+    value_type const* v_ptr = boost::addressof(*c1.begin());
+    std::size_t count = c2.count(test::get_key<Container1>(v));
+    insert_return_type2 r = c2.insert(c1.extract(test::get_key<Container1>(v)));
+    if (r.inserted) {
+      BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count + 1);
+      BOOST_TEST(r.position != c2.end());
+      BOOST_TEST(boost::addressof(*r.position) == v_ptr);
+      BOOST_TEST(!r.node);
+    } else {
+      BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count);
+      BOOST_TEST(r.position != c2.end());
+      BOOST_TEST(
+        test::get_key<Container2>(*r.position) == test::get_key<Container2>(v));
+      BOOST_TEST(r.node);
+      node_handle_compare(r.node, v);
+    }
+  }
+}
+
+template <typename Container1, typename Container2>
+void insert_node_handle_equiv(Container1& c1, Container2& c2)
+{
+  typedef BOOST_DEDUCED_TYPENAME Container1::node_type node_type;
+  typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_type;
+  BOOST_STATIC_ASSERT(boost::is_same<node_type,
+    BOOST_DEDUCED_TYPENAME Container2::node_type>::value);
+
+  typedef BOOST_DEDUCED_TYPENAME Container1::iterator iterator1;
+  typedef BOOST_DEDUCED_TYPENAME Container2::iterator iterator2;
+
+  iterator1 r1 = c1.insert(node_type());
+  iterator2 r2 = c2.insert(node_type());
+  BOOST_TEST(r1 == c1.end());
+  BOOST_TEST(r2 == c2.end());
+
+  while (!c1.empty()) {
+    value_type v = *c1.begin();
+    value_type const* v_ptr = boost::addressof(*c1.begin());
+    std::size_t count = c2.count(test::get_key<Container1>(v));
+    iterator2 r = c2.insert(c1.extract(c1.begin()));
+    BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count + 1);
+    BOOST_TEST(r != c2.end());
+    BOOST_TEST(boost::addressof(*r) == v_ptr);
+  }
+}
+
+struct hash_thing
+{
+  std::size_t operator()(int x) const
+  {
+    return static_cast<std::size_t>(x * 13 + 5);
+  }
+};
+
+UNORDERED_AUTO_TEST (insert_node_handle_unique_tests) {
+  {
+    boost::unordered_set<int> x1;
+    boost::unordered_set<int> x2;
+    x1.emplace(100);
+    x1.emplace(140);
+    x1.emplace(-55);
+    x2.emplace(140);
+    insert_node_handle_unique(x1, x2);
+    BOOST_TEST(x2.size() == 3);
+  }
+
+  {
+    boost::unordered_map<int, int, hash_thing> x1;
+    boost::unordered_map<int, int> x2;
+    x1.emplace(67, 50);
+    x1.emplace(23, 45);
+    x1.emplace(18, 19);
+    x2.emplace(23, 50);
+    x2.emplace(12, 49);
+    insert_node_handle_unique(x1, x2);
+    BOOST_TEST(x2.size() == 4);
+  }
+}
+
+UNORDERED_AUTO_TEST (insert_node_handle_equiv_tests) {
+  {
+    boost::unordered_multimap<int, int, hash_thing> x1;
+    boost::unordered_multimap<int, int> x2;
+    x1.emplace(67, 50);
+    x1.emplace(67, 100);
+    x1.emplace(23, 45);
+    x1.emplace(18, 19);
+    x2.emplace(23, 50);
+    x2.emplace(12, 49);
+    insert_node_handle_equiv(x1, x2);
+    BOOST_TEST(x2.size() == 6);
+  }
+}
+
+UNORDERED_AUTO_TEST (insert_node_handle_unique_tests2) {
+  {
+    boost::unordered_set<int> x1;
+    boost::unordered_set<int> x2;
+    x1.emplace(100);
+    x1.emplace(140);
+    x1.emplace(-55);
+    x2.emplace(140);
+    insert_node_handle_unique2(x1, x2);
+    BOOST_TEST(x2.size() == 3);
+  }
+
+  {
+    boost::unordered_map<int, int, hash_thing> x1;
+    boost::unordered_map<int, int> x2;
+    x1.emplace(67, 50);
+    x1.emplace(23, 45);
+    x1.emplace(18, 19);
+    x2.emplace(23, 50);
+    x2.emplace(12, 49);
+    insert_node_handle_unique2(x1, x2);
+    BOOST_TEST(x2.size() == 4);
+  }
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/noexcept_tests.cpp

@@ -0,0 +1,168 @@
+
+// Copyright 2013 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+
+namespace noexcept_tests {
+  // Test the noexcept is set correctly for the move constructor.
+
+  struct hash_possible_exception : boost::hash<int>
+  {
+    hash_possible_exception(hash_possible_exception const&) {}
+  };
+
+  struct equal_to_possible_exception : std::equal_to<int>
+  {
+    equal_to_possible_exception(equal_to_possible_exception const&) {}
+  };
+
+  // Test that the move constructor does actually move without throwing
+  // an exception when it claims to.
+
+  struct test_exception
+  {
+  };
+
+  bool throwing_test_exception = false;
+  void test_throw(char const* name)
+  {
+    if (throwing_test_exception) {
+      BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Throw exception in: " << name
+                                     << std::endl;
+      throw test_exception();
+    }
+  }
+
+  class hash_nothrow_move : boost::hash<int>
+  {
+    BOOST_COPYABLE_AND_MOVABLE(hash_nothrow_move)
+
+    typedef boost::hash<int> base;
+
+  public:
+    hash_nothrow_move(BOOST_RV_REF(hash_nothrow_move)) BOOST_NOEXCEPT {}
+
+    hash_nothrow_move() { test_throw("Constructor"); }
+    hash_nothrow_move(hash_nothrow_move const&) { test_throw("Copy"); }
+    hash_nothrow_move& operator=(BOOST_COPY_ASSIGN_REF(hash_nothrow_move))
+    {
+      test_throw("Assign");
+      return *this;
+    }
+    hash_nothrow_move& operator=(BOOST_RV_REF(hash_nothrow_move))
+    {
+      test_throw("Move Assign");
+      return *this;
+    }
+    std::size_t operator()(int x) const
+    {
+      test_throw("Operator");
+      return static_cast<base const&>(*this)(x);
+    }
+  };
+
+  class equal_to_nothrow_move : std::equal_to<int>
+  {
+    BOOST_COPYABLE_AND_MOVABLE(equal_to_nothrow_move)
+
+    typedef std::equal_to<int> base;
+
+  public:
+    equal_to_nothrow_move(BOOST_RV_REF(equal_to_nothrow_move)) BOOST_NOEXCEPT {}
+    equal_to_nothrow_move() { test_throw("Constructor"); }
+    equal_to_nothrow_move(equal_to_nothrow_move const&) { test_throw("Copy"); }
+    equal_to_nothrow_move& operator=(
+      BOOST_COPY_ASSIGN_REF(equal_to_nothrow_move))
+    {
+      test_throw("Assign");
+      return *this;
+    }
+    equal_to_nothrow_move& operator=(BOOST_RV_REF(equal_to_nothrow_move))
+    {
+      test_throw("Move Assign");
+      return *this;
+    }
+    std::size_t operator()(int x, int y) const
+    {
+      test_throw("Operator");
+      return static_cast<base const&>(*this)(x, y);
+    }
+  };
+
+  bool have_is_nothrow_move = false;
+
+  UNORDERED_AUTO_TEST (check_is_nothrow_move) {
+    BOOST_TEST(
+      !boost::is_nothrow_move_constructible<hash_possible_exception>::value);
+    have_is_nothrow_move =
+      boost::is_nothrow_move_constructible<hash_nothrow_move>::value;
+
+// Copied from boost::is_nothrow_move_constructible implementation
+// to make sure this does actually detect it when expected.
+//
+// The type trait is also available when BOOST_IS_NOTHROW_MOVE_CONSTRUCT
+// is defined (for some versions of Visual C++?) but detects 'throw()',
+// not noexcept.
+#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) &&     \
+  !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40800)
+    BOOST_TEST(have_is_nothrow_move);
+#endif
+  }
+
+  UNORDERED_AUTO_TEST (test_noexcept) {
+    if (have_is_nothrow_move) {
+      BOOST_TEST((boost::is_nothrow_move_constructible<
+        boost::unordered_set<int> >::value));
+      BOOST_TEST((boost::is_nothrow_move_constructible<
+        boost::unordered_multiset<int> >::value));
+      BOOST_TEST((boost::is_nothrow_move_constructible<
+        boost::unordered_map<int, int> >::value));
+      BOOST_TEST((boost::is_nothrow_move_constructible<
+        boost::unordered_multimap<int, int> >::value));
+    }
+
+    BOOST_TEST((!boost::is_nothrow_move_constructible<
+                boost::unordered_set<int, hash_possible_exception> >::value));
+    BOOST_TEST(
+      (!boost::is_nothrow_move_constructible<boost::unordered_multiset<int,
+          boost::hash<int>, equal_to_possible_exception> >::value));
+  }
+
+  UNORDERED_AUTO_TEST (test_no_throw_when_noexcept) {
+    typedef boost::unordered_set<int, hash_nothrow_move, equal_to_nothrow_move>
+      throwing_set;
+
+    if (have_is_nothrow_move) {
+      BOOST_TEST(boost::is_nothrow_move_constructible<throwing_set>::value);
+
+      throwing_test_exception = false;
+
+      throwing_set x1;
+      x1.insert(10);
+      x1.insert(50);
+
+      try {
+        throwing_test_exception = true;
+
+        throwing_set x2 = boost::move(x1);
+        BOOST_TEST(x2.size() == 2);
+        BOOST_TEST(*x2.begin() == 10 || *x2.begin() == 50);
+      } catch (test_exception) {
+        BOOST_TEST(false);
+      }
+
+      throwing_test_exception = false;
+    }
+  }
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/rehash_tests.cpp

@@ -0,0 +1,230 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+#include "../helpers/metafunctions.hpp"
+#include "../objects/test.hpp"
+
+namespace rehash_tests {
+
+  test::seed_t initialize_seed(2974);
+
+  template <class X>
+  bool postcondition(X const& x, BOOST_DEDUCED_TYPENAME X::size_type n)
+  {
+    return static_cast<double>(x.bucket_count()) >=
+             static_cast<double>(x.size()) / x.max_load_factor() &&
+           x.bucket_count() >= n;
+  }
+
+  template <class X> void rehash_empty_test1(X*)
+  {
+    X x;
+
+    x.rehash(10000);
+    BOOST_TEST(postcondition(x, 10000));
+
+    x.rehash(0);
+    BOOST_TEST(postcondition(x, 0));
+
+    x.rehash(10000000);
+    BOOST_TEST(postcondition(x, 10000000));
+  }
+
+  template <class X>
+  void rehash_empty_test2(X*, test::random_generator generator)
+  {
+    test::random_values<X> v(1000, generator);
+    test::ordered<X> tracker;
+
+    X x;
+
+    x.rehash(10000);
+    BOOST_TEST(postcondition(x, 10000));
+
+    tracker.insert_range(v.begin(), v.end());
+    x.insert(v.begin(), v.end());
+    tracker.compare(x);
+
+    BOOST_TEST(postcondition(x, 10000));
+
+    x.rehash(10000000);
+    tracker.compare(x);
+    BOOST_TEST(postcondition(x, 10000000));
+  }
+
+  template <class X>
+  void rehash_empty_test3(X*, test::random_generator generator)
+  {
+    test::random_values<X> v(1000, generator);
+    test::ordered<X> tracker;
+
+    X x;
+
+    x.rehash(0);
+    BOOST_TEST(postcondition(x, 0));
+
+    tracker.insert_range(v.begin(), v.end());
+    x.insert(v.begin(), v.end());
+    tracker.compare(x);
+
+    BOOST_TEST(postcondition(x, 0));
+  }
+
+  template <class X> void rehash_test1(X*, test::random_generator generator)
+  {
+    test::random_values<X> v(1000, generator);
+    test::ordered<X> tracker;
+    tracker.insert_range(v.begin(), v.end());
+    X x(v.begin(), v.end());
+
+    x.rehash(0);
+    BOOST_TEST(postcondition(x, 0));
+    tracker.compare(x);
+
+    x.max_load_factor(0.25);
+    x.rehash(0);
+    BOOST_TEST(postcondition(x, 0));
+    tracker.compare(x);
+
+    x.max_load_factor(50.0);
+    x.rehash(0);
+    BOOST_TEST(postcondition(x, 0));
+    tracker.compare(x);
+
+    x.rehash(1000);
+    BOOST_TEST(postcondition(x, 1000));
+    tracker.compare(x);
+  }
+
+  template <class X> void reserve_empty_test1(X*)
+  {
+    X x;
+
+    x.reserve(10000);
+    BOOST_TEST(x.bucket_count() >= 10000);
+
+    x.reserve(0);
+
+    x.reserve(10000000);
+    BOOST_TEST(x.bucket_count() >= 10000000);
+  }
+
+  template <class X> void reserve_empty_test2(X*)
+  {
+    X x;
+    x.max_load_factor(0.25);
+
+    x.reserve(10000);
+    BOOST_TEST(x.bucket_count() >= 40000);
+
+    x.reserve(0);
+
+    x.reserve(10000000);
+    BOOST_TEST(x.bucket_count() >= 40000000);
+  }
+
+  template <class X> void reserve_test1(X*, test::random_generator generator)
+  {
+    for (int random_mlf = 0; random_mlf < 2; ++random_mlf) {
+      for (std::size_t i = 1; i < 2000; i += i < 50 ? 1 : 13) {
+        test::random_values<X> v(i, generator);
+
+        test::ordered<X> tracker;
+        tracker.insert_range(v.begin(), v.end());
+
+        X x;
+        x.max_load_factor(
+          random_mlf ? static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f
+                     : 1.0f);
+        x.reserve(test::has_unique_keys<X>::value ? i : v.size());
+
+        // Insert an element before the range insert, otherwise there are
+        // no iterators to invalidate in the range insert, and it can
+        // rehash.
+        typename test::random_values<X>::iterator it = v.begin();
+        x.insert(*it);
+        ++it;
+
+        std::size_t bucket_count = x.bucket_count();
+        x.insert(it, v.end());
+        BOOST_TEST(bucket_count == x.bucket_count());
+        tracker.compare(x);
+      }
+    }
+  }
+
+  template <class X> void reserve_test2(X*, test::random_generator generator)
+  {
+    for (int random_mlf = 0; random_mlf < 2; ++random_mlf) {
+      for (std::size_t i = 0; i < 2000; i += i < 50 ? 1 : 13) {
+        test::random_values<X> v(i, generator);
+
+        test::ordered<X> tracker;
+        tracker.insert_range(v.begin(), v.end());
+
+        X x;
+        x.max_load_factor(
+          random_mlf ? static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f
+                     : 1.0f);
+
+        x.reserve(test::has_unique_keys<X>::value ? i : v.size());
+
+        std::size_t bucket_count = x.bucket_count();
+        for (typename test::random_values<X>::iterator it = v.begin();
+             it != v.end(); ++it) {
+          x.insert(*it);
+        }
+
+        BOOST_TEST(bucket_count == x.bucket_count());
+        tracker.compare(x);
+      }
+    }
+  }
+
+  boost::unordered_set<int>* int_set_ptr;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multiset_ptr;
+  boost::unordered_map<test::movable, test::movable, test::hash, test::equal_to,
+    test::allocator2<test::movable> >* test_map_ptr;
+  boost::unordered_multimap<int, int>* int_multimap_ptr;
+
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+  UNORDERED_TEST(rehash_empty_test1,
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
+  UNORDERED_TEST(rehash_empty_test2,
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
+      (default_generator)(generate_collisions)(limited_range)))
+  UNORDERED_TEST(rehash_empty_test3,
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
+      (default_generator)(generate_collisions)(limited_range)))
+  UNORDERED_TEST(rehash_test1,
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
+      (default_generator)(generate_collisions)(limited_range)))
+  UNORDERED_TEST(reserve_empty_test1,
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
+  UNORDERED_TEST(reserve_empty_test2,
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
+  UNORDERED_TEST(reserve_test1,
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
+      (default_generator)(generate_collisions)(limited_range)))
+  UNORDERED_TEST(reserve_test2,
+    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
+      (default_generator)(generate_collisions)(limited_range)))
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/simple_tests.cpp

@@ -0,0 +1,134 @@
+
+// Copyright 2006-2009 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)
+
+// This test checks the runtime requirements of containers.
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+#include <cstdlib>
+#include <algorithm>
+#include "../helpers/equivalent.hpp"
+
+template <class X> void simple_test(X const& a)
+{
+  test::unordered_equivalence_tester<X> equivalent(a);
+
+  {
+    X u;
+    BOOST_TEST(u.size() == 0);
+    BOOST_TEST(X().size() == 0);
+  }
+
+  {
+    BOOST_TEST(equivalent(X(a)));
+  }
+
+  {
+    X u(a);
+    BOOST_TEST(equivalent(u));
+  }
+
+  {
+    X u = a;
+    BOOST_TEST(equivalent(u));
+  }
+
+  {
+    X b(a);
+    BOOST_TEST(b.begin() == const_cast<X const&>(b).cbegin());
+    BOOST_TEST(b.end() == const_cast<X const&>(b).cend());
+  }
+
+  {
+    X b(a);
+    X c;
+    BOOST_TEST(equivalent(b));
+    BOOST_TEST(c.empty());
+    b.swap(c);
+    BOOST_TEST(b.empty());
+    BOOST_TEST(equivalent(c));
+    b.swap(c);
+    BOOST_TEST(c.empty());
+    BOOST_TEST(equivalent(b));
+  }
+
+  {
+    X u;
+    X& r = u;
+    BOOST_TEST(&(r = r) == &r);
+
+    BOOST_TEST(r.empty());
+    BOOST_TEST(&(r = a) == &r);
+    BOOST_TEST(equivalent(r));
+    BOOST_TEST(&(r = r) == &r);
+    BOOST_TEST(equivalent(r));
+  }
+
+  {
+    BOOST_TEST(a.size() == static_cast<BOOST_DEDUCED_TYPENAME X::size_type>(
+                             std::distance(a.begin(), a.end())));
+  }
+
+  {
+    BOOST_TEST(a.empty() == (a.size() == 0));
+  }
+
+  {
+    BOOST_TEST(a.empty() == (a.begin() == a.end()));
+    X u;
+    BOOST_TEST(u.begin() == u.end());
+  }
+}
+
+UNORDERED_AUTO_TEST (simple_tests) {
+  using namespace std;
+  srand(14878);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+  boost::unordered_set<int> set;
+  simple_test(set);
+
+  set.insert(1);
+  set.insert(2);
+  set.insert(1456);
+  simple_test(set);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+  boost::unordered_multiset<int> multiset;
+  simple_test(multiset);
+
+  for (int i1 = 0; i1 < 1000; ++i1) {
+    int count = rand() % 10, index = rand();
+    for (int j = 0; j < count; ++j)
+      multiset.insert(index);
+  }
+  simple_test(multiset);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
+  boost::unordered_map<int, int> map;
+
+  for (int i2 = 0; i2 < 1000; ++i2) {
+    map.insert(std::pair<const int, int>(rand(), rand()));
+  }
+  simple_test(map);
+
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+  boost::unordered_multimap<int, int> multimap;
+
+  for (int i3 = 0; i3 < 1000; ++i3) {
+    int count = rand() % 10, index = rand();
+    for (int j = 0; j < count; ++j)
+      multimap.insert(std::pair<const int, int>(index, rand()));
+  }
+  simple_test(multimap);
+}
+
+RUN_TESTS()

libs/unordered/test/unordered/swap_tests.cpp

@@ -0,0 +1,211 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include <boost/config.hpp>
+#include <algorithm>
+#include <iterator>
+#include "../helpers/test.hpp"
+#include "../objects/test.hpp"
+#include "../objects/cxx11_allocator.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+#include "../helpers/invariants.hpp"
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable : 4127) // conditional expression is constant
+#endif
+
+namespace swap_tests {
+
+  test::seed_t initialize_seed(783472);
+
+  template <class X> void swap_test_impl(X& x1, X& x2)
+  {
+    test::ordered<X> tracker1 = test::create_ordered(x1);
+    test::ordered<X> tracker2 = test::create_ordered(x2);
+    tracker1.insert_range(x1.begin(), x1.end());
+    tracker2.insert_range(x2.begin(), x2.end());
+    x1.swap(x2);
+    tracker1.compare(x2);
+    tracker2.compare(x1);
+  }
+
+  template <class X> void swap_tests1(X*, test::random_generator generator)
+  {
+    {
+      test::check_instances check_;
+
+      X x;
+      swap_test_impl(x, x);
+    }
+
+    {
+      test::check_instances check_;
+
+      X x, y;
+      swap_test_impl(x, y);
+    }
+
+    {
+      test::check_instances check_;
+
+      test::random_values<X> v(1000, generator);
+      X x, y(v.begin(), v.end());
+      swap_test_impl(x, y);
+      swap_test_impl(x, y);
+    }
+
+    {
+      test::check_instances check_;
+
+      test::random_values<X> vx(1000, generator), vy(1000, generator);
+      X x(vx.begin(), vx.end()), y(vy.begin(), vy.end());
+      swap_test_impl(x, y);
+      swap_test_impl(x, y);
+    }
+  }
+
+  template <class X> void swap_tests2(X* ptr, test::random_generator generator)
+  {
+    swap_tests1(ptr, generator);
+
+    typedef BOOST_DEDUCED_TYPENAME X::hasher hasher;
+    typedef BOOST_DEDUCED_TYPENAME X::key_equal key_equal;
+    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
+
+    {
+      test::check_instances check_;
+
+      X x(0, hasher(1), key_equal(1));
+      X y(0, hasher(2), key_equal(2));
+      swap_test_impl(x, y);
+    }
+
+    {
+      test::check_instances check_;
+
+      test::random_values<X> v(1000, generator);
+      X x(v.begin(), v.end(), 0, hasher(1), key_equal(1));
+      X y(0, hasher(2), key_equal(2));
+      swap_test_impl(x, y);
+    }
+
+    {
+      test::check_instances check_;
+
+      test::random_values<X> vx(100, generator), vy(50, generator);
+      X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1));
+      X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2));
+      swap_test_impl(x, y);
+      swap_test_impl(x, y);
+    }
+
+    {
+      test::force_equal_allocator force_(!allocator_type::is_propagate_on_swap);
+      test::check_instances check_;
+
+      test::random_values<X> vx(50, generator), vy(100, generator);
+      X x(vx.begin(), vx.end(), 0, hasher(), key_equal(), allocator_type(1));
+      X y(vy.begin(), vy.end(), 0, hasher(), key_equal(), allocator_type(2));
+
+      if (allocator_type::is_propagate_on_swap ||
+          x.get_allocator() == y.get_allocator()) {
+        swap_test_impl(x, y);
+      }
+    }
+
+    {
+      test::force_equal_allocator force_(!allocator_type::is_propagate_on_swap);
+      test::check_instances check_;
+
+      test::random_values<X> vx(100, generator), vy(100, generator);
+      X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1), allocator_type(1));
+      X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2), allocator_type(2));
+
+      if (allocator_type::is_propagate_on_swap ||
+          x.get_allocator() == y.get_allocator()) {
+        swap_test_impl(x, y);
+        swap_test_impl(x, y);
+      }
+    }
+  }
+
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    std::allocator<test::object> >* test_map_std_alloc;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_set;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_multiset;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_map;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator2<test::object> >* test_multimap;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_swap> >*
+    test_set_prop_swap;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_swap> >*
+    test_multiset_prop_swap;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_swap> >*
+    test_map_prop_swap;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::cxx11_allocator<test::object, test::propagate_swap> >*
+    test_multimap_prop_swap;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+    test_set_no_prop_swap;
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+    test_multiset_no_prop_swap;
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+    test_map_no_prop_swap;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+    test_multimap_no_prop_swap;
+
+  template <typename T> bool is_propagate(T*)
+  {
+    return T::allocator_type::is_propagate_on_swap;
+  }
+
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+  UNORDERED_AUTO_TEST (check_traits) {
+    BOOST_TEST(!is_propagate(test_set));
+    BOOST_TEST(is_propagate(test_set_prop_swap));
+    BOOST_TEST(!is_propagate(test_set_no_prop_swap));
+  }
+
+  UNORDERED_TEST(
+    swap_tests1, ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(
+                   test_multimap)(test_set_prop_swap)(test_multiset_prop_swap)(
+                   test_map_prop_swap)(test_multimap_prop_swap)(
+                   test_set_no_prop_swap)(test_multiset_no_prop_swap)(
+                   test_map_no_prop_swap)(test_multimap_no_prop_swap))(
+                   (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(swap_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_prop_swap)(
+      test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap)(
+      test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(
+      test_multimap_no_prop_swap))(
+      (default_generator)(generate_collisions)(limited_range)))
+}
+RUN_TESTS()

libs/unordered/test/unordered/unnecessary_copy_tests.cpp

@@ -0,0 +1,582 @@
+
+// Copyright 2006-2009 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)
+
+// clang-format off
+#include "../helpers/prefix.hpp"
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../helpers/test.hpp"
+
+namespace unnecessary_copy_tests {
+  struct count_copies
+  {
+  private:
+    BOOST_COPYABLE_AND_MOVABLE(count_copies)
+  public:
+    static int copies;
+    static int moves;
+    static int id_count;
+
+    count_copies() : tag_(0), id_(++id_count)
+    {
+      ++copies;
+      trace_op("Default construct");
+    }
+
+    explicit count_copies(int tag) : tag_(tag), id_(++id_count)
+    {
+      ++copies;
+      trace_op("Tag construct");
+    }
+
+    // This bizarre constructor is an attempt to confuse emplace.
+    //
+    // unordered_map<count_copies, count_copies> x:
+    // x.emplace(count_copies(1), count_copies(2));
+    // x.emplace(count_copies(1), count_copies(2), count_copies(3));
+    //
+    // The first emplace should use the single argument constructor twice.
+    // The second emplace should use the single argument contructor for
+    // the key, and this constructor for the value.
+    count_copies(count_copies const&, count_copies const& x)
+        : tag_(x.tag_), id_(++id_count)
+    {
+      ++copies;
+      trace_op("Pair construct");
+    }
+
+    count_copies(count_copies const& x) : tag_(x.tag_), id_(++id_count)
+    {
+      ++copies;
+      trace_op("Copy construct");
+    }
+
+    count_copies(BOOST_RV_REF(count_copies) x) : tag_(x.tag_), id_(++id_count)
+    {
+      x.tag_ = -1;
+      ++moves;
+      trace_op("Move construct");
+    }
+
+    count_copies& operator=(
+      BOOST_COPY_ASSIGN_REF(count_copies) p) // Copy assignment
+    {
+      tag_ = p.tag_;
+      ++copies;
+      trace_op("Copy assign");
+      return *this;
+    }
+
+    count_copies& operator=(BOOST_RV_REF(count_copies) p) // Move assignment
+    {
+      tag_ = p.tag_;
+      ++moves;
+      trace_op("Move assign");
+      return *this;
+    }
+
+    ~count_copies() { trace_op("Destruct"); }
+
+    void trace_op(char const* str)
+    {
+      BOOST_LIGHTWEIGHT_TEST_OSTREAM << str << ": " << tag_ << " (#" << id_
+                                     << ")" << std::endl;
+    }
+
+    int tag_;
+    int id_;
+  };
+
+  bool operator==(count_copies const& x, count_copies const& y)
+  {
+    return x.tag_ == y.tag_;
+  }
+
+  template <class T> T source() { return T(); }
+
+  void reset()
+  {
+    count_copies::copies = 0;
+    count_copies::moves = 0;
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\nReset\n" << std::endl;
+  }
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace boost
+#else
+namespace unnecessary_copy_tests
+#endif
+{
+  std::size_t hash_value(unnecessary_copy_tests::count_copies const& x)
+  {
+    return static_cast<std::size_t>(x.tag_);
+  }
+}
+
+// Boost.Move doesn't seem to work very well on this compiler.
+// For example for:
+//
+//     T x;
+//
+// It will default construct T, and then move it in.
+// For 'T const' it seems to copy.
+
+#if defined(__IBMCPP__) && __IBMCPP__ <= 1210
+#define EXTRA_CONSTRUCT_COST 1
+#else
+#define EXTRA_CONSTRUCT_COST 0
+#endif
+
+#define COPY_COUNT(n)                                                          \
+  if (::unnecessary_copy_tests::count_copies::copies != n) {                   \
+    BOOST_ERROR("Wrong number of copies.");                                    \
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
+      << "Number of copies: "                                                  \
+      << ::unnecessary_copy_tests::count_copies::copies << " expecting: " << n \
+      << std::endl;                                                            \
+  }
+#define MOVE_COUNT(n)                                                          \
+  if (::unnecessary_copy_tests::count_copies::moves != n) {                    \
+    BOOST_ERROR("Wrong number of moves.");                                     \
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
+      << "Number of moves: " << ::unnecessary_copy_tests::count_copies::moves  \
+      << " expecting: " << n << std::endl;                                     \
+  }
+#define COPY_COUNT_RANGE(a, b)                                                 \
+  if (::unnecessary_copy_tests::count_copies::copies < a ||                    \
+      ::unnecessary_copy_tests::count_copies::copies > b) {                    \
+    BOOST_ERROR("Wrong number of copies.");                                    \
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
+      << "Number of copies: "                                                  \
+      << ::unnecessary_copy_tests::count_copies::copies << " expecting: ["     \
+      << a << ", " << b << "]" << std::endl;                                   \
+  }
+#define MOVE_COUNT_RANGE(a, b)                                                 \
+  if (::unnecessary_copy_tests::count_copies::moves < a ||                     \
+      ::unnecessary_copy_tests::count_copies::moves > b) {                     \
+    BOOST_ERROR("Wrong number of moves.");                                     \
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
+      << "Number of moves: " << ::unnecessary_copy_tests::count_copies::moves  \
+      << " expecting: [" << a << ", " << b << "]" << std::endl;                \
+  }
+#define COPY_COUNT_EXTRA(a, b) COPY_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)
+#define MOVE_COUNT_EXTRA(a, b) MOVE_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)
+
+namespace unnecessary_copy_tests {
+  int count_copies::copies;
+  int count_copies::moves;
+  int count_copies::id_count;
+
+  template <class T> void unnecessary_copy_insert_test(T*)
+  {
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    reset();
+    x.insert(a);
+    COPY_COUNT(1);
+    MOVE_COUNT(0);
+  }
+
+  template <class T> void unnecessary_copy_insert_rvalue_set_test(T*)
+  {
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    reset();
+    x.insert(boost::move(a));
+    COPY_COUNT(0);
+    MOVE_COUNT(1);
+
+    BOOST_DEDUCED_TYPENAME T::value_type a2;
+    reset();
+    x.insert(boost::move(a));
+    COPY_COUNT(0);
+    MOVE_COUNT((x.size() == 2 ? 1 : 0));
+  }
+
+  template <class T> void unnecessary_copy_insert_rvalue_map_test(T*)
+  {
+    // Doesn't currently try to emulate std::pair move construction,
+    // so std::pair's require a copy. Could try emulating it in
+    // construct_from_args.
+
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    reset();
+    x.insert(boost::move(a));
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    COPY_COUNT(1);
+    MOVE_COUNT(0);
+#else
+    COPY_COUNT(0);
+    MOVE_COUNT(1);
+#endif
+
+    BOOST_DEDUCED_TYPENAME T::value_type a2;
+    reset();
+    x.insert(boost::move(a));
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    COPY_COUNT((x.size() == 2 ? 1 : 0));
+    MOVE_COUNT(0);
+#else
+    COPY_COUNT(0);
+    MOVE_COUNT((x.size() == 2 ? 1 : 0));
+#endif
+  }
+
+  boost::unordered_set<count_copies>* set;
+  boost::unordered_multiset<count_copies>* multiset;
+  boost::unordered_map<int, count_copies>* map;
+  boost::unordered_multimap<int, count_copies>* multimap;
+
+  UNORDERED_TEST(unnecessary_copy_insert_test, ((set)(multiset)(map)(multimap)))
+  UNORDERED_TEST(unnecessary_copy_insert_rvalue_set_test, ((set)(multiset)))
+  UNORDERED_TEST(unnecessary_copy_insert_rvalue_map_test, ((map)(multimap)))
+
+  template <class T> void unnecessary_copy_emplace_test(T*)
+  {
+    reset();
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    COPY_COUNT(1);
+    x.emplace(a);
+    COPY_COUNT(2);
+  }
+
+  template <class T> void unnecessary_copy_emplace_rvalue_test(T*)
+  {
+    reset();
+    T x;
+    x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    COPY_COUNT(1);
+#else
+    COPY_COUNT(2);
+#endif
+  }
+
+  UNORDERED_TEST(
+    unnecessary_copy_emplace_test, ((set)(multiset)(map)(multimap)))
+  UNORDERED_TEST(
+    unnecessary_copy_emplace_rvalue_test, ((set)(multiset)(map)(multimap)))
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+  template <class T> void unnecessary_copy_emplace_std_move_test(T*)
+  {
+    reset();
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    COPY_COUNT(1);
+    MOVE_COUNT(0);
+    x.emplace(std::move(a));
+    COPY_COUNT(1);
+    MOVE_COUNT(1);
+  }
+
+  UNORDERED_TEST(
+    unnecessary_copy_emplace_std_move_test, ((set)(multiset)(map)(multimap)))
+#endif
+
+  template <class T> void unnecessary_copy_emplace_boost_move_test(T*)
+  {
+    reset();
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    COPY_COUNT(1);
+    MOVE_COUNT_EXTRA(0, 1);
+    x.emplace(boost::move(a));
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    COPY_COUNT(1);
+    MOVE_COUNT(1);
+#else
+    // Since std::pair isn't movable, move only works for sets.
+    COPY_COUNT_RANGE(1, 2);
+    MOVE_COUNT_RANGE(0, 1);
+#endif
+  }
+
+  UNORDERED_TEST(
+    unnecessary_copy_emplace_boost_move_test, ((set)(multiset)(map)(multimap)))
+
+  template <class T> void unnecessary_copy_emplace_boost_move_set_test(T*)
+  {
+    reset();
+    T x;
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    COPY_COUNT(1);
+    MOVE_COUNT(0);
+    x.emplace(boost::move(a));
+    COPY_COUNT(1);
+    MOVE_COUNT(1);
+  }
+
+  UNORDERED_TEST(
+    unnecessary_copy_emplace_boost_move_set_test, ((set)(multiset)))
+
+  template <class T> void unnecessary_copy_emplace_boost_move_map_test(T*)
+  {
+    reset();
+    T x;
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
+    BOOST_DEDUCED_TYPENAME T::value_type a;
+    COPY_COUNT(1);
+    MOVE_COUNT_EXTRA(0, 1);
+    x.emplace(boost::move(a));
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    COPY_COUNT(2);
+    MOVE_COUNT_EXTRA(0, 1);
+#else
+    COPY_COUNT(1);
+    MOVE_COUNT(1);
+#endif
+  }
+
+  UNORDERED_TEST(
+    unnecessary_copy_emplace_boost_move_map_test, ((map)(multimap)))
+
+  UNORDERED_AUTO_TEST (unnecessary_copy_emplace_set_test) {
+    // When calling 'source' the object is moved on some compilers, but not
+    // others. So count that here to adjust later.
+
+    reset();
+    source<count_copies>();
+    int source_cost = ::unnecessary_copy_tests::count_copies::moves;
+
+    //
+
+    reset();
+    boost::unordered_set<count_copies> x;
+    count_copies a;
+    x.insert(a);
+    COPY_COUNT(2);
+    MOVE_COUNT(0);
+
+//
+// 0 arguments
+//
+
+#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
+    // The container will have to create a copy in order to compare with
+    // the existing element.
+    reset();
+    x.emplace();
+
+    // source_cost doesn't make much sense here, but it seems to fit.
+    COPY_COUNT(1);
+    MOVE_COUNT(source_cost);
+#endif
+
+    //
+    // 1 argument
+    //
+
+    // Emplace should be able to tell that there already is an element
+    // without creating a new one.
+    reset();
+    x.emplace(a);
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
+
+    // A new object is created by source, but it shouldn't be moved or
+    // copied.
+    reset();
+    x.emplace(source<count_copies>());
+    COPY_COUNT(1);
+    MOVE_COUNT(source_cost);
+
+    // No move should take place.
+    reset();
+    x.emplace(boost::move(a));
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
+
+    // Use a new value for cases where a did get moved...
+    count_copies b;
+
+    // The container will have to create a copy in order to compare with
+    // the existing element.
+    reset();
+    x.emplace(b.tag_);
+    COPY_COUNT(1);
+    MOVE_COUNT(0);
+
+    //
+    // 2 arguments
+    //
+
+    // The container will have to create b copy in order to compare with
+    // the existing element.
+    //
+    // Note to self: If copy_count == 0 it's an error not an optimization.
+    // TODO: Devise a better test.
+
+    reset();
+
+    x.emplace(b, b);
+    COPY_COUNT(1);
+    MOVE_COUNT(0);
+  }
+
+  UNORDERED_AUTO_TEST (unnecessary_copy_emplace_map_test) {
+    // When calling 'source' the object is moved on some compilers, but not
+    // others. So count that here to adjust later.
+
+    reset();
+    source<count_copies>();
+    int source_cost = ::unnecessary_copy_tests::count_copies::moves;
+
+    reset();
+    source<std::pair<count_copies, count_copies> >();
+    int source_pair_cost = ::unnecessary_copy_tests::count_copies::moves;
+
+    //
+
+    reset();
+    boost::unordered_map<count_copies, count_copies> x;
+    // TODO: Run tests for pairs without const etc.
+    std::pair<count_copies const, count_copies> a;
+    x.emplace(a);
+    COPY_COUNT_EXTRA(4, 1);
+    MOVE_COUNT_EXTRA(0, 1);
+
+//
+// 0 arguments
+//
+
+#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
+    // COPY_COUNT(1) would be okay here.
+    reset();
+    x.emplace();
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1700)
+    // This is a little odd, Visual C++ 11 seems to move the pair, which
+    // results in one copy (for the const key) and one move (for the
+    // non-const mapped value). Since 'emplace(boost::move(a))' (see below)
+    // has the normal result, it must be some odd consequence of how
+    // Visual C++ 11 handles calling move for default arguments.
+    COPY_COUNT(3);
+    MOVE_COUNT(1);
+#else
+    COPY_COUNT_EXTRA(2, 1);
+    MOVE_COUNT_EXTRA(0, 1);
+#endif
+#endif
+
+    reset();
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
+      boost::make_tuple());
+    COPY_COUNT(2);
+    MOVE_COUNT(0);
+
+    //
+    // 1 argument
+    //
+
+    reset();
+    x.emplace(a);
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
+
+    // A new object is created by source, but it shouldn't be moved or
+    // copied.
+    reset();
+    x.emplace(source<std::pair<count_copies, count_copies> >());
+    COPY_COUNT(2);
+    MOVE_COUNT(source_pair_cost);
+
+#if !(defined(__GNUC__) && __cplusplus < 199900L) &&                           \
+  !(defined(_MSC_VER) && _MSC_VER < 1600)
+    count_copies part;
+    reset();
+    std::pair<count_copies const&, count_copies const&> a_ref(part, part);
+    x.emplace(a_ref);
+    COPY_COUNT(2);
+    MOVE_COUNT(0);
+
+#endif
+
+    // No move should take place.
+    // (since a is already in the container)
+    reset();
+    x.emplace(boost::move(a));
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
+
+    //
+    // 2 arguments
+    //
+
+    std::pair<count_copies const, count_copies> b;
+
+    reset();
+    x.emplace(b.first, b.second);
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
+
+    reset();
+    x.emplace(source<count_copies>(), source<count_copies>());
+    COPY_COUNT(2);
+    MOVE_COUNT(source_cost * 2);
+
+    // source<count_copies> creates a single copy.
+    reset();
+    x.emplace(b.first, source<count_copies>());
+    COPY_COUNT(1);
+    MOVE_COUNT(source_cost);
+
+    reset();
+    x.emplace(count_copies(b.first.tag_), count_copies(b.second.tag_));
+    COPY_COUNT(2);
+    MOVE_COUNT(0);
+
+    reset();
+    x.emplace(boost::unordered::piecewise_construct,
+      boost::make_tuple(boost::ref(b.first)),
+      boost::make_tuple(boost::ref(b.second)));
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
+
+#if BOOST_UNORDERED_TUPLE_ARGS
+
+    reset();
+    x.emplace(boost::unordered::piecewise_construct,
+      std::make_tuple(std::ref(b.first)), std::make_tuple(std::ref(b.second)));
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
+
+    std::pair<count_copies const, count_copies> move_source_trial;
+    reset();
+    std::make_tuple(std::move(move_source_trial.first));
+    std::make_tuple(std::move(move_source_trial.second));
+    int tuple_move_cost = ::unnecessary_copy_tests::count_copies::moves;
+    int tuple_copy_cost = ::unnecessary_copy_tests::count_copies::copies;
+
+    std::pair<count_copies const, count_copies> move_source;
+    reset();
+    x.emplace(boost::unordered::piecewise_construct,
+      std::make_tuple(std::move(move_source.first)),
+      std::make_tuple(std::move(move_source.second)));
+    COPY_COUNT(tuple_copy_cost);
+    MOVE_COUNT(tuple_move_cost);
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) &&                                      \
+  !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ < 6) &&               \
+  !(defined(BOOST_MSVC) && BOOST_MSVC < 1700)
+    reset();
+    x.emplace(boost::unordered::piecewise_construct,
+      std::forward_as_tuple(b.first), std::forward_as_tuple(b.second));
+    COPY_COUNT(0);
+    MOVE_COUNT(0);
+#endif
+
+#endif
+  }
+}
+
+RUN_TESTS()