Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

79 files changed, 16326 insertions, 0 deletions

diff --git a/src/boost/libs/unordered/_clang-format b/src/boost/libs/unordered/_clang-format
new file mode 100644
index 000000000..d892b414c
--- /dev/null
+++ b/src/boost/libs/unordered/_clang-format
@@ -0,0 +1,38 @@
+
+# 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)
+
+# Using clang format 4.0
+# http://llvm.org/releases/4.0.0/tools/clang/docs/ClangFormatStyleOptions.html
+
+# Becuase you have to start somewhere.
+BasedOnStyle: LLVM
+
+# Basic settings
+ColumnLimit: 80
+NamespaceIndentation: All
+ContinuationIndentWidth: 2
+IndentWidth: 2
+UseTab: Never
+Language: Cpp
+Standard: Cpp03
+
+# Code layout
+AlignAfterOpenBracket: DontAlign
+AlignTrailingComments: true
+BreakBeforeBraces: Custom
+BraceWrapping:
+    AfterNamespace: false
+    AfterClass: true
+    AfterStruct: true
+    AfterUnion: true
+    AfterEnum: true
+    AfterFunction: true
+    AfterControlStatement: false
+    BeforeCatch: false
+    BeforeElse: false
+PointerAlignment: Left
+
+# Boost specific stuff
+ForEachMacros: [ BOOST_FOREACH, UNORDERED_AUTO_TEST ]
diff --git a/src/boost/libs/unordered/ci/download-boost-snapshot.py b/src/boost/libs/unordered/ci/download-boost-snapshot.py
new file mode 100644
index 000000000..a9d8ba98f
--- /dev/null
+++ b/src/boost/libs/unordered/ci/download-boost-snapshot.py
@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+
+import urllib, os, os.path, sys, json, tarfile, zipfile, tempfile
+
+def download(snapshot):
+    if snapshot == 'stable':
+        # TODO: Default version/filename if not available?
+        downloads = [
+            "https://sourceforge.net/projects/boost/files/boost/%s/%s.tar.bz2/download" %
+                (os.environ['BOOST_VERSION'], os.environ['BOOST_FILENAME'])]
+    else:
+        json_response = urllib.urlopen('https://api.bintray.com/packages/boostorg/%s/snapshot/files' % (snapshot))
+        x = json.load(json_response)
+
+        extension_priorities = { '.bz2': 2, '.gz': 1, '.zip': 0 }
+        file_list = []
+        version_dates = {}
+        for file in x:
+            file_extension = os.path.splitext(file['path'])[1]
+            if (file_extension in extension_priorities):
+                file['priority'] = extension_priorities[file_extension]
+                file_list.append(file)
+                if not file['version'] in version_dates or file['created'] < version_dates[file['version']]:
+                    version_dates[file['version']] = file['created']
+        file_list.sort(key=lambda x: (version_dates[x['version']], x['priority']), reverse=True)
+        downloads = ['http://dl.bintray.com/boostorg/%s/%s' % (snapshot, file['path']) for file in file_list]
+
+    filename = ''
+    for download_url in downloads:
+        try:
+            print "Downloading: " + download_url
+            (filename, headers) = urllib.urlretrieve(download_url)
+
+            print "Extracting: " + filename
+            dir = tempfile.mkdtemp()
+            extract(filename, dir)
+            os.remove(filename)
+            files = os.listdir(dir)
+            assert(len(files) == 1)
+            os.rename(os.path.join(dir, files[0]), 'boost')
+            return
+        except IOError:
+            print "Error opening URL: " + download_url
+
+def extract(filename, path = '.'):
+    if (filename.endswith(".gz")):
+        tar = tarfile.open(filename, "r:gz")
+        tar.extractall(path)
+        tar.close
+    elif (filename.endswith(".bz2")):
+        tar = tarfile.open(filename, "r:bz2")
+        tar.extractall(path)
+        tar.close
+    elif (filename.endswith(".zip")):
+        zip = zipfile.ZipFile(filename, "r")
+        zip.extractall(path)
+        zip.close
+    else:
+        assert False
+
+if len(sys.argv) == 1:
+    download('stable')
+elif len(sys.argv) == 2:
+    download(sys.argv[1])
+else:
+    print "Usage: %s [stable|branch-name]" % (sys.argv[0])
diff --git a/src/boost/libs/unordered/examples/case_insensitive.hpp b/src/boost/libs/unordered/examples/case_insensitive.hpp
new file mode 100644
index 000000000..83a388d87
--- /dev/null
+++ b/src/boost/libs/unordered/examples/case_insensitive.hpp
@@ -0,0 +1,58 @@
+
+// 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 file implements a locale aware case insenstive equality predicate and
+// hash function. Unfortunately it still falls short of full
+// internationalization as it only deals with a single character at a time
+// (some languages have tricky cases where the characters in an upper case
+// string don't have a one-to-one correspondence with the lower case version of
+// the text, eg. )
+
+#if !defined(BOOST_HASH_EXAMPLES_CASE_INSENSITIVE_HEADER)
+#define BOOST_HASH_EXAMPLES_CASE_INSENSITIVE_HEADER
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/functional/hash.hpp>
+
+namespace hash_examples
+{
+    struct iequal_to
+    {
+        iequal_to() {}
+        explicit iequal_to(std::locale const& l) : locale_(l) {}
+
+        template <typename String1, typename String2>
+        bool operator()(String1 const& x1, String2 const& x2) const
+        {
+            return boost::algorithm::iequals(x1, x2, locale_);
+        }
+    private:
+        std::locale locale_;
+    };
+
+    struct ihash
+    {
+        ihash() {}
+        explicit ihash(std::locale const& l) : locale_(l) {}
+
+        template <typename String>
+        std::size_t operator()(String const& x) const
+        {
+            std::size_t seed = 0;
+
+            for(typename String::const_iterator it = x.begin();
+                it != x.end(); ++it)
+            {
+                boost::hash_combine(seed, std::toupper(*it, locale_));
+            }
+
+            return seed;
+        }
+    private:
+        std::locale locale_;
+    };
+}
+
+#endif
diff --git a/src/boost/libs/unordered/examples/case_insensitive_test.cpp b/src/boost/libs/unordered/examples/case_insensitive_test.cpp
new file mode 100644
index 000000000..b717c1306
--- /dev/null
+++ b/src/boost/libs/unordered/examples/case_insensitive_test.cpp
@@ -0,0 +1,82 @@
+
+// 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)
+
+#include "./case_insensitive.hpp"
+#include <boost/core/lightweight_test.hpp>
+#include <boost/unordered_map.hpp>
+
+struct word_info {
+    int tag;
+    explicit word_info(int t = 0) : tag(t) {}
+};
+
+void test1() {
+    boost::unordered_map<std::string, word_info,
+        hash_examples::ihash, hash_examples::iequal_to> idictionary;
+
+    BOOST_TEST(idictionary.empty());
+
+    idictionary["one"] = word_info(1);
+    BOOST_TEST(idictionary.size() == 1);
+    BOOST_TEST(idictionary.find("ONE") != idictionary.end() &&
+        idictionary.find("ONE") == idictionary.find("one"));
+
+    idictionary.insert(std::make_pair("ONE", word_info(2)));
+    BOOST_TEST(idictionary.size() == 1);
+    BOOST_TEST(idictionary.find("ONE") != idictionary.end() &&
+            idictionary.find("ONE")->first == "one" &&
+            idictionary.find("ONE")->second.tag == 1);
+
+    idictionary["One"] = word_info(3);
+    BOOST_TEST(idictionary.size() == 1);
+    BOOST_TEST(idictionary.find("ONE") != idictionary.end() &&
+            idictionary.find("ONE")->first == "one" &&
+            idictionary.find("ONE")->second.tag == 3);
+
+    idictionary["two"] = word_info(4);
+    BOOST_TEST(idictionary.size() == 2);
+    BOOST_TEST(idictionary.find("two") != idictionary.end() &&
+            idictionary.find("TWO")->first == "two" &&
+            idictionary.find("Two")->second.tag == 4);
+
+
+}
+
+void test2() {
+    boost::unordered_map<std::wstring, word_info,
+        hash_examples::ihash, hash_examples::iequal_to> idictionary;
+
+    BOOST_TEST(idictionary.empty());
+
+    idictionary[L"one"] = word_info(1);
+    BOOST_TEST(idictionary.size() == 1);
+    BOOST_TEST(idictionary.find(L"ONE") != idictionary.end() &&
+        idictionary.find(L"ONE") == idictionary.find(L"one"));
+
+    idictionary.insert(std::make_pair(L"ONE", word_info(2)));
+    BOOST_TEST(idictionary.size() == 1);
+    BOOST_TEST(idictionary.find(L"ONE") != idictionary.end() &&
+            idictionary.find(L"ONE")->first == L"one" &&
+            idictionary.find(L"ONE")->second.tag == 1);
+
+    idictionary[L"One"] = word_info(3);
+    BOOST_TEST(idictionary.size() == 1);
+    BOOST_TEST(idictionary.find(L"ONE") != idictionary.end() &&
+            idictionary.find(L"ONE")->first == L"one" &&
+            idictionary.find(L"ONE")->second.tag == 3);
+
+    idictionary[L"two"] = word_info(4);
+    BOOST_TEST(idictionary.size() == 2);
+    BOOST_TEST(idictionary.find(L"two") != idictionary.end() &&
+            idictionary.find(L"TWO")->first == L"two" &&
+            idictionary.find(L"Two")->second.tag == 4);
+}
+
+int main() {
+    test1();
+    test2();
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/unordered/examples/fnv1.hpp b/src/boost/libs/unordered/examples/fnv1.hpp
new file mode 100644
index 000000000..3337d1365
--- /dev/null
+++ b/src/boost/libs/unordered/examples/fnv1.hpp
@@ -0,0 +1,69 @@
+
+// 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)
+
+// This code is also released into the public domain.
+
+// Algorithm from: http://www.isthe.com/chongo/tech/comp/fnv/
+
+#include <string>
+
+namespace hash
+{
+    template <std::size_t FnvPrime, std::size_t OffsetBasis>
+    struct basic_fnv_1
+    {
+        std::size_t operator()(std::string const& text) const
+        {
+            std::size_t hash = OffsetBasis;
+            for(std::string::const_iterator it = text.begin(), end = text.end();
+                    it != end; ++it)
+            {
+                hash *= FnvPrime;
+                hash ^= *it;
+            }
+
+            return hash;
+        }
+    };
+
+    template <std::size_t FnvPrime, std::size_t OffsetBasis>
+    struct basic_fnv_1a
+    {
+        std::size_t operator()(std::string const& text) const
+        {
+            std::size_t hash = OffsetBasis;
+            for(std::string::const_iterator it = text.begin(), end = text.end();
+                    it != end; ++it)
+            {
+                hash ^= *it;
+                hash *= FnvPrime;
+            }
+
+            return hash;
+        }
+    };
+
+    // For 32 bit machines:
+    const std::size_t fnv_prime = 16777619u;
+    const std::size_t fnv_offset_basis = 2166136261u;
+
+    // For 64 bit machines:
+    // const std::size_t fnv_prime = 1099511628211u;
+    // const std::size_t fnv_offset_basis = 14695981039346656037u;
+
+    // For 128 bit machines:
+    // const std::size_t fnv_prime = 309485009821345068724781401u;
+    // const std::size_t fnv_offset_basis =
+    //     275519064689413815358837431229664493455u;
+
+    // For 256 bit machines:
+    // const std::size_t fnv_prime =
+    //     374144419156711147060143317175368453031918731002211u;
+    // const std::size_t fnv_offset_basis =
+    //     100029257958052580907070968620625704837092796014241193945225284501741471925557u;
+
+    typedef basic_fnv_1<fnv_prime, fnv_offset_basis> fnv_1;
+    typedef basic_fnv_1a<fnv_prime, fnv_offset_basis> fnv_1a;
+}
diff --git a/src/boost/libs/unordered/index.html b/src/boost/libs/unordered/index.html
new file mode 100644
index 000000000..a752386cf
--- /dev/null
+++ b/src/boost/libs/unordered/index.html
@@ -0,0 +1,16 @@
+
+<!--
+Copyright 2005-2007 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)
+-->
+
+<html>
+<head>
+    <meta http-equiv="refresh" content="0; URL=../../doc/html/unordered.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../../doc/html/unordered.html">../../doc/html/unordered.html</a>
+</body>
+</html>
diff --git a/src/boost/libs/unordered/meta/explicit-failures-markup.xml b/src/boost/libs/unordered/meta/explicit-failures-markup.xml
new file mode 100644
index 000000000..25a19e3df
--- /dev/null
+++ b/src/boost/libs/unordered/meta/explicit-failures-markup.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2017-2018 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)
+-->
+<explicit-failures-markup>
+    <!-- unordered -->
+    <library name="unordered">
+      <mark-expected-failures>
+        <test name="unnecessary_copy_tests"/>
+        <toolset name="borland-*"/>
+        <toolset name="sun-*"/>
+        <note author="Daniel James">
+            This tests whether inserting elements creates as few copies as I think
+            is possible. If this fails it just means that the container might be
+            a little inefficient.
+        </note>
+      </mark-expected-failures>
+
+      <mark-expected-failures>
+        <test name="compile_map_unordered_allocator"/>
+        <toolset name="msvc-7.1"/>
+        <note author="Daniel James">
+            This test fail because it's using unordered's internal
+            allocator traits, which doesn't work on Visual C++ 7.1.
+            It normally uses the one from Boost.Container by default.
+        </note>
+      </mark-expected-failures>
+
+      <mark-expected-failures>
+        <test name="noexcept_tests"/>
+        <toolset name="gcc-4.3c+"/>
+        <note author="Daniel James">
+            boost::is_nothrow_move_constructible and
+            boost::is_nothrow_move_assignable don't seem to work on this
+            compiler. I'd hope that anyone wanting noexcept support would
+            use a more recent compiler anyway.
+        </note>
+      </mark-expected-failures>
+      </library>
+</explicit-failures-markup>
+
diff --git a/src/boost/libs/unordered/meta/libraries.json b/src/boost/libs/unordered/meta/libraries.json
new file mode 100644
index 000000000..1cd5b6ce8
--- /dev/null
+++ b/src/boost/libs/unordered/meta/libraries.json
@@ -0,0 +1,17 @@
+{
+    "key": "unordered",
+    "name": "Unordered",
+    "authors": [
+        "Daniel James"
+    ],
+    "maintainers": [
+        "Daniel James <dnljms -at- gmail.com>"
+    ],
+    "description": "Unordered associative containers.",
+    "std": [
+        "tr1"
+    ],
+    "category": [
+        "Containers"
+    ]
+}
\ No newline at end of file
diff --git a/src/boost/libs/unordered/test/Jamfile.v2 b/src/boost/libs/unordered/test/Jamfile.v2
new file mode 100644
index 000000000..67c31d989
--- /dev/null
+++ b/src/boost/libs/unordered/test/Jamfile.v2
@@ -0,0 +1,97 @@
+
+# Copyright 2006-2008 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)
+
+import testing ;
+
+project unordered-test/unordered
+    : requirements
+        <warnings>all
+        <toolset>intel:<warnings>on
+        # Would be nice to define -Wundef, but I'm getting warnings from
+        # Boost.Preprocessor on trunk.
+        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
+        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
+        <toolset>clang:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wsign-conversion -Wconversion -Wfloat-equal -Wshadow"
+        <toolset>msvc:<cxxflags>"/wd4494"
+        <toolset>gcc:<c++-template-depth>500
+    ;
+
+#alias framework : /boost/test//boost_unit_test_framework ;
+alias framework : ;
+
+test-suite unordered
+    :
+        [ run unordered/fwd_set_test.cpp ]
+        [ run unordered/fwd_map_test.cpp ]
+        [ run unordered/allocator_traits.cpp ]
+        [ run unordered/minimal_allocator.cpp ]
+        [ run unordered/compile_set.cpp ]
+        [ run unordered/compile_map.cpp ]
+        [ run unordered/compile_map.cpp : :
+            : <define>BOOST_UNORDERED_USE_ALLOCATOR_TRAITS=0
+            : compile_map_unordered_allocator ]
+        [ run unordered/noexcept_tests.cpp ]
+        [ run unordered/link_test_1.cpp unordered/link_test_2.cpp ]
+        [ run unordered/incomplete_test.cpp ]
+        [ run unordered/simple_tests.cpp ]
+        [ run unordered/equivalent_keys_tests.cpp ]
+        [ run unordered/constructor_tests.cpp ]
+        [ run unordered/copy_tests.cpp ]
+        [ run unordered/move_tests.cpp ]
+        [ run unordered/assign_tests.cpp ]
+        [ run unordered/insert_tests.cpp ]
+        [ run unordered/insert_stable_tests.cpp ]
+        [ run unordered/insert_hint_tests.cpp ]
+        [ run unordered/emplace_tests.cpp ]
+        [ run unordered/unnecessary_copy_tests.cpp ]
+        [ run unordered/erase_tests.cpp : : : <define>BOOST_UNORDERED_SUPPRESS_DEPRECATED ]
+        [ run unordered/erase_equiv_tests.cpp ]
+        [ run unordered/extract_tests.cpp ]
+        [ run unordered/node_handle_tests.cpp ]
+        [ run unordered/merge_tests.cpp ]
+        [ compile-fail unordered/insert_node_type_fail.cpp : <define>UNORDERED_TEST_MAP : insert_node_type_fail_map ]
+        [ compile-fail unordered/insert_node_type_fail.cpp : <define>UNORDERED_TEST_MULTIMAP : insert_node_type_fail_multimap ]
+        [ compile-fail unordered/insert_node_type_fail.cpp : <define>UNORDERED_TEST_SET : insert_node_type_fail_set ]
+        [ compile-fail unordered/insert_node_type_fail.cpp : <define>UNORDERED_TEST_MULTISET : insert_node_type_fail_multiset ]
+        [ run unordered/find_tests.cpp ]
+        [ run unordered/at_tests.cpp ]
+        [ run unordered/bucket_tests.cpp ]
+        [ run unordered/load_factor_tests.cpp ]
+        [ run unordered/rehash_tests.cpp ]
+        [ run unordered/equality_tests.cpp ]
+        [ run unordered/swap_tests.cpp ]
+        [ run unordered/detail_tests.cpp ]
+        [ run unordered/deduction_tests.cpp ]
+
+        [ run unordered/compile_set.cpp : :
+            : <define>BOOST_UNORDERED_USE_MOVE
+            : bmove_compile_set ]
+        [ run unordered/compile_map.cpp : :
+            : <define>BOOST_UNORDERED_USE_MOVE
+            : bmove_compile_map ]
+        [ run unordered/copy_tests.cpp : :
+            : <define>BOOST_UNORDERED_USE_MOVE
+            : bmove_copy ]
+        [ run unordered/move_tests.cpp : :
+            : <define>BOOST_UNORDERED_USE_MOVE
+            : bmove_move ]
+        [ run unordered/assign_tests.cpp : :
+            : <define>BOOST_UNORDERED_USE_MOVE
+            : bmove_assign ]
+    ;
+
+test-suite unordered-exception
+    :
+        [ run exception/constructor_exception_tests.cpp framework ]
+        [ run exception/copy_exception_tests.cpp framework ]
+        [ run exception/assign_exception_tests.cpp framework ]
+        [ run exception/move_assign_exception_tests.cpp framework ]
+        [ run exception/insert_exception_tests.cpp framework ]
+        [ run exception/erase_exception_tests.cpp framework ]
+        [ run exception/rehash_exception_tests.cpp framework ]
+        [ run exception/swap_exception_tests.cpp framework : : :
+            <define>BOOST_UNORDERED_SWAP_METHOD=2 ]
+        [ run exception/merge_exception_tests.cpp framework ]
+    ;
diff --git a/src/boost/libs/unordered/test/exception/assign_exception_tests.cpp b/src/boost/libs/unordered/test/exception/assign_exception_tests.cpp
new file mode 100644
index 000000000..c62bf8ab5
--- /dev/null
+++ b/src/boost/libs/unordered/test/exception/assign_exception_tests.cpp
@@ -0,0 +1,185 @@
+
+// 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)
+
+#include "./containers.hpp"
+
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable : 4512) // assignment operator could not be generated
+#endif
+
+test::seed_t initialize_seed(12847);
+
+template <class T> struct self_assign_base : public test::exception_base
+{
+  test::random_values<T> values;
+  self_assign_base(std::size_t count = 0) : values(count, test::limited_range)
+  {
+  }
+
+  typedef T data_type;
+  T init() const { return T(values.begin(), values.end()); }
+
+  void run(T& x) const
+  {
+    x = x;
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, values);
+    test::check_equivalent_keys(x);
+  }
+
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
+  {
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct self_assign_test1 : self_assign_base<T>
+{
+};
+
+template <class T> struct self_assign_test2 : self_assign_base<T>
+{
+  self_assign_test2() : self_assign_base<T>(100) {}
+};
+
+template <class T> struct assign_base : public test::exception_base
+{
+  test::random_values<T> x_values, y_values;
+  T x, y;
+
+  typedef typename T::hasher hasher;
+  typedef typename T::key_equal key_equal;
+  typedef typename T::allocator_type allocator_type;
+
+  assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
+      : x_values(), y_values(),
+        x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
+        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
+  {
+    x.max_load_factor(mlf1);
+    y.max_load_factor(mlf2);
+  }
+
+  typedef T data_type;
+  T init() const { return T(x); }
+
+  void run(T& x1) const
+  {
+    x1 = y;
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x1, y_values);
+    test::check_equivalent_keys(x1);
+  }
+
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x1) const
+  {
+    test::check_equivalent_keys(x1);
+
+    // If the container is empty at the point of the exception, the
+    // internal structure is hidden, this exposes it, at the cost of
+    // messing up the data.
+    if (x_values.size()) {
+      T& x2 = const_cast<T&>(x1);
+      x2.emplace(*x_values.begin());
+      test::check_equivalent_keys(x2);
+    }
+  }
+};
+
+template <class T> struct assign_values : assign_base<T>
+{
+  assign_values(unsigned int count1, unsigned int count2, int tag1, int tag2,
+    test::random_generator gen = test::default_generator, float mlf1 = 1.0,
+    float mlf2 = 1.0)
+      : assign_base<T>(tag1, tag2, mlf1, mlf2)
+  {
+    this->x_values.fill(count1, gen);
+    this->y_values.fill(count2, gen);
+    this->x.insert(this->x_values.begin(), this->x_values.end());
+    this->y.insert(this->y_values.begin(), this->y_values.end());
+  }
+};
+
+template <class T> struct assign_test1 : assign_values<T>
+{
+  assign_test1() : assign_values<T>(0, 0, 0, 0) {}
+};
+
+template <class T> struct assign_test2 : assign_values<T>
+{
+  assign_test2() : assign_values<T>(60, 0, 0, 0) {}
+};
+
+template <class T> struct assign_test2a : assign_values<T>
+{
+  assign_test2a() : assign_values<T>(60, 0, 0, 0, test::limited_range) {}
+};
+
+template <class T> struct assign_test3 : assign_values<T>
+{
+  assign_test3() : assign_values<T>(0, 60, 0, 0) {}
+};
+
+template <class T> struct assign_test3a : assign_values<T>
+{
+  assign_test3a() : assign_values<T>(0, 60, 0, 0, test::limited_range) {}
+};
+
+template <class T> struct assign_test4 : assign_values<T>
+{
+  assign_test4() : assign_values<T>(10, 10, 1, 2) {}
+};
+
+template <class T> struct assign_test4a : assign_values<T>
+{
+  assign_test4a() : assign_values<T>(10, 100, 1, 2) {}
+};
+
+template <class T> struct assign_test4b : assign_values<T>
+{
+  assign_test4b() : assign_values<T>(10, 100, 1, 2, test::limited_range) {}
+};
+
+template <class T> struct assign_test5 : assign_values<T>
+{
+  assign_test5()
+      : assign_values<T>(5, 60, 0, 0, test::default_generator, 1.0f, 0.1f)
+  {
+  }
+};
+
+template <class T> struct equivalent_test1 : assign_base<T>
+{
+  equivalent_test1() : assign_base<T>(0, 0)
+  {
+    test::random_values<T> x_values2(10);
+    this->x_values.insert(x_values2.begin(), x_values2.end());
+    this->x_values.insert(x_values2.begin(), x_values2.end());
+    test::random_values<T> y_values2(10);
+    this->y_values.insert(y_values2.begin(), y_values2.end());
+    this->y_values.insert(y_values2.begin(), y_values2.end());
+    this->x.insert(this->x_values.begin(), this->x_values.end());
+    this->y.insert(this->y_values.begin(), this->y_values.end());
+  }
+};
+
+// clang-format off
+EXCEPTION_TESTS_REPEAT(5,
+    (self_assign_test1)(self_assign_test2)
+    (assign_test1)(assign_test2)(assign_test2a)
+    (assign_test3)(assign_test3a)
+    (assign_test4)(assign_test4a)(assign_test4b)
+    (assign_test5)
+    (equivalent_test1),
+    CONTAINER_SEQ)
+// clang-format on
+
+RUN_TESTS()
diff --git a/src/boost/libs/unordered/test/exception/constructor_exception_tests.cpp b/src/boost/libs/unordered/test/exception/constructor_exception_tests.cpp
new file mode 100644
index 000000000..3dfebceff
--- /dev/null
+++ b/src/boost/libs/unordered/test/exception/constructor_exception_tests.cpp
@@ -0,0 +1,212 @@
+
+// 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)
+
+#include "./containers.hpp"
+
+#include "../helpers/input_iterator.hpp"
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+
+template <typename T> inline void avoid_unused_warning(T const&) {}
+
+test::seed_t initialize_seed(91274);
+
+struct objects
+{
+  test::exception::object obj;
+  test::exception::hash hash;
+  test::exception::equal_to equal_to;
+  test::exception::allocator<test::exception::object> allocator;
+};
+
+template <class T> struct construct_test1 : public objects, test::exception_base
+{
+  void run() const
+  {
+    T x;
+
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct construct_test2 : public objects, test::exception_base
+{
+  void run() const
+  {
+    T x(300);
+
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct construct_test3 : public objects, test::exception_base
+{
+  void run() const
+  {
+    T x(0, hash);
+
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct construct_test4 : public objects, test::exception_base
+{
+  void run() const
+  {
+    T x(0, hash, equal_to);
+
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct construct_test5 : public objects, test::exception_base
+{
+  void run() const
+  {
+    T x(50, hash, equal_to, allocator);
+
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct construct_test6 : public objects, test::exception_base
+{
+  void run() const
+  {
+    T x(allocator);
+
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct range : public test::exception_base
+{
+  test::random_values<T> values;
+
+  range() : values(5, test::limited_range) {}
+  range(unsigned int count) : values(count, test::limited_range) {}
+};
+
+template <class T> struct range_construct_test1 : public range<T>, objects
+{
+  void run() const
+  {
+    T x(this->values.begin(), this->values.end());
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct range_construct_test2 : public range<T>, objects
+{
+  void run() const
+  {
+    T x(this->values.begin(), this->values.end(), 0);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct range_construct_test3 : public range<T>, objects
+{
+  void run() const
+  {
+    T x(this->values.begin(), this->values.end(), 0, hash);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct range_construct_test4 : public range<T>, objects
+{
+  void run() const
+  {
+    T x(this->values.begin(), this->values.end(), 100, hash, equal_to);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+// Need to run at least one test with a fairly large number
+// of objects in case it triggers a rehash.
+template <class T> struct range_construct_test5 : public range<T>, objects
+{
+  range_construct_test5() : range<T>(60) {}
+
+  void run() const
+  {
+    T x(this->values.begin(), this->values.end(), 0, hash, equal_to, allocator);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct input_range_construct_test : public range<T>, objects
+{
+  input_range_construct_test() : range<T>(60) {}
+
+  void run() const
+  {
+    typename test::random_values<T>::const_iterator begin =
+                                                      this->values.begin(),
+                                                    end = this->values.end();
+    T x(test::input_iterator(begin), test::input_iterator(end), 0, hash,
+      equal_to, allocator);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct copy_range_construct_test : public range<T>, objects
+{
+  copy_range_construct_test() : range<T>(60) {}
+
+  void run() const
+  {
+    T x(test::copy_iterator(this->values.begin()),
+      test::copy_iterator(this->values.end()), 0, hash, equal_to, allocator);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+// clang-format off
+EXCEPTION_TESTS(
+  (construct_test1)(construct_test2)(construct_test3)(construct_test4)
+  (construct_test5)(construct_test6)(range_construct_test1)
+  (range_construct_test2)(range_construct_test3)(range_construct_test4)
+  (range_construct_test5)(input_range_construct_test)
+  (copy_range_construct_test),
+  CONTAINER_SEQ)
+// clang-format on
+
+RUN_TESTS()
diff --git a/src/boost/libs/unordered/test/exception/containers.hpp b/src/boost/libs/unordered/test/exception/containers.hpp
new file mode 100644
index 000000000..c3b34be24
--- /dev/null
+++ b/src/boost/libs/unordered/test/exception/containers.hpp
@@ -0,0 +1,44 @@
+
+// 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_map.hpp>
+#include <boost/unordered_set.hpp>
+#include "../helpers/postfix.hpp"
+// clang-format on
+
+#include "../objects/exception.hpp"
+
+typedef boost::unordered_set<test::exception::object, test::exception::hash,
+  test::exception::equal_to,
+  test::exception::allocator<test::exception::object> >
+  test_set;
+typedef boost::unordered_multiset<test::exception::object,
+  test::exception::hash, test::exception::equal_to,
+  test::exception::allocator2<test::exception::object> >
+  test_multiset;
+typedef boost::unordered_map<test::exception::object, test::exception::object,
+  test::exception::hash, test::exception::equal_to,
+  test::exception::allocator2<test::exception::object> >
+  test_map;
+typedef boost::unordered_multimap<test::exception::object,
+  test::exception::object, test::exception::hash, test::exception::equal_to,
+  test::exception::allocator<test::exception::object> >
+  test_multimap;
+typedef boost::unordered_set<
+  std::pair<test::exception::object, test::exception::object>,
+  test::exception::hash, test::exception::equal_to,
+  test::exception::allocator<test::exception::object> >
+  test_pair_set;
+typedef boost::unordered_multiset<
+  std::pair<test::exception::object, test::exception::object>,
+  test::exception::hash, test::exception::equal_to,
+  test::exception::allocator2<test::exception::object> >
+  test_pair_multiset;
+
+#define CONTAINER_SEQ (test_set)(test_multiset)(test_map)(test_multimap)
+#define CONTAINER_PAIR_SEQ                                                     \
+  (test_pair_set)(test_pair_multiset)(test_map)(test_multimap)
diff --git a/src/boost/libs/unordered/test/exception/copy_exception_tests.cpp b/src/boost/libs/unordered/test/exception/copy_exception_tests.cpp
new file mode 100644
index 000000000..6149235aa
--- /dev/null
+++ b/src/boost/libs/unordered/test/exception/copy_exception_tests.cpp
@@ -0,0 +1,110 @@
+
+// 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)
+
+#include "./containers.hpp"
+
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+
+template <typename T> inline void avoid_unused_warning(T const&) {}
+
+test::seed_t initialize_seed(73041);
+
+template <class T> struct copy_test1 : public test::exception_base
+{
+  T x;
+
+  void run() const
+  {
+    T y(x);
+
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(y.empty());
+    test::check_equivalent_keys(y);
+  }
+};
+
+template <class T> struct copy_test2 : public test::exception_base
+{
+  test::random_values<T> values;
+  T x;
+
+  copy_test2() : values(5, test::limited_range), x(values.begin(), values.end())
+  {
+  }
+
+  void run() const
+  {
+    T y(x);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(y, this->values);
+    test::check_equivalent_keys(y);
+  }
+};
+
+template <class T> struct copy_test3 : public test::exception_base
+{
+  test::random_values<T> values;
+  T x;
+
+  copy_test3() : values(100), x(values.begin(), values.end()) {}
+
+  void run() const
+  {
+    T y(x);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(y, this->values);
+    test::check_equivalent_keys(y);
+  }
+};
+
+template <class T> struct copy_test3a : public test::exception_base
+{
+  test::random_values<T> values;
+  T x;
+
+  copy_test3a()
+      : values(100, test::limited_range), x(values.begin(), values.end())
+  {
+  }
+
+  void run() const
+  {
+    T y(x);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(y, this->values);
+    test::check_equivalent_keys(y);
+  }
+};
+
+template <class T> struct copy_with_allocator_test : public test::exception_base
+{
+  test::random_values<T> values;
+  T x;
+  test::exception::allocator<test::exception::object> allocator;
+
+  copy_with_allocator_test() : values(100), x(values.begin(), values.end()) {}
+
+  void run() const
+  {
+    T y(x, allocator);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(y, this->values);
+    test::check_equivalent_keys(y);
+  }
+};
+
+// clang-format off
+EXCEPTION_TESTS(
+    (copy_test1)(copy_test2)(copy_test3)(copy_test3a)(copy_with_allocator_test),
+    CONTAINER_SEQ)
+// clang-format on
+
+RUN_TESTS()
diff --git a/src/boost/libs/unordered/test/exception/erase_exception_tests.cpp b/src/boost/libs/unordered/test/exception/erase_exception_tests.cpp
new file mode 100644
index 000000000..0f2c1eb61
--- /dev/null
+++ b/src/boost/libs/unordered/test/exception/erase_exception_tests.cpp
@@ -0,0 +1,55 @@
+
+// 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)
+
+#include "./containers.hpp"
+
+#include "../helpers/helpers.hpp"
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+
+test::seed_t initialize_seed(835193);
+
+template <class T> struct erase_test_base : public test::exception_base
+{
+  test::random_values<T> values;
+  erase_test_base(unsigned int count = 5) : values(count, test::limited_range)
+  {
+  }
+
+  typedef T data_type;
+
+  data_type init() const { return T(values.begin(), values.end()); }
+
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
+  {
+    std::string scope(test::scope);
+
+    BOOST_TEST(scope.find("hash::") != std::string::npos ||
+               scope.find("equal_to::") != std::string::npos ||
+               scope == "operator==(object, object)");
+
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct erase_by_key_test1 : public erase_test_base<T>
+{
+  void run(T& x) const
+  {
+    typedef typename test::random_values<T>::const_iterator iterator;
+
+    for (iterator it = this->values.begin(), end = this->values.end();
+         it != end; ++it) {
+      x.erase(test::get_key<T>(*it));
+    }
+
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(x.empty());
+    test::check_equivalent_keys(x);
+  }
+};
+
+EXCEPTION_TESTS((erase_by_key_test1), CONTAINER_SEQ)
+RUN_TESTS()
diff --git a/src/boost/libs/unordered/test/exception/insert_exception_tests.cpp b/src/boost/libs/unordered/test/exception/insert_exception_tests.cpp
new file mode 100644
index 000000000..79074c5ee
--- /dev/null
+++ b/src/boost/libs/unordered/test/exception/insert_exception_tests.cpp
@@ -0,0 +1,416 @@
+
+// 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)
+#include "./containers.hpp"
+
+#include "../helpers/helpers.hpp"
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/strong.hpp"
+#include "../helpers/tracker.hpp"
+#include <cmath>
+#include <string>
+
+test::seed_t initialize_seed(747373);
+
+// Fill in a container so that it's about to rehash
+template <typename T> void rehash_prep(T& x)
+{
+  using namespace std;
+  typedef typename T::size_type size_type;
+
+  x.max_load_factor(0.25);
+  size_type bucket_count = x.bucket_count();
+  size_type initial_elements = static_cast<size_type>(
+    ceil((double)bucket_count * (double)x.max_load_factor()) - 1);
+  test::random_values<T> v(initial_elements);
+  x.insert(v.begin(), v.end());
+  BOOST_TEST(bucket_count == x.bucket_count());
+}
+
+// Overload to generate inserters that need type information.
+
+template <typename Inserter, typename T>
+Inserter generate(Inserter inserter, T&)
+{
+  return inserter;
+}
+
+// Get the iterator returned from an insert/emplace.
+
+template <typename T> T get_iterator(T const& x) { return x; }
+
+template <typename T> T get_iterator(std::pair<T, bool> const& x)
+{
+  return x.first;
+}
+
+// Generic insert exception test for typical single element inserts..
+
+template <typename T, typename Inserter, typename Values>
+void insert_exception_test_impl(T x, Inserter insert, Values const& v)
+{
+  test::strong<T> strong;
+
+  test::ordered<T> tracker;
+  tracker.insert(x.begin(), x.end());
+
+  try {
+    ENABLE_EXCEPTIONS;
+
+    for (typename Values::const_iterator it = v.begin(); it != v.end(); ++it) {
+      strong.store(x, test::detail::tracker.count_allocations);
+      insert(x, it);
+    }
+  } catch (...) {
+    test::check_equivalent_keys(x);
+    insert.exception_check(x, strong);
+    throw;
+  }
+
+  test::check_equivalent_keys(x);
+  insert.track(tracker, v.begin(), v.end());
+  tracker.compare(x);
+}
+
+// Simple insert exception test
+
+template <typename T, typename Inserter>
+void insert_exception_test(T*, Inserter insert, test::random_generator gen)
+{
+  for (int i = 0; i < 5; ++i) {
+    test::random_values<T> v(10, gen);
+    T x;
+
+    EXCEPTION_LOOP(insert_exception_test_impl(x, generate(insert, x), v));
+  }
+}
+
+// Insert into a container which is about to hit its max load, so that it
+// rehashes.
+
+template <typename T, typename Inserter>
+void insert_rehash_exception_test(
+  T*, Inserter insert, test::random_generator gen)
+{
+  for (int i = 0; i < 5; ++i) {
+    T x;
+    rehash_prep(x);
+
+    test::random_values<T> v2(5, gen);
+    EXCEPTION_LOOP(insert_exception_test_impl(x, generate(insert, x), v2));
+  }
+}
+
+// Various methods for inserting a single element
+
+struct inserter_base
+{
+  template <typename T> void exception_check(T& x, test::strong<T>& strong)
+  {
+    std::string scope(test::scope);
+
+    if (scope.find("hash::operator()") == std::string::npos)
+      strong.test(x, test::detail::tracker.count_allocations);
+  }
+
+  template <typename T, typename Iterator>
+  void track(T& tracker, Iterator begin, Iterator end)
+  {
+    tracker.insert(begin, end);
+  }
+};
+
+struct insert_lvalue_type : inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.insert(*it);
+  }
+} insert_lvalue;
+
+struct insert_lvalue_begin_type : inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.insert(x.begin(), *it);
+  }
+} insert_lvalue_begin;
+
+struct insert_lvalue_end_type : inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.insert(x.end(), *it);
+  }
+} insert_lvalue_end;
+
+template <typename T> struct insert_lvalue_pos_type_impl : inserter_base
+{
+  typename T::iterator pos;
+
+  insert_lvalue_pos_type_impl(T& x) : pos(x.begin()) {}
+
+  template <typename Iterator> void operator()(T& x, Iterator it)
+  {
+    pos = get_iterator(x.insert(pos, *it));
+  }
+};
+
+struct insert_lvalue_pos_type
+{
+  template <typename T>
+  friend insert_lvalue_pos_type_impl<T> generate(insert_lvalue_pos_type, T& x)
+  {
+    return insert_lvalue_pos_type_impl<T>(x);
+  }
+} insert_lvalue_pos;
+
+struct insert_single_item_range_type : inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.insert(it, test::next(it));
+  }
+} insert_single_item_range;
+
+struct emplace_lvalue_type : inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.emplace(*it);
+  }
+} emplace_lvalue;
+
+struct emplace_lvalue_begin_type : inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.emplace_hint(x.begin(), *it);
+  }
+} emplace_lvalue_begin;
+
+struct emplace_lvalue_end_type : inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.emplace_hint(x.end(), *it);
+  }
+} emplace_lvalue_end;
+
+template <typename T> struct emplace_lvalue_pos_type_impl : inserter_base
+{
+  typename T::iterator pos;
+
+  emplace_lvalue_pos_type_impl(T& x) : pos(x.begin()) {}
+
+  template <typename Iterator> void operator()(T& x, Iterator it)
+  {
+    pos = get_iterator(x.emplace_hint(pos, *it));
+  }
+};
+
+struct emplace_lvalue_pos_type
+{
+  template <typename T>
+  friend emplace_lvalue_pos_type_impl<T> generate(emplace_lvalue_pos_type, T& x)
+  {
+    return emplace_lvalue_pos_type_impl<T>(x);
+  }
+} emplace_lvalue_pos;
+
+// Run the exception tests in various combinations.
+
+test_set* test_set_;
+test_multiset* test_multiset_;
+test_map* test_map_;
+test_multimap* test_multimap_;
+
+using test::default_generator;
+using test::limited_range;
+using test::generate_collisions;
+
+// clang-format off
+UNORDERED_TEST(insert_exception_test,
+    ((test_set_)(test_multiset_)(test_map_)(test_multimap_))
+    ((insert_lvalue)(insert_lvalue_begin)(insert_lvalue_end)
+     (insert_lvalue_pos)(insert_single_item_range)
+     (emplace_lvalue)(emplace_lvalue_begin)(emplace_lvalue_end)
+     (emplace_lvalue_pos)
+    )
+    ((default_generator)(limited_range)(generate_collisions))
+)
+
+UNORDERED_TEST(insert_rehash_exception_test,
+    ((test_set_)(test_multiset_)(test_map_)(test_multimap_))
+    ((insert_lvalue)(insert_lvalue_begin)(insert_lvalue_end)
+     (insert_lvalue_pos)(insert_single_item_range)
+     (emplace_lvalue)(emplace_lvalue_begin)(emplace_lvalue_end)
+     (emplace_lvalue_pos)
+    )
+    ((default_generator)(limited_range)(generate_collisions))
+)
+// clang-format on
+
+// Repeat insert tests with pairs
+
+struct pair_emplace_type : inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.emplace(boost::unordered::piecewise_construct,
+      boost::make_tuple(it->first), boost::make_tuple(it->second));
+  }
+} pair_emplace;
+
+struct pair_emplace2_type : inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.emplace_hint(x.begin(), boost::unordered::piecewise_construct,
+      boost::make_tuple(it->first),
+      boost::make_tuple(it->second.tag1_, it->second.tag2_));
+  }
+} pair_emplace2;
+
+test_pair_set* test_pair_set_;
+test_pair_multiset* test_pair_multiset_;
+
+// clang-format off
+UNORDERED_TEST(insert_exception_test,
+    ((test_pair_set_)(test_pair_multiset_)(test_map_)(test_multimap_))
+    ((pair_emplace)(pair_emplace2))
+    ((default_generator)(limited_range)(generate_collisions))
+)
+UNORDERED_TEST(insert_rehash_exception_test,
+    ((test_pair_set_)(test_pair_multiset_)(test_map_)(test_multimap_))
+    ((pair_emplace)(pair_emplace2))
+    ((default_generator)(limited_range)(generate_collisions))
+)
+// clang-format on
+
+// Test inserting using operator[]
+
+struct try_emplace_type : inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.try_emplace(it->first, it->second);
+  }
+} try_emplace;
+
+struct try_emplace2_type : inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.try_emplace(it->first, it->second.tag1_, it->second.tag2_);
+  }
+} try_emplace2;
+
+struct map_inserter_base
+{
+  template <typename T> void exception_check(T& x, test::strong<T>& strong)
+  {
+    std::string scope(test::scope);
+
+    if (scope.find("hash::operator()") == std::string::npos &&
+        scope.find("::operator=") == std::string::npos)
+      strong.test(x, test::detail::tracker.count_allocations);
+  }
+
+  template <typename T, typename Iterator>
+  void track(T& tracker, Iterator begin, Iterator end)
+  {
+    for (; begin != end; ++begin) {
+      tracker[begin->first] = begin->second;
+    }
+  }
+};
+
+struct map_insert_operator_type : map_inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x[it->first] = it->second;
+  }
+} map_insert_operator;
+
+struct map_insert_or_assign_type : map_inserter_base
+{
+  template <typename T, typename Iterator> void operator()(T& x, Iterator it)
+  {
+    x.insert_or_assign(it->first, it->second);
+  }
+} map_insert_or_assign;
+
+// clang-format off
+UNORDERED_TEST(insert_exception_test,
+    ((test_map_))
+    ((try_emplace)(try_emplace2)(map_insert_operator)(map_insert_or_assign))
+    ((default_generator)(limited_range)(generate_collisions))
+)
+UNORDERED_TEST(insert_rehash_exception_test,
+    ((test_map_))
+    ((try_emplace)(try_emplace2)(map_insert_operator)(map_insert_or_assign))
+    ((default_generator)(limited_range)(generate_collisions))
+)
+// clang-format on
+
+// Range insert tests
+
+template <typename T, typename Values>
+void insert_range_exception_test_impl(T x, Values const& v)
+{
+  test::ordered<T> tracker;
+  tracker.insert(x.begin(), x.end());
+
+  try {
+    ENABLE_EXCEPTIONS;
+    x.insert(v.begin(), v.end());
+  } catch (...) {
+    test::check_equivalent_keys(x);
+    throw;
+  }
+
+  test::check_equivalent_keys(x);
+  tracker.insert(v.begin(), v.end());
+  tracker.compare(x);
+}
+
+template <typename T>
+void insert_range_exception_test(T*, test::random_generator gen)
+{
+  for (int i = 0; i < 5; ++i) {
+    test::random_values<T> v(10, gen);
+    T x;
+
+    EXCEPTION_LOOP(insert_range_exception_test_impl(x, v));
+  }
+}
+
+template <typename T>
+void insert_range_rehash_exception_test(T*, test::random_generator gen)
+{
+  for (int i = 0; i < 5; ++i) {
+    T x;
+    rehash_prep(x);
+
+    test::random_values<T> v2(5, gen);
+    EXCEPTION_LOOP(insert_range_exception_test_impl(x, v2));
+  }
+}
+
+// clang-format off
+UNORDERED_TEST(insert_range_exception_test,
+    ((test_set_)(test_multiset_)(test_map_)(test_multimap_))
+    ((default_generator)(limited_range)(generate_collisions))
+)
+
+UNORDERED_TEST(insert_range_rehash_exception_test,
+    ((test_set_)(test_multiset_)(test_map_)(test_multimap_))
+    ((default_generator)(limited_range)(generate_collisions))
+)
+// clang-format on
+
+RUN_TESTS()
diff --git a/src/boost/libs/unordered/test/exception/merge_exception_tests.cpp b/src/boost/libs/unordered/test/exception/merge_exception_tests.cpp
new file mode 100644
index 000000000..2cf7faf44
--- /dev/null
+++ b/src/boost/libs/unordered/test/exception/merge_exception_tests.cpp
@@ -0,0 +1,108 @@
+
+// Copyright 2017-2018 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/exception_test.hpp"
+#include "../helpers/invariants.hpp"
+#include "../helpers/metafunctions.hpp"
+#include "../helpers/random_values.hpp"
+#include "./containers.hpp"
+
+template <typename T1, typename T2> void merge_exception_test(T1 x, T2 y)
+{
+  std::size_t size = x.size() + y.size();
+
+  try {
+    ENABLE_EXCEPTIONS;
+    x.merge(y);
+  } catch (...) {
+    test::check_equivalent_keys(x);
+    test::check_equivalent_keys(y);
+    throw;
+  }
+
+  // Not a full check, just want to make sure the merge completed.
+  BOOST_TEST(size == x.size() + y.size());
+  if (y.size()) {
+    BOOST_TEST(test::has_unique_keys<T1>::value);
+    for (typename T2::iterator it = y.begin(); it != y.end(); ++it) {
+      BOOST_TEST(x.find(test::get_key<T2>(*it)) != x.end());
+    }
+  }
+  test::check_equivalent_keys(x);
+  test::check_equivalent_keys(y);
+}
+
+template <typename T1, typename T2>
+void merge_exception_test(T1 const*, T2 const*, std::size_t count12, int tag12,
+  test::random_generator gen1, test::random_generator gen2)
+{
+  std::size_t count1 = count12 / 256;
+  std::size_t count2 = count12 % 256;
+  int tag1 = tag12 / 256;
+  int tag2 = tag12 % 256;
+  test::random_values<T1> v1(count1, gen1);
+  test::random_values<T2> v2(count2, gen2);
+  T1 x(v1.begin(), v1.end(), 0, test::exception::hash(tag1),
+    test::exception::equal_to(tag1));
+  T2 y(v2.begin(), v2.end(), 0, test::exception::hash(tag2),
+    test::exception::equal_to(tag2));
+
+  EXCEPTION_LOOP(merge_exception_test(x, y))
+}
+
+boost::unordered_set<test::exception::object, test::exception::hash,
+  test::exception::equal_to,
+  test::exception::allocator<test::exception::object> >* test_set_;
+boost::unordered_multiset<test::exception::object, test::exception::hash,
+  test::exception::equal_to,
+  test::exception::allocator<test::exception::object> >* test_multiset_;
+boost::unordered_map<test::exception::object, test::exception::object,
+  test::exception::hash, test::exception::equal_to,
+  test::exception::allocator2<test::exception::object> >* test_map_;
+boost::unordered_multimap<test::exception::object, test::exception::object,
+  test::exception::hash, test::exception::equal_to,
+  test::exception::allocator2<test::exception::object> >* test_multimap_;
+
+using test::default_generator;
+using test::generate_collisions;
+using test::limited_range;
+
+// clang-format off
+UNORDERED_MULTI_TEST(set_merge, merge_exception_test,
+    ((test_set_)(test_multiset_))
+    ((test_set_)(test_multiset_))
+    ((0x0000)(0x6400)(0x0064)(0x0a64)(0x3232))
+    ((0x0000)(0x0001)(0x0102))
+    ((default_generator)(limited_range))
+    ((default_generator)(limited_range))
+)
+UNORDERED_MULTI_TEST(map_merge, merge_exception_test,
+    ((test_map_)(test_multimap_))
+    ((test_map_)(test_multimap_))
+    ((0x0000)(0x6400)(0x0064)(0x0a64)(0x3232))
+    ((0x0101)(0x0200)(0x0201))
+    ((default_generator)(limited_range))
+    ((default_generator)(limited_range))
+)
+// Run fewer generate_collisions tests, as they're slow.
+UNORDERED_MULTI_TEST(set_merge_collisions, merge_exception_test,
+    ((test_set_)(test_multiset_))
+    ((test_set_)(test_multiset_))
+    ((0x0a0a))
+    ((0x0202)(0x0100)(0x0201))
+    ((generate_collisions))
+    ((generate_collisions))
+)
+UNORDERED_MULTI_TEST(map_merge_collisions, merge_exception_test,
+    ((test_map_)(test_multimap_))
+    ((test_map_)(test_multimap_))
+    ((0x0a0a))
+    ((0x0000)(0x0002)(0x0102))
+    ((generate_collisions))
+    ((generate_collisions))
+)
+// clang-format on
+
+RUN_TESTS_QUIET()
diff --git a/src/boost/libs/unordered/test/exception/move_assign_exception_tests.cpp b/src/boost/libs/unordered/test/exception/move_assign_exception_tests.cpp
new file mode 100644
index 000000000..6beb68202
--- /dev/null
+++ b/src/boost/libs/unordered/test/exception/move_assign_exception_tests.cpp
@@ -0,0 +1,132 @@
+
+// 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)
+
+#include "./containers.hpp"
+
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+
+#if defined(BOOST_MSVC)
+#pragma warning(                                                               \
+  disable : 4512) // move_assignment operator could not be generated
+#endif
+
+test::seed_t initialize_seed(12847);
+
+template <class T> struct move_assign_base : public test::exception_base
+{
+  test::random_values<T> x_values, y_values;
+  T x, y;
+
+  typedef typename T::hasher hasher;
+  typedef typename T::key_equal key_equal;
+  typedef typename T::allocator_type allocator_type;
+
+  move_assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
+      : x_values(), y_values(),
+        x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
+        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
+  {
+    x.max_load_factor(mlf1);
+    y.max_load_factor(mlf2);
+  }
+
+  typedef T data_type;
+  T init() const { return T(x); }
+  void run(T& x1) const
+  {
+    test::exceptions_enable disable_exceptions(false);
+    T y1 = y;
+    disable_exceptions.release();
+    x1 = boost::move(y1);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x1, y_values);
+    test::check_equivalent_keys(x1);
+  }
+
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x1) const
+  {
+    test::check_equivalent_keys(x1);
+
+    // If the container is empty at the point of the exception, the
+    // internal structure is hidden, this exposes it, at the cost of
+    // messing up the data.
+    if (x_values.size()) {
+      T& x2 = const_cast<T&>(x1);
+      x2.emplace(*x_values.begin());
+      test::check_equivalent_keys(x2);
+    }
+  }
+};
+
+template <class T> struct move_assign_values : move_assign_base<T>
+{
+  move_assign_values(unsigned int count1, unsigned int count2, int tag1,
+    int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
+      : move_assign_base<T>(tag1, tag2, mlf1, mlf2)
+  {
+    this->x_values.fill(count1, test::limited_range);
+    this->y_values.fill(count2, test::limited_range);
+    this->x.insert(this->x_values.begin(), this->x_values.end());
+    this->y.insert(this->y_values.begin(), this->y_values.end());
+  }
+};
+
+template <class T> struct move_assign_test1 : move_assign_values<T>
+{
+  move_assign_test1() : move_assign_values<T>(0, 0, 0, 0) {}
+};
+
+template <class T> struct move_assign_test2 : move_assign_values<T>
+{
+  move_assign_test2() : move_assign_values<T>(60, 0, 0, 0) {}
+};
+
+template <class T> struct move_assign_test3 : move_assign_values<T>
+{
+  move_assign_test3() : move_assign_values<T>(0, 60, 0, 0) {}
+};
+
+template <class T> struct move_assign_test4 : move_assign_values<T>
+{
+  move_assign_test4() : move_assign_values<T>(10, 10, 1, 2) {}
+};
+
+template <class T> struct move_assign_test4a : move_assign_values<T>
+{
+  move_assign_test4a() : move_assign_values<T>(10, 100, 1, 2) {}
+};
+
+template <class T> struct move_assign_test5 : move_assign_values<T>
+{
+  move_assign_test5() : move_assign_values<T>(5, 60, 0, 0, 1.0f, 0.1f) {}
+};
+
+template <class T> struct equivalent_test1 : move_assign_base<T>
+{
+  equivalent_test1() : move_assign_base<T>(0, 0)
+  {
+    test::random_values<T> x_values2(10, test::limited_range);
+    this->x_values.insert(x_values2.begin(), x_values2.end());
+    this->x_values.insert(x_values2.begin(), x_values2.end());
+    test::random_values<T> y_values2(10, test::limited_range);
+    this->y_values.insert(y_values2.begin(), y_values2.end());
+    this->y_values.insert(y_values2.begin(), y_values2.end());
+    this->x.insert(this->x_values.begin(), this->x_values.end());
+    this->y.insert(this->y_values.begin(), this->y_values.end());
+  }
+};
+
+// clang-format off
+EXCEPTION_TESTS(
+  (move_assign_test1)(move_assign_test2)(move_assign_test3)
+  (move_assign_test4)(move_assign_test4a)(move_assign_test5)
+  (equivalent_test1),
+  CONTAINER_SEQ)
+// clang-format on
+
+RUN_TESTS()
diff --git a/src/boost/libs/unordered/test/exception/rehash_exception_tests.cpp b/src/boost/libs/unordered/test/exception/rehash_exception_tests.cpp
new file mode 100644
index 000000000..a927d1368
--- /dev/null
+++ b/src/boost/libs/unordered/test/exception/rehash_exception_tests.cpp
@@ -0,0 +1,133 @@
+
+// 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)
+
+#include "./containers.hpp"
+
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/strong.hpp"
+#include "../helpers/tracker.hpp"
+#include <string>
+
+test::seed_t initialize_seed(3298597);
+
+template <class T> struct rehash_test_base : public test::exception_base
+{
+  test::random_values<T> values;
+  unsigned int n;
+  rehash_test_base(unsigned int count = 100, unsigned int n_ = 0)
+      : values(count, test::limited_range), n(n_)
+  {
+  }
+
+  typedef T data_type;
+  typedef test::strong<T> strong_type;
+
+  data_type init() const
+  {
+    T x(values.begin(), values.end(), n);
+    return x;
+  }
+
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(
+    T const& x, strong_type const& strong) const
+  {
+    std::string scope(test::scope);
+
+    if (scope.find("hash::operator()") == std::string::npos &&
+        scope.find("equal_to::operator()") == std::string::npos &&
+        scope != "operator==(object, object)")
+      strong.test(x);
+
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct rehash_test0 : rehash_test_base<T>
+{
+  rehash_test0() : rehash_test_base<T>(0) {}
+  void run(T& x) const
+  {
+    x.rehash(0);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct rehash_test1 : rehash_test_base<T>
+{
+  rehash_test1() : rehash_test_base<T>(0) {}
+  void run(T& x) const
+  {
+    x.rehash(200);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct rehash_test2 : rehash_test_base<T>
+{
+  rehash_test2() : rehash_test_base<T>(0, 200) {}
+  void run(T& x) const
+  {
+    x.rehash(0);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct rehash_test3 : rehash_test_base<T>
+{
+  rehash_test3() : rehash_test_base<T>(10, 0) {}
+  void run(T& x) const
+  {
+    x.rehash(200);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct rehash_test4 : rehash_test_base<T>
+{
+  rehash_test4() : rehash_test_base<T>(10, 200) {}
+  void run(T& x) const
+  {
+    x.rehash(0);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct rehash_test5 : rehash_test_base<T>
+{
+  rehash_test5() : rehash_test_base<T>(200, 10) {}
+  void run(T& x) const
+  {
+    x.rehash(0);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+};
+
+// clang-format off
+EXCEPTION_TESTS(
+  (rehash_test0)(rehash_test1)(rehash_test2)(rehash_test3)(rehash_test4)
+  (rehash_test5),
+  CONTAINER_SEQ)
+// clang-format on
+
+RUN_TESTS()
diff --git a/src/boost/libs/unordered/test/exception/swap_exception_tests.cpp b/src/boost/libs/unordered/test/exception/swap_exception_tests.cpp
new file mode 100644
index 000000000..1569e814c
--- /dev/null
+++ b/src/boost/libs/unordered/test/exception/swap_exception_tests.cpp
@@ -0,0 +1,145 @@
+
+// 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)
+
+#include "./containers.hpp"
+
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable : 4512) // assignment operator could not be generated
+#endif
+
+test::seed_t initialize_seed(9387);
+
+template <class T> struct self_swap_base : public test::exception_base
+{
+  test::random_values<T> values;
+  self_swap_base(std::size_t count = 0) : values(count, test::limited_range) {}
+
+  typedef T data_type;
+  T init() const { return T(values.begin(), values.end()); }
+
+  void run(T& x) const
+  {
+    x.swap(x);
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(x, this->values);
+    test::check_equivalent_keys(x);
+  }
+
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
+  {
+    std::string scope(test::scope);
+
+    // TODO: In C++11 exceptions are only allowed in the swap function.
+    BOOST_TEST(scope == "hash::hash(hash)" ||
+               scope == "hash::operator=(hash)" ||
+               scope == "equal_to::equal_to(equal_to)" ||
+               scope == "equal_to::operator=(equal_to)");
+
+    test::check_equivalent_keys(x);
+  }
+};
+
+template <class T> struct self_swap_test1 : self_swap_base<T>
+{
+};
+
+template <class T> struct self_swap_test2 : self_swap_base<T>
+{
+  self_swap_test2() : self_swap_base<T>(100) {}
+};
+
+template <class T> struct swap_base : public test::exception_base
+{
+  const test::random_values<T> x_values, y_values;
+  const T initial_x, initial_y;
+
+  typedef typename T::hasher hasher;
+  typedef typename T::key_equal key_equal;
+  typedef typename T::allocator_type allocator_type;
+
+  swap_base(unsigned int count1, unsigned int count2, int tag1, int tag2)
+      : x_values(count1, test::limited_range),
+        y_values(count2, test::limited_range),
+        initial_x(x_values.begin(), x_values.end(), 0, hasher(tag1),
+          key_equal(tag1), allocator_type(tag1)),
+        initial_y(y_values.begin(), y_values.end(), 0, hasher(tag2),
+          key_equal(tag2),
+          allocator_type(T::allocator_type::propagate_on_container_swap::value
+                           ? tag2
+                           : tag1))
+  {
+  }
+
+  struct data_type
+  {
+    data_type(T const& x_, T const& y_) : x(x_), y(y_) {}
+
+    T x, y;
+  };
+
+  data_type init() const { return data_type(initial_x, initial_y); }
+
+  void run(data_type& d) const
+  {
+    try {
+      d.x.swap(d.y);
+    } catch (std::runtime_error&) {
+    }
+
+    DISABLE_EXCEPTIONS;
+    test::check_container(d.x, this->y_values);
+    test::check_equivalent_keys(d.x);
+    test::check_container(d.y, this->x_values);
+    test::check_equivalent_keys(d.y);
+  }
+
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(data_type const& d) const
+  {
+    std::string scope(test::scope);
+
+    // TODO: In C++11 exceptions are only allowed in the swap function.
+    BOOST_TEST(scope == "hash::hash(hash)" ||
+               scope == "hash::operator=(hash)" ||
+               scope == "equal_to::equal_to(equal_to)" ||
+               scope == "equal_to::operator=(equal_to)");
+
+    test::check_equivalent_keys(d.x);
+    test::check_equivalent_keys(d.y);
+  }
+};
+
+template <class T> struct swap_test1 : swap_base<T>
+{
+  swap_test1() : swap_base<T>(0, 0, 0, 0) {}
+};
+
+template <class T> struct swap_test2 : swap_base<T>
+{
+  swap_test2() : swap_base<T>(60, 0, 0, 0) {}
+};
+
+template <class T> struct swap_test3 : swap_base<T>
+{
+  swap_test3() : swap_base<T>(0, 60, 0, 0) {}
+};
+
+template <class T> struct swap_test4 : swap_base<T>
+{
+  swap_test4() : swap_base<T>(10, 10, 1, 2) {}
+};
+
+// clang-format off
+EXCEPTION_TESTS(
+  (self_swap_test1)(self_swap_test2)
+  (swap_test1)(swap_test2)(swap_test3)(swap_test4),
+  CONTAINER_SEQ)
+// clang-format on
+
+RUN_TESTS()
diff --git a/src/boost/libs/unordered/test/helpers/check_return_type.hpp b/src/boost/libs/unordered/test/helpers/check_return_type.hpp
new file mode 100644
index 000000000..1c70a8c7f
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/check_return_type.hpp
@@ -0,0 +1,33 @@
+
+// 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_UNORDERED_TEST_HELPERS_CHECK_RETURN_TYPE_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_CHECK_RETURN_TYPE_HEADER
+
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace test {
+  template <class T1> struct check_return_type
+  {
+    template <class T2> static void equals(T2)
+    {
+      BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
+    }
+
+    template <class T2> static void equals_ref(T2&)
+    {
+      BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
+    }
+
+    template <class T2> static void convertible(T2)
+    {
+      BOOST_STATIC_ASSERT((boost::is_convertible<T2, T1>::value));
+    }
+  };
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/count.hpp b/src/boost/libs/unordered/test/helpers/count.hpp
new file mode 100644
index 000000000..90372dca3
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/count.hpp
@@ -0,0 +1,89 @@
+
+// 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)
+
+#if !defined(BOOST_UNORDERED_TEST_HELPERS_COUNT_HEAD)
+#define BOOST_UNORDERED_TEST_HELPERS_COUNT_HEAD
+
+#include <boost/core/lightweight_test.hpp>
+
+namespace test {
+  struct object_count
+  {
+    int instances;
+    int constructions;
+
+    object_count() : instances(0), constructions(0) {}
+    void reset() { *this = object_count(); }
+
+    void construct()
+    {
+      ++instances;
+      ++constructions;
+    }
+
+    void destruct()
+    {
+      if (instances == 0) {
+        BOOST_ERROR("Unbalanced constructions.");
+      } else {
+        --instances;
+      }
+    }
+
+    bool operator==(object_count const& x) const
+    {
+      return instances == x.instances && constructions == x.constructions;
+    }
+
+    bool operator!=(object_count const& x) const { return !(*this == x); }
+
+    friend std::ostream& operator<<(std::ostream& out, object_count const& c)
+    {
+      out << "[instances: " << c.instances
+          << ", constructions: " << c.constructions << "]";
+      return out;
+    }
+  };
+
+  // This won't be a problem as I'm only using a single compile unit
+  // in each test (this is actually require by the minimal test
+  // framework).
+  //
+  // boostinspect:nounnamed
+  namespace {
+    object_count global_object_count;
+  }
+
+  struct counted_object
+  {
+    counted_object() { global_object_count.construct(); }
+    counted_object(counted_object const&) { global_object_count.construct(); }
+    ~counted_object() { global_object_count.destruct(); }
+  };
+
+  struct check_instances
+  {
+    int instances_;
+    int constructions_;
+
+    check_instances()
+        : instances_(global_object_count.instances),
+          constructions_(global_object_count.constructions)
+    {
+    }
+    ~check_instances()
+    {
+      BOOST_TEST(global_object_count.instances == instances_);
+    }
+
+    int instances() const { return global_object_count.instances - instances_; }
+    int constructions() const
+    {
+      return global_object_count.constructions - constructions_;
+    }
+  };
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/equivalent.hpp b/src/boost/libs/unordered/test/helpers/equivalent.hpp
new file mode 100644
index 000000000..bd27d8df2
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/equivalent.hpp
@@ -0,0 +1,96 @@
+
+// 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_UNORDERED_TESTS_EQUIVALENT_HEADER)
+#define BOOST_UNORDERED_TESTS_EQUIVALENT_HEADER
+
+#include "./fwd.hpp"
+#include "./list.hpp"
+#include "./metafunctions.hpp"
+#include <algorithm>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+
+namespace test {
+  template <class T1, class T2>
+  bool equivalent_impl(T1 const& x, T2 const& y, base_type)
+  {
+    return x == y;
+  }
+
+  template <class T>
+  bool equivalent_impl(
+    boost::hash<T> const&, boost::hash<T> const&, derived_type)
+  {
+    return true;
+  }
+
+  template <class T>
+  bool equivalent_impl(
+    std::equal_to<T> const&, std::equal_to<T> const&, derived_type)
+  {
+    return true;
+  }
+
+  template <class T1, class T2, class T3, class T4>
+  bool equivalent_impl(
+    std::pair<T1, T2> const& x1, std::pair<T3, T4> const& x2, derived_type)
+  {
+    return equivalent_impl(x1.first, x2.first, derived) &&
+           equivalent_impl(x1.second, x2.second, derived);
+  }
+
+  struct equivalent_type
+  {
+    equivalent_type() {}
+
+    template <class T1, class T2>
+    bool operator()(T1 const& x, T2 const& y) const
+    {
+      return equivalent_impl(x, y, derived);
+    }
+  };
+
+  const equivalent_type equivalent;
+
+  template <class Container> class unordered_equivalence_tester
+  {
+    typename Container::size_type size_;
+    typename Container::hasher hasher_;
+    typename Container::key_equal key_equal_;
+    float max_load_factor_;
+
+    typedef test::list<typename Container::value_type> value_list;
+    value_list values_;
+
+  public:
+    unordered_equivalence_tester(Container const& x)
+        : size_(x.size()), hasher_(x.hash_function()), key_equal_(x.key_eq()),
+          max_load_factor_(x.max_load_factor()), values_(x.begin(), x.end())
+    {
+      values_.sort();
+    }
+
+    bool operator()(Container const& x) const
+    {
+      if (!((size_ == x.size()) &&
+            (test::equivalent(hasher_, x.hash_function())) &&
+            (test::equivalent(key_equal_, x.key_eq())) &&
+            (max_load_factor_ == x.max_load_factor()) &&
+            (values_.size() == x.size())))
+        return false;
+
+      value_list copy(x.begin(), x.end());
+      copy.sort();
+      return values_ == copy;
+    }
+
+  private:
+    unordered_equivalence_tester();
+  };
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/exception_test.hpp b/src/boost/libs/unordered/test/helpers/exception_test.hpp
new file mode 100644
index 000000000..8984eee9b
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/exception_test.hpp
@@ -0,0 +1,348 @@
+
+// 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)
+
+#if !defined(BOOST_UNORDERED_EXCEPTION_TEST_HEADER)
+#define BOOST_UNORDERED_EXCEPTION_TEST_HEADER
+
+#include "./count.hpp"
+#include "./test.hpp"
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/seq/elem.hpp>
+#include <boost/preprocessor/seq/for_each_product.hpp>
+
+#define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type)                   \
+  UNORDERED_AUTO_TEST (name) {                                                 \
+    test_func<type> fixture;                                                   \
+    ::test::lightweight::exception_safety(                                     \
+      fixture, BOOST_STRINGIZE(test_func<type>));                              \
+  }
+
+#define UNORDERED_EXCEPTION_TEST_CASE_REPEAT(name, test_func, n, type)         \
+  UNORDERED_AUTO_TEST (name) {                                                 \
+    for (unsigned i = 0; i < n; ++i) {                                         \
+      test_func<type> fixture;                                                 \
+      ::test::lightweight::exception_safety(                                   \
+        fixture, BOOST_STRINGIZE(test_func<type>));                            \
+    }                                                                          \
+  }
+
+#define UNORDERED_EPOINT_IMPL ::test::lightweight::epoint
+
+#define UNORDERED_EXCEPTION_TEST_POSTFIX RUN_TESTS()
+
+#define EXCEPTION_TESTS(test_seq, param_seq)                                   \
+  BOOST_PP_SEQ_FOR_EACH_PRODUCT(EXCEPTION_TESTS_OP, (test_seq)((1))(param_seq))
+
+#define EXCEPTION_TESTS_REPEAT(n, test_seq, param_seq)                         \
+  BOOST_PP_SEQ_FOR_EACH_PRODUCT(EXCEPTION_TESTS_OP, (test_seq)((n))(param_seq))
+
+#define EXCEPTION_TESTS_OP(r, product)                                         \
+  UNORDERED_EXCEPTION_TEST_CASE_REPEAT(                                        \
+    BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, product),                                \
+      BOOST_PP_CAT(_, BOOST_PP_SEQ_ELEM(2, product))),                         \
+    BOOST_PP_SEQ_ELEM(0, product), BOOST_PP_SEQ_ELEM(1, product),              \
+    BOOST_PP_SEQ_ELEM(2, product))
+
+#define UNORDERED_SCOPE(scope_name)                                            \
+  for (::test::scope_guard unordered_test_guard(BOOST_STRINGIZE(scope_name));  \
+       !unordered_test_guard.dismissed(); unordered_test_guard.dismiss())
+
+#define UNORDERED_EPOINT(name)                                                 \
+  if (::test::exceptions_enabled) {                                            \
+    UNORDERED_EPOINT_IMPL(name);                                               \
+  }
+
+#define ENABLE_EXCEPTIONS                                                      \
+  ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(true)
+
+#define DISABLE_EXCEPTIONS                                                     \
+  ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(false)
+
+namespace test {
+  static char const* scope = "";
+  bool exceptions_enabled = false;
+
+  class scope_guard
+  {
+    scope_guard& operator=(scope_guard const&);
+    scope_guard(scope_guard const&);
+
+    char const* old_scope_;
+    char const* scope_;
+    bool dismissed_;
+
+  public:
+    scope_guard(char const* name)
+        : old_scope_(scope), scope_(name), dismissed_(false)
+    {
+      scope = scope_;
+    }
+
+    ~scope_guard()
+    {
+      if (dismissed_)
+        scope = old_scope_;
+    }
+
+    void dismiss() { dismissed_ = true; }
+
+    bool dismissed() const { return dismissed_; }
+  };
+
+  class exceptions_enable
+  {
+    exceptions_enable& operator=(exceptions_enable const&);
+    exceptions_enable(exceptions_enable const&);
+
+    bool old_value_;
+    bool released_;
+
+  public:
+    exceptions_enable(bool enable)
+        : old_value_(exceptions_enabled), released_(false)
+    {
+      exceptions_enabled = enable;
+    }
+
+    ~exceptions_enable()
+    {
+      if (!released_) {
+        exceptions_enabled = old_value_;
+        released_ = true;
+      }
+    }
+
+    void release()
+    {
+      if (!released_) {
+        exceptions_enabled = old_value_;
+        released_ = true;
+      }
+    }
+  };
+
+  struct exception_base
+  {
+    struct data_type
+    {
+    };
+    struct strong_type
+    {
+      template <class T> void store(T const&) {}
+      template <class T> void test(T const&) const {}
+    };
+    data_type init() const { return data_type(); }
+    void check BOOST_PREVENT_MACRO_SUBSTITUTION() const {}
+  };
+
+  template <class T, class P1, class P2, class T2>
+  inline void call_ignore_extra_parameters(
+    void (T::*fn)() const, T2 const& obj, P1&, P2&)
+  {
+    (obj.*fn)();
+  }
+
+  template <class T, class P1, class P2, class T2>
+  inline void call_ignore_extra_parameters(
+    void (T::*fn)(P1&) const, T2 const& obj, P1& p1, P2&)
+  {
+    (obj.*fn)(p1);
+  }
+
+  template <class T, class P1, class P2, class T2>
+  inline void call_ignore_extra_parameters(
+    void (T::*fn)(P1&, P2&) const, T2 const& obj, P1& p1, P2& p2)
+  {
+    (obj.*fn)(p1, p2);
+  }
+
+  template <class T> T const& constant(T const& x) { return x; }
+
+  template <class Test> class test_runner
+  {
+    Test const& test_;
+    bool exception_in_check_;
+
+    test_runner(test_runner const&);
+    test_runner& operator=(test_runner const&);
+
+  public:
+    test_runner(Test const& t) : test_(t), exception_in_check_(false) {}
+    void run()
+    {
+      DISABLE_EXCEPTIONS;
+      test::check_instances check;
+      test::scope = "";
+      typename Test::data_type x(test_.init());
+      typename Test::strong_type strong;
+      strong.store(x);
+      try {
+        ENABLE_EXCEPTIONS;
+        call_ignore_extra_parameters<Test, typename Test::data_type,
+          typename Test::strong_type>(&Test::run, test_, x, strong);
+      } catch (...) {
+        try {
+          DISABLE_EXCEPTIONS;
+          call_ignore_extra_parameters<Test, typename Test::data_type const,
+            typename Test::strong_type const>(
+            &Test::check, test_, constant(x), constant(strong));
+        } catch (...) {
+          exception_in_check_ = true;
+        }
+        throw;
+      }
+    }
+    void end()
+    {
+      if (exception_in_check_) {
+        BOOST_ERROR("Unexcpected exception in test_runner check call.");
+      }
+    }
+  };
+
+  // Quick exception testing based on lightweight test
+
+  namespace lightweight {
+    static int iteration;
+    static int count;
+
+    struct test_exception
+    {
+      char const* name;
+      test_exception(char const* n) : name(n) {}
+    };
+
+    struct test_failure
+    {
+    };
+
+    void epoint(char const* name)
+    {
+      ++count;
+      if (count == iteration) {
+        throw test_exception(name);
+      }
+    }
+
+    template <class Test>
+    void exception_safety(Test const& f, char const* /*name*/)
+    {
+      test_runner<Test> runner(f);
+
+      iteration = 0;
+      bool success = false;
+      unsigned int failure_count = 0;
+      char const* error_msg = 0;
+      do {
+        int error_count = boost::detail::test_errors();
+        ++iteration;
+        count = 0;
+
+        try {
+          runner.run();
+          success = true;
+        } catch (test_failure) {
+          error_msg = "test_failure caught.";
+          break;
+        } catch (test_exception e) {
+          if (error_count != boost::detail::test_errors()) {
+            BOOST_LIGHTWEIGHT_TEST_OSTREAM
+              << "Iteration: " << iteration
+              << " Error found for epoint: " << e.name << std::endl;
+          }
+        } catch (...) {
+          error_msg = "Unexpected exception.";
+          break;
+        }
+
+        if (error_count != boost::detail::test_errors()) {
+          ++failure_count;
+        }
+      } while (!success && failure_count < 5);
+
+      if (error_msg) {
+        BOOST_ERROR(error_msg);
+      }
+      runner.end();
+    }
+
+    //
+    // An alternative way to run exception tests.
+    // See merge_exception_tests.cpp for an example.
+
+    struct exception_looper
+    {
+      bool success;
+      unsigned int failure_count;
+      char const* error_msg;
+      int error_count;
+
+      exception_looper() : success(false), failure_count(0), error_msg(0) {}
+
+      void start() { iteration = 0; }
+
+      bool loop_condition() const
+      {
+        return !error_msg && !success && failure_count < 5;
+      }
+
+      void start_iteration()
+      {
+        error_count = boost::detail::test_errors();
+        ++iteration;
+        count = 0;
+      }
+
+      void successful_run() { success = true; }
+
+      void test_failure_caught(test_failure const&)
+      {
+        error_msg = "test_failure caught.";
+      }
+
+      void test_exception_caught(test_exception const& e)
+      {
+        if (error_count != boost::detail::test_errors()) {
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << "Iteration: " << iteration
+            << " Error found for epoint: " << e.name << std::endl;
+        }
+      }
+
+      void unexpected_exception_caught()
+      {
+        error_msg = "Unexpected exception.";
+      }
+
+      void end()
+      {
+        if (error_msg) {
+          BOOST_ERROR(error_msg);
+        }
+      }
+    };
+
+#define EXCEPTION_LOOP(op)                                                     \
+  test::lightweight::exception_looper looper;                                  \
+  looper.start();                                                              \
+  while (looper.loop_condition()) {                                            \
+    looper.start_iteration();                                                  \
+    try {                                                                      \
+      op;                                                                      \
+      looper.successful_run();                                                 \
+    } catch (test::lightweight::test_failure e) {                              \
+      looper.test_failure_caught(e);                                           \
+    } catch (test::lightweight::test_exception e) {                            \
+      looper.test_exception_caught(e);                                         \
+    } catch (...) {                                                            \
+      looper.unexpected_exception_caught();                                    \
+    }                                                                          \
+  }                                                                            \
+  looper.end();
+  }
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/fwd.hpp b/src/boost/libs/unordered/test/helpers/fwd.hpp
new file mode 100644
index 000000000..a5657e018
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/fwd.hpp
@@ -0,0 +1,32 @@
+
+// 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)
+
+#if !defined(BOOST_UNORDERED_TEST_HELPERS_FWD_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_FWD_HEADER
+
+#include <string>
+
+namespace test {
+  typedef enum {
+    default_generator,
+    generate_collisions,
+    limited_range
+  } random_generator;
+
+  int generate(int const*, random_generator);
+  char generate(char const*, random_generator);
+  signed char generate(signed char const*, random_generator);
+  std::string generate(std::string const*, random_generator);
+  float generate(float const*, random_generator);
+
+  struct base_type
+  {
+  } base;
+  struct derived_type : base_type
+  {
+  } derived;
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/generators.hpp b/src/boost/libs/unordered/test/helpers/generators.hpp
new file mode 100644
index 000000000..c9ed42bdd
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/generators.hpp
@@ -0,0 +1,93 @@
+
+// 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)
+
+// This uses std::rand to generate random values for tests.
+// Which is not good as different platforms will be running different tests.
+// It would be much better to use Boost.Random, but it doesn't
+// support all the compilers that I want to test on.
+
+#if !defined(BOOST_UNORDERED_TEST_HELPERS_GENERATORS_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_GENERATORS_HEADER
+
+#include "./fwd.hpp"
+#include <boost/type_traits/add_const.hpp>
+#include <cstdlib>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+namespace test {
+  struct seed_t
+  {
+    seed_t(unsigned int x)
+    {
+      using namespace std;
+      srand(x);
+    }
+  };
+
+  std::size_t random_value(std::size_t max)
+  {
+    using namespace std;
+    return static_cast<std::size_t>(rand()) % max;
+  }
+
+  inline int generate(int const*, random_generator g)
+  {
+    using namespace std;
+    int value = rand();
+    if (g == limited_range) {
+      value = value % 100;
+    }
+    return value;
+  }
+
+  inline char generate(char const*, random_generator)
+  {
+    using namespace std;
+    return static_cast<char>((rand() >> 1) % (128 - 32) + 32);
+  }
+
+  inline signed char generate(signed char const*, random_generator)
+  {
+    using namespace std;
+    return static_cast<signed char>(rand());
+  }
+
+  inline std::string generate(std::string const*, random_generator g)
+  {
+    using namespace std;
+
+    char* char_ptr = 0;
+
+    std::string result;
+
+    if (g == limited_range) {
+      std::size_t length = test::random_value(2) + 2;
+
+      char const* strings[] = {"'vZh(3~ms", "%m", "_Y%U", "N'Y", "4,J_J"};
+      for (std::size_t i = 0; i < length; ++i) {
+        result += strings[random_value(sizeof(strings) / sizeof(strings[0]))];
+      }
+    } else {
+      std::size_t length = test::random_value(10) + 1;
+      for (std::size_t i = 0; i < length; ++i) {
+        result += generate(char_ptr, g);
+      }
+    }
+
+    return result;
+  }
+
+  float generate(float const*, random_generator g)
+  {
+    using namespace std;
+    int x = 0;
+    int value = generate(&x, g);
+    return (float)value / (float)RAND_MAX;
+  }
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/helpers.hpp b/src/boost/libs/unordered/test/helpers/helpers.hpp
new file mode 100644
index 000000000..146dea4df
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/helpers.hpp
@@ -0,0 +1,56 @@
+
+// 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)
+
+#if !defined(BOOST_UNORDERED_TEST_HELPERS_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_HEADER
+
+#include <iterator>
+
+namespace test {
+  template <class Container> struct get_key_impl
+  {
+    typedef typename Container::key_type key_type;
+
+    static key_type const& get_key(key_type const& x) { return x; }
+
+    template <class T>
+    static key_type const& get_key(std::pair<key_type, T> const& x, char = 0)
+    {
+      return x.first;
+    }
+
+    template <class T>
+    static key_type const& get_key(
+      std::pair<key_type const, T> const& x, unsigned char = 0)
+    {
+      return x.first;
+    }
+  };
+
+  template <class Container, class T>
+  inline typename Container::key_type const& get_key(T const& x)
+  {
+    return get_key_impl<Container>::get_key(x);
+  }
+
+  // test::next
+  //
+  // Increments an iterator by 1 or a given value.
+  // Like boost::next, but simpler.
+  // Mainly because boost::next uses an MPL file
+  // which causes warnings.
+
+  template <typename Iterator> Iterator next(Iterator it) { return ++it; }
+
+  template <typename Iterator, typename IntType>
+  Iterator next(Iterator it, IntType x)
+  {
+    std::advance(it,
+      static_cast<typename std::iterator_traits<Iterator>::difference_type>(x));
+    return it;
+  }
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/input_iterator.hpp b/src/boost/libs/unordered/test/helpers/input_iterator.hpp
new file mode 100644
index 000000000..7a938a50f
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/input_iterator.hpp
@@ -0,0 +1,165 @@
+
+// Copyright 2005-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)
+
+#if !defined(BOOST_UNORDERED_TEST_HELPERS_INPUT_ITERATOR_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_INPUT_ITERATOR_HEADER
+
+#include <boost/config.hpp>
+#include <iterator>
+
+namespace test {
+  template <class Iterator> struct proxy
+  {
+    typedef typename Iterator::value_type value_type;
+
+    explicit proxy(value_type const& v) : v_(v) {}
+    proxy(proxy const& x) : v_(x.v_) {}
+    operator value_type const&() const { return v_; }
+
+    value_type v_;
+
+  private:
+    proxy& operator=(proxy const&);
+  };
+
+  template <class Iterator> struct input_iterator_adaptor
+  {
+    typedef typename std::iterator_traits<Iterator>::value_type value_type;
+    typedef typename std::iterator_traits<Iterator>::pointer pointer;
+    typedef proxy<Iterator> reference;
+    typedef std::ptrdiff_t difference_type;
+    typedef std::input_iterator_tag iterator_category;
+
+    input_iterator_adaptor() : base_() {}
+    explicit input_iterator_adaptor(Iterator& it) : base_(&it) {}
+    proxy<Iterator> operator*() const { return proxy<Iterator>(**base_); }
+    value_type* operator->() const { return &**base_; }
+    input_iterator_adaptor& operator++()
+    {
+      ++*base_;
+      return *this;
+    }
+    // input_iterator_adaptor operator++(int) {
+    //}
+    bool operator==(input_iterator_adaptor const& x) const
+    {
+      return *base_ == *x.base_;
+    }
+    bool operator!=(input_iterator_adaptor const& x) const
+    {
+      return *base_ != *x.base_;
+    }
+
+  private:
+    Iterator* base_;
+  };
+
+  template <class Iterator>
+  input_iterator_adaptor<Iterator> input_iterator(Iterator& it)
+  {
+    return input_iterator_adaptor<Iterator>(it);
+  }
+
+  template <class Iterator> struct copy_iterator_adaptor
+  {
+    typedef typename std::iterator_traits<Iterator>::value_type value_type;
+    typedef
+      typename std::iterator_traits<Iterator>::difference_type difference_type;
+    typedef typename std::iterator_traits<Iterator>::iterator_category
+      iterator_category;
+    typedef typename std::iterator_traits<Iterator>::pointer pointer;
+    typedef proxy<Iterator> reference;
+
+    copy_iterator_adaptor() : base_() {}
+    explicit copy_iterator_adaptor(Iterator const& it) : base_(it) {}
+    value_type operator*() const { return *base_; }
+    value_type* operator->() const { return &*base_; }
+    value_type operator[](difference_type d) { return base_[d]; }
+    copy_iterator_adaptor& operator++()
+    {
+      ++base_;
+      return *this;
+    }
+    copy_iterator_adaptor operator++(int)
+    {
+      copy_iterator_adaptor tmp(*this);
+      ++base_;
+      return tmp;
+    }
+    copy_iterator_adaptor& operator--()
+    {
+      --base_;
+      return *this;
+    }
+    copy_iterator_adaptor operator--(int)
+    {
+      copy_iterator_adaptor tmp(*this);
+      --base_;
+      return tmp;
+    }
+    copy_iterator_adaptor operator+=(difference_type x)
+    {
+      base_ += x;
+      return *this;
+    }
+    copy_iterator_adaptor operator-=(difference_type x)
+    {
+      base_ -= x;
+      return *this;
+    }
+    copy_iterator_adaptor operator+(difference_type n)
+    {
+      return copy_iterator_adaptor(base_ + n);
+    }
+    copy_iterator_adaptor operator-(difference_type n)
+    {
+      return copy_iterator_adaptor(base_ - n);
+    }
+    friend copy_iterator_adaptor operator+(
+      difference_type n, copy_iterator_adaptor x)
+    {
+      return x + n;
+    }
+    difference_type operator-(copy_iterator_adaptor const& other)
+    {
+      return base_ - other.base_;
+    }
+    bool operator==(copy_iterator_adaptor const& x) const
+    {
+      return base_ == x.base_;
+    }
+    bool operator!=(copy_iterator_adaptor const& x) const
+    {
+      return base_ != x.base_;
+    }
+    bool operator<(copy_iterator_adaptor const& x) const
+    {
+      return base_ < x.base_;
+    }
+    bool operator>(copy_iterator_adaptor const& x) const
+    {
+      return base_ > x.base_;
+    }
+    bool operator<=(copy_iterator_adaptor const& x) const
+    {
+      return base_ <= x.base_;
+    }
+    bool operator>=(copy_iterator_adaptor const& x) const
+    {
+      return base_ >= x.base_;
+    }
+
+  private:
+    Iterator base_;
+  };
+
+  template <class Iterator>
+  copy_iterator_adaptor<Iterator> copy_iterator(Iterator const& it)
+  {
+    return copy_iterator_adaptor<Iterator>(it);
+  }
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/invariants.hpp b/src/boost/libs/unordered/test/helpers/invariants.hpp
new file mode 100644
index 000000000..a555da60c
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/invariants.hpp
@@ -0,0 +1,130 @@
+
+// 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 header contains metafunctions/functions to get the equivalent
+// associative container for an unordered container, and compare the contents.
+
+#if !defined(BOOST_UNORDERED_TEST_HELPERS_INVARIANT_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_INVARIANT_HEADER
+
+#include "./helpers.hpp"
+#include "./metafunctions.hpp"
+#include <cmath>
+#include <set>
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable : 4127) // conditional expression is constant
+#pragma warning(disable : 4267) // conversion from 'size_t' to 'unsigned int',
+                                // possible loss of data
+#endif
+
+namespace test {
+  template <class X> void check_equivalent_keys(X const& x1)
+  {
+    typename X::key_equal eq = x1.key_eq();
+    typedef typename X::key_type key_type;
+    std::set<key_type, std::less<key_type> > found_;
+
+    typename X::const_iterator it = x1.begin(), end = x1.end();
+    typename X::size_type size = 0;
+    while (it != end) {
+      // First test that the current key has not occurred before, required
+      // to test either that keys are unique or that equivalent keys are
+      // adjacent. (6.3.1/6)
+      key_type key = get_key<X>(*it);
+      if (!found_.insert(key).second)
+        BOOST_ERROR("Elements with equivalent keys aren't adjacent.");
+
+      // Iterate over equivalent keys, counting them.
+      unsigned int count = 0;
+      do {
+        ++it;
+        ++count;
+        ++size;
+      } while (it != end && eq(get_key<X>(*it), key));
+
+      // If the container has unique keys, test that there's only one.
+      // Since the previous test makes sure that all equivalent keys are
+      // adjacent, this is all the equivalent keys - so the test is
+      // sufficient. (6.3.1/6 again).
+      if (test::has_unique_keys<X>::value && count != 1)
+        BOOST_ERROR("Non-unique key.");
+
+      if (x1.count(key) != count) {
+        BOOST_ERROR("Incorrect output of count.");
+        std::cerr << x1.count(key) << "," << count << "\n";
+      }
+
+      // Check that the keys are in the correct bucket and are
+      // adjacent in the bucket.
+      typename X::size_type bucket = x1.bucket(key);
+      typename X::const_local_iterator lit = x1.begin(bucket),
+                                       lend = x1.end(bucket);
+
+      unsigned int count_checked = 0;
+      for (; lit != lend && !eq(get_key<X>(*lit), key); ++lit) {
+        ++count_checked;
+      }
+
+      if (lit == lend) {
+        BOOST_ERROR("Unable to find element with a local_iterator");
+        std::cerr << "Checked: " << count_checked << " elements" << std::endl;
+      } else {
+        unsigned int count2 = 0;
+        for (; lit != lend && eq(get_key<X>(*lit), key); ++lit)
+          ++count2;
+        if (count != count2)
+          BOOST_ERROR("Element count doesn't match local_iterator.");
+        for (; lit != lend; ++lit) {
+          if (eq(get_key<X>(*lit), key)) {
+            BOOST_ERROR("Non-adjacent element with equivalent key "
+                        "in bucket.");
+            break;
+          }
+        }
+      }
+    };
+
+    // Check that size matches up.
+
+    if (x1.size() != size) {
+      BOOST_ERROR("x1.size() doesn't match actual size.");
+      std::cout << x1.size() << "/" << size << std::endl;
+    }
+
+    // Check the load factor.
+
+    float load_factor = size == 0 ? 0
+                                  : static_cast<float>(size) /
+                                      static_cast<float>(x1.bucket_count());
+    using namespace std;
+    if (fabs(x1.load_factor() - load_factor) > x1.load_factor() / 64)
+      BOOST_ERROR("x1.load_factor() doesn't match actual load_factor.");
+
+    // Check that size in the buckets matches up.
+
+    typename X::size_type bucket_size = 0;
+
+    for (typename X::size_type i = 0; i < x1.bucket_count(); ++i) {
+      for (typename X::const_local_iterator begin2 = x1.begin(i),
+                                            end2 = x1.end(i);
+           begin2 != end2; ++begin2) {
+        ++bucket_size;
+      }
+    }
+
+    if (x1.size() != bucket_size) {
+      BOOST_ERROR("x1.size() doesn't match bucket size.");
+      std::cout << x1.size() << "/" << bucket_size << std::endl;
+    }
+  }
+}
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/list.hpp b/src/boost/libs/unordered/test/helpers/list.hpp
new file mode 100644
index 000000000..d39c766e7
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/list.hpp
@@ -0,0 +1,327 @@
+
+// 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)
+
+// Gratuitous single linked list.
+//
+// Sadly some STL implementations aren't up to scratch and I need a simple
+// cross-platform container. So here it is.
+
+#if !defined(UNORDERED_TEST_LIST_HEADER)
+#define UNORDERED_TEST_LIST_HEADER
+
+#include <boost/limits.hpp>
+#include <functional>
+#include <iterator>
+
+namespace test {
+  template <typename It1, typename It2>
+  bool equal(It1 begin, It1 end, It2 compare)
+  {
+    for (; begin != end; ++begin, ++compare)
+      if (*begin != *compare)
+        return false;
+    return true;
+  }
+
+  template <typename It1, typename It2, typename Pred>
+  bool equal(It1 begin, It1 end, It2 compare, Pred predicate)
+  {
+    for (; begin != end; ++begin, ++compare)
+      if (!predicate(*begin, *compare))
+        return false;
+    return true;
+  }
+
+  template <typename T> class list;
+
+  namespace test_detail {
+    template <typename T> class list_node;
+    template <typename T> class list_data;
+    template <typename T> class list_iterator;
+    template <typename T> class list_const_iterator;
+
+    template <typename T> class list_node
+    {
+      list_node(list_node const&);
+      list_node& operator=(list_node const&);
+
+    public:
+      T value_;
+      list_node* next_;
+
+      list_node(T const& v) : value_(v), next_(0) {}
+      list_node(T const& v, list_node* n) : value_(v), next_(n) {}
+    };
+
+    template <typename T> class list_data
+    {
+    public:
+      typedef list_node<T> node;
+      typedef unsigned int size_type;
+
+      node* first_;
+      node** last_ptr_;
+      size_type size_;
+
+      list_data() : first_(0), last_ptr_(&first_), size_(0) {}
+
+      ~list_data()
+      {
+        while (first_) {
+          node* tmp = first_;
+          first_ = first_->next_;
+          delete tmp;
+        }
+      }
+
+    private:
+      list_data(list_data const&);
+      list_data& operator=(list_data const&);
+    };
+
+    template <typename T> class list_iterator
+    {
+      friend class list_const_iterator<T>;
+      friend class test::list<T>;
+      typedef list_node<T> node;
+      typedef list_const_iterator<T> const_iterator;
+
+      node* ptr_;
+
+    public:
+      typedef T value_type;
+      typedef T* pointer;
+      typedef T& reference;
+      typedef int difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+
+      list_iterator() : ptr_(0) {}
+      explicit list_iterator(node* x) : ptr_(x) {}
+
+      T& operator*() const { return ptr_->value_; }
+      T* operator->() const { return &ptr_->value_; }
+      list_iterator& operator++()
+      {
+        ptr_ = ptr_->next_;
+        return *this;
+      }
+      list_iterator operator++(int)
+      {
+        list_iterator tmp = *this;
+        ptr_ = ptr_->next_;
+        return tmp;
+      }
+      bool operator==(const_iterator y) const { return ptr_ == y.ptr_; }
+      bool operator!=(const_iterator y) const { return ptr_ != y.ptr_; }
+    };
+
+    template <typename T> class list_const_iterator
+    {
+      friend class list_iterator<T>;
+      friend class test::list<T>;
+      typedef list_node<T> node;
+      typedef list_iterator<T> iterator;
+      typedef list_const_iterator<T> const_iterator;
+
+      node* ptr_;
+
+    public:
+      typedef T value_type;
+      typedef T const* pointer;
+      typedef T const& reference;
+      typedef int difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+
+      list_const_iterator() : ptr_(0) {}
+      list_const_iterator(list_iterator<T> const& x) : ptr_(x.ptr_) {}
+
+      T const& operator*() const { return ptr_->value_; }
+      T const* operator->() const { return &ptr_->value_; }
+
+      list_const_iterator& operator++()
+      {
+        ptr_ = ptr_->next_;
+        return *this;
+      }
+
+      list_const_iterator operator++(int)
+      {
+        list_const_iterator tmp = *this;
+        ptr_ = ptr_->next_;
+        return tmp;
+      }
+
+      bool operator==(const_iterator y) const { return ptr_ == y.ptr_; }
+
+      bool operator!=(const_iterator y) const { return ptr_ != y.ptr_; }
+    };
+  }
+
+  template <typename T> class list
+  {
+    typedef test::test_detail::list_data<T> data;
+    typedef test::test_detail::list_node<T> node;
+    data data_;
+
+  public:
+    typedef T value_type;
+    typedef value_type& reference;
+    typedef value_type const& const_reference;
+    typedef unsigned int size_type;
+
+    typedef test::test_detail::list_iterator<T> iterator;
+    typedef test::test_detail::list_const_iterator<T> const_iterator;
+
+    list() : data_() {}
+
+    list(list const& other) : data_() { insert(other.begin(), other.end()); }
+
+    template <class InputIterator>
+    list(InputIterator i, InputIterator j) : data_()
+    {
+      insert(i, j);
+    }
+
+    list& operator=(list const& other)
+    {
+      clear();
+      insert(other.begin(), other.end());
+      return *this;
+    }
+
+    iterator begin() { return iterator(data_.first_); }
+    iterator end() { return iterator(); }
+    const_iterator begin() const { return iterator(data_.first_); }
+    const_iterator end() const { return iterator(); }
+    const_iterator cbegin() const { return iterator(data_.first_); }
+    const_iterator cend() const { return iterator(); }
+
+    template <class InputIterator> void insert(InputIterator i, InputIterator j)
+    {
+      for (; i != j; ++i)
+        push_back(*i);
+    }
+
+    void push_front(value_type const& v)
+    {
+      data_.first_ = new node(v, data_.first_);
+      if (!data_.size_)
+        data_.last_ptr_ = &(*data_.last_ptr_)->next_;
+      ++data_.size_;
+    }
+
+    void push_back(value_type const& v)
+    {
+      *data_.last_ptr_ = new node(v);
+      data_.last_ptr_ = &(*data_.last_ptr_)->next_;
+      ++data_.size_;
+    }
+
+    void clear()
+    {
+      while (data_.first_) {
+        node* tmp = data_.first_;
+        data_.first_ = data_.first_->next_;
+        --data_.size_;
+        delete tmp;
+      }
+      data_.last_ptr_ = &data_.first_;
+    }
+
+    void erase(const_iterator i, const_iterator j)
+    {
+      node** ptr = &data_.first_;
+
+      while (*ptr != i.ptr_) {
+        ptr = &(*ptr)->next_;
+      }
+
+      while (*ptr != j.ptr_) {
+        node* to_delete = *ptr;
+        *ptr = (*ptr)->next_;
+        --data_.size_;
+        delete to_delete;
+      }
+
+      if (!*ptr)
+        data_.last_ptr_ = ptr;
+    }
+
+    bool empty() const { return !data_.size_; }
+
+    size_type size() const { return data_.size_; }
+
+    void sort() { sort(std::less<T>()); }
+
+    template <typename Less> void sort(Less less = Less())
+    {
+      if (!empty())
+        merge_sort(
+          &data_.first_, (std::numeric_limits<size_type>::max)(), less);
+    }
+
+    bool operator==(list const& y) const
+    {
+      return size() == y.size() && test::equal(begin(), end(), y.begin());
+    }
+
+    bool operator!=(list const& y) const { return !(*this == y); }
+
+  private:
+    template <typename Less>
+    node** merge_sort(node** l, size_type recurse_limit, Less less)
+    {
+      node** ptr = &(*l)->next_;
+      for (size_type count = 0; count < recurse_limit && *ptr; ++count) {
+        ptr = merge_adjacent_ranges(l, ptr, merge_sort(ptr, count, less), less);
+      }
+      return ptr;
+    }
+
+    template <typename Less>
+    node** merge_adjacent_ranges(
+      node** first, node** second, node** third, Less less)
+    {
+      for (;;) {
+        for (;;) {
+          if (first == second)
+            return third;
+          if (less((*second)->value_, (*first)->value_))
+            break;
+          first = &(*first)->next_;
+        }
+
+        swap_adjacent_ranges(first, second, third);
+        first = &(*first)->next_;
+
+        // Since the two ranges we just swapped, the order is now:
+        // first...third...second
+
+        for (;;) {
+          if (first == third)
+            return second;
+          if (!less((*first)->value_, (*third)->value_))
+            break;
+          first = &(*first)->next_;
+        }
+
+        swap_adjacent_ranges(first, third, second);
+        first = &(*first)->next_;
+      }
+    }
+
+    void swap_adjacent_ranges(node** first, node** second, node** third)
+    {
+      node* tmp = *first;
+      *first = *second;
+      *second = *third;
+      *third = tmp;
+      if (!*second)
+        data_.last_ptr_ = second;
+    }
+  };
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/memory.hpp b/src/boost/libs/unordered/test/helpers/memory.hpp
new file mode 100644
index 000000000..22946cc25
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/memory.hpp
@@ -0,0 +1,189 @@
+
+// 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)
+
+#if !defined(BOOST_UNORDERED_TEST_MEMORY_HEADER)
+#define BOOST_UNORDERED_TEST_MEMORY_HEADER
+
+#include "../helpers/test.hpp"
+#include <boost/assert.hpp>
+#include <boost/unordered/detail/implementation.hpp>
+#include <map>
+#include <memory>
+
+namespace test {
+  namespace detail {
+    struct memory_area
+    {
+      void const* start;
+      void const* end;
+
+      memory_area(void const* s, void const* e) : start(s), end(e)
+      {
+        BOOST_ASSERT(start != end);
+      }
+    };
+
+    struct memory_track
+    {
+      explicit memory_track(int tag = -1) : constructed_(0), tag_(tag) {}
+
+      int constructed_;
+      int tag_;
+    };
+
+    // This is a bit dodgy as it defines overlapping
+    // areas as 'equal', so this isn't a total ordering.
+    // But it is for non-overlapping memory regions - which
+    // is what'll be stored.
+    //
+    // All searches will be for areas entirely contained by
+    // a member of the set - so it should find the area that contains
+    // the region that is searched for.
+
+    struct memory_area_compare
+    {
+      bool operator()(memory_area const& x, memory_area const& y) const
+      {
+        return x.end <= y.start;
+      }
+    };
+
+    struct memory_tracker
+    {
+      typedef std::map<memory_area, memory_track, memory_area_compare,
+        std::allocator<std::pair<memory_area const, memory_track> > >
+        allocated_memory_type;
+
+      allocated_memory_type allocated_memory;
+      unsigned int count_allocators;
+      unsigned int count_allocations;
+      unsigned int count_constructions;
+      bool tracking_constructions;
+
+      memory_tracker()
+          : count_allocators(0), count_allocations(0), count_constructions(0),
+            tracking_constructions(true)
+      {
+      }
+
+      ~memory_tracker() { BOOST_TEST(count_allocators == 0); }
+
+      void allocator_ref()
+      {
+        if (count_allocators == 0) {
+          count_allocations = 0;
+          count_constructions = 0;
+          allocated_memory.clear();
+        }
+        ++count_allocators;
+      }
+
+      void allocator_unref()
+      {
+        BOOST_TEST(count_allocators > 0);
+        if (count_allocators > 0) {
+          --count_allocators;
+          if (count_allocators == 0) {
+            bool no_allocations_left = (count_allocations == 0);
+            bool no_constructions_left = (count_constructions == 0);
+            bool allocated_memory_empty = allocated_memory.empty();
+
+            // Clearing the data before the checks terminate the
+            // tests.
+            count_allocations = 0;
+            count_constructions = 0;
+            allocated_memory.clear();
+
+            BOOST_TEST(no_allocations_left);
+            BOOST_TEST(no_constructions_left);
+            BOOST_TEST(allocated_memory_empty);
+          }
+        }
+      }
+
+      void track_allocate(void* ptr, std::size_t n, std::size_t size, int tag)
+      {
+        if (n == 0) {
+          BOOST_ERROR("Allocating 0 length array.");
+        } else {
+          ++count_allocations;
+          allocated_memory.insert(std::pair<memory_area const, memory_track>(
+            memory_area(ptr, (char*)ptr + n * size), memory_track(tag)));
+        }
+      }
+
+      void track_deallocate(void* ptr, std::size_t n, std::size_t size, int tag,
+        bool check_tag_ = true)
+      {
+        allocated_memory_type::iterator pos =
+          allocated_memory.find(memory_area(ptr, (char*)ptr + n * size));
+        if (pos == allocated_memory.end()) {
+          BOOST_ERROR("Deallocating unknown pointer.");
+        } else {
+          BOOST_TEST(pos->first.start == ptr);
+          BOOST_TEST(pos->first.end == (char*)ptr + n * size);
+          if (check_tag_)
+            BOOST_TEST(pos->second.tag_ == tag);
+          allocated_memory.erase(pos);
+        }
+        BOOST_TEST(count_allocations > 0);
+        if (count_allocations > 0)
+          --count_allocations;
+      }
+
+      void track_construct(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
+      {
+        if (tracking_constructions) {
+          ++count_constructions;
+        }
+      }
+
+      void track_destroy(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
+      {
+        if (tracking_constructions) {
+          BOOST_TEST(count_constructions > 0);
+          if (count_constructions > 0)
+            --count_constructions;
+        }
+      }
+    };
+  }
+
+  namespace detail {
+    // This won't be a problem as I'm only using a single compile unit
+    // in each test (this is actually required by the minimal test
+    // framework).
+    //
+    // boostinspect:nounnamed
+    namespace {
+      test::detail::memory_tracker tracker;
+    }
+  }
+
+  namespace detail {
+    struct disable_construction_tracking
+    {
+      bool old_value;
+
+      disable_construction_tracking()
+          : old_value(detail::tracker.tracking_constructions)
+      {
+        test::detail::tracker.tracking_constructions = false;
+      }
+
+      ~disable_construction_tracking()
+      {
+        test::detail::tracker.tracking_constructions = old_value;
+      }
+
+    private:
+      disable_construction_tracking(disable_construction_tracking const&);
+      disable_construction_tracking& operator=(
+        disable_construction_tracking const&);
+    };
+  }
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/metafunctions.hpp b/src/boost/libs/unordered/test/helpers/metafunctions.hpp
new file mode 100644
index 000000000..f5f138514
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/metafunctions.hpp
@@ -0,0 +1,30 @@
+
+// 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_UNORDERED_TEST_HELPERS_METAFUNCTIONS_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_METAFUNCTIONS_HEADER
+
+#include <boost/config.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace test {
+  template <class Container>
+  struct is_set : public boost::is_same<typename Container::key_type,
+                    typename Container::value_type>
+  {
+  };
+
+  template <class Container> struct has_unique_keys
+  {
+    static char flip(typename Container::iterator const&);
+    static long flip(std::pair<typename Container::iterator, bool> const&);
+    BOOST_STATIC_CONSTANT(bool,
+      value = sizeof(long) ==
+              sizeof(flip(
+                ((Container*)0)->insert(*(typename Container::value_type*)0))));
+  };
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/postfix.hpp b/src/boost/libs/unordered/test/helpers/postfix.hpp
new file mode 100644
index 000000000..ca14ae71b
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/postfix.hpp
@@ -0,0 +1,10 @@
+
+// Copyright 2012 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 this after the boost headers, but before other test headers.
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/prefix.hpp b/src/boost/libs/unordered/test/helpers/prefix.hpp
new file mode 100644
index 000000000..fe7570250
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/prefix.hpp
@@ -0,0 +1,11 @@
+
+// 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)
+
+#if defined(_WIN32_WCE)
+// The standard windows mobile headers trigger this warning so I disable it
+// before doing anything else.
+#pragma warning(disable : 4201) // nonstandard extension used :
+                                // nameless struct/union
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/random_values.hpp b/src/boost/libs/unordered/test/helpers/random_values.hpp
new file mode 100644
index 000000000..d139d1804
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/random_values.hpp
@@ -0,0 +1,109 @@
+
+// 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_UNORDERED_TEST_HELPERS_RANDOM_VALUES_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_RANDOM_VALUES_HEADER
+
+#include "./generators.hpp"
+#include "./list.hpp"
+#include "./metafunctions.hpp"
+#include <algorithm>
+#include <boost/detail/select_type.hpp>
+
+namespace test {
+  template <class X> struct unordered_generator_set
+  {
+    typedef typename X::value_type value_type;
+
+    random_generator type_;
+
+    unordered_generator_set(random_generator type) : type_(type) {}
+
+    template <class T> void fill(T& x, std::size_t len)
+    {
+      value_type* value_ptr = 0;
+      len += x.size();
+
+      for (std::size_t i = 0; i < len; ++i) {
+        value_type value = generate(value_ptr, type_);
+
+        std::size_t count =
+          type_ == generate_collisions ? random_value(5) + 1 : 1;
+
+        for (std::size_t j = 0; j < count; ++j) {
+          x.push_back(value);
+        }
+      }
+    }
+  };
+
+  template <class X> struct unordered_generator_map
+  {
+    typedef typename X::key_type key_type;
+    typedef typename X::mapped_type mapped_type;
+
+    random_generator type_;
+
+    unordered_generator_map(random_generator type) : type_(type) {}
+
+    template <class T> void fill(T& x, std::size_t len)
+    {
+      key_type* key_ptr = 0;
+      mapped_type* mapped_ptr = 0;
+
+      for (std::size_t i = 0; i < len; ++i) {
+        key_type key = generate(key_ptr, type_);
+
+        std::size_t count =
+          type_ == generate_collisions ? random_value(5) + 1 : 1;
+
+        for (std::size_t j = 0; j < count; ++j) {
+          x.push_back(std::pair<key_type const, mapped_type>(
+            key, generate(mapped_ptr, type_)));
+        }
+      }
+    }
+  };
+
+  template <class X>
+  struct unordered_generator_base
+    : public boost::detail::if_true<test::is_set<X>::value>::
+        BOOST_NESTED_TEMPLATE then<test::unordered_generator_set<X>,
+          test::unordered_generator_map<X> >
+  {
+  };
+
+  template <class X>
+  struct unordered_generator : public unordered_generator_base<X>::type
+  {
+    typedef typename unordered_generator_base<X>::type base;
+
+    unordered_generator(random_generator const& type = default_generator)
+        : base(type)
+    {
+    }
+  };
+
+  template <class X>
+  struct random_values : public test::list<typename X::value_type>
+  {
+    random_values() {}
+
+    explicit random_values(std::size_t count,
+      test::random_generator const& generator = test::default_generator)
+    {
+      fill(count, generator);
+    }
+
+    void fill(std::size_t count,
+      test::random_generator const& generator = test::default_generator)
+    {
+      test::unordered_generator<X> gen(generator);
+      gen.fill(*this, count);
+    }
+  };
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/strong.hpp b/src/boost/libs/unordered/test/helpers/strong.hpp
new file mode 100644
index 000000000..3c9361337
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/strong.hpp
@@ -0,0 +1,42 @@
+
+// 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_UNORDERED_TEST_HELPERS_STRONG_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_STRONG_HEADER
+
+#include "./equivalent.hpp"
+#include "./exception_test.hpp"
+#include "./list.hpp"
+#include <boost/config.hpp>
+#include <iterator>
+
+namespace test {
+  template <class X> class strong
+  {
+    typedef test::list<typename X::value_type> values_type;
+    values_type values_;
+    unsigned int allocations_;
+
+  public:
+    void store(X const& x, unsigned int allocations = 0)
+    {
+      DISABLE_EXCEPTIONS;
+      values_.clear();
+      values_.insert(x.cbegin(), x.cend());
+      allocations_ = allocations;
+    }
+
+    void test(X const& x, unsigned int allocations = 0) const
+    {
+      if (!(x.size() == values_.size() && test::equal(x.cbegin(), x.cend(),
+                                            values_.begin(), test::equivalent)))
+        BOOST_ERROR("Strong exception safety failure.");
+      if (allocations != allocations_)
+        BOOST_ERROR("Strong exception failure: extra allocations.");
+    }
+  };
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/test.hpp b/src/boost/libs/unordered/test/helpers/test.hpp
new file mode 100644
index 000000000..5534f8118
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/test.hpp
@@ -0,0 +1,201 @@
+
+// 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)
+
+#if !defined(BOOST_UNORDERED_TEST_TEST_HEADER)
+#define BOOST_UNORDERED_TEST_TEST_HEADER
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/stringize.hpp>
+
+#define UNORDERED_AUTO_TEST(x)                                                 \
+  struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base          \
+  {                                                                            \
+    BOOST_PP_CAT(x, _type)                                                     \
+    () : ::test::registered_test_base(BOOST_PP_STRINGIZE(x))                   \
+    {                                                                          \
+      ::test::get_state().add_test(this);                                      \
+    }                                                                          \
+    void run();                                                                \
+  };                                                                           \
+  BOOST_PP_CAT(x, _type) x;                                                    \
+  void BOOST_PP_CAT(x, _type)::run()
+
+#define RUN_TESTS()                                                            \
+  int main(int, char**)                                                        \
+  {                                                                            \
+    BOOST_UNORDERED_TEST_COMPILER_INFO()                                       \
+    ::test::get_state().run_tests();                                           \
+    return boost::report_errors();                                             \
+  }
+
+#define RUN_TESTS_QUIET()                                                      \
+  int main(int, char**)                                                        \
+  {                                                                            \
+    BOOST_UNORDERED_TEST_COMPILER_INFO()                                       \
+    ::test::get_state().run_tests(true);                                       \
+    return boost::report_errors();                                             \
+  }
+
+#define UNORDERED_SUB_TEST(x)                                                  \
+  for (int UNORDERED_SUB_TEST_VALUE = ::test::get_state().start_sub_test(x);   \
+       UNORDERED_SUB_TEST_VALUE;                                               \
+       UNORDERED_SUB_TEST_VALUE =                                              \
+         ::test::get_state().end_sub_test(x, UNORDERED_SUB_TEST_VALUE))
+
+namespace test {
+
+  struct registered_test_base
+  {
+    registered_test_base* next;
+    char const* name;
+    explicit registered_test_base(char const* n) : name(n) {}
+    virtual void run() = 0;
+    virtual ~registered_test_base() {}
+  };
+
+  struct state
+  {
+    bool is_quiet;
+    registered_test_base* first_test;
+    registered_test_base* last_test;
+
+    state() : is_quiet(false), first_test(0), last_test(0) {}
+
+    void add_test(registered_test_base* test)
+    {
+      if (last_test) {
+        last_test->next = test;
+      } else {
+        first_test = test;
+      }
+      last_test = test;
+    }
+
+    void run_tests(bool quiet = false)
+    {
+      is_quiet = quiet;
+
+      for (registered_test_base* i = first_test; i; i = i->next) {
+        int error_count = boost::detail::test_errors();
+        if (!quiet) {
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Running " << i->name << "\n"
+                                         << std::flush;
+        }
+        i->run();
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << std::flush;
+        if (quiet && error_count != boost::detail::test_errors()) {
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Error in: " << i->name << "\n"
+                                         << std::flush;
+        }
+      }
+    }
+
+    int start_sub_test(char const* name)
+    {
+      if (!is_quiet) {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Sub-test: " << name << "\n"
+                                       << std::flush;
+      }
+      // Add one because it's used as a loop condition.
+      return boost::detail::test_errors() + 1;
+    }
+
+    int end_sub_test(char const* name, int value)
+    {
+      if (is_quiet && value != boost::detail::test_errors() + 1) {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Error in sub-test: " << name << "\n"
+                                       << std::flush;
+      }
+      return 0;
+    }
+  };
+
+  // Get the currnet translation unit's test state.
+  static inline state& get_state()
+  {
+    static state instance;
+    return instance;
+  }
+}
+
+#if defined(__cplusplus)
+#define BOOST_UNORDERED_CPLUSPLUS __cplusplus
+#else
+#define BOOST_UNORDERED_CPLUSPLUS "(not defined)"
+#endif
+
+#define BOOST_UNORDERED_TEST_COMPILER_INFO()                                   \
+  {                                                                            \
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
+      << "Compiler: " << BOOST_COMPILER << "\n"                                \
+      << "Library: " << BOOST_STDLIB << "\n"                                   \
+      << "__cplusplus: " << BOOST_UNORDERED_CPLUSPLUS << "\n\n"                \
+      << "BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT: "                          \
+      << BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT << "\n"                      \
+      << "BOOST_UNORDERED_EMPLACE_LIMIT: " << BOOST_UNORDERED_EMPLACE_LIMIT    \
+      << "\n"                                                                  \
+      << "BOOST_UNORDERED_USE_ALLOCATOR_TRAITS: "                              \
+      << BOOST_UNORDERED_USE_ALLOCATOR_TRAITS << "\n"                          \
+      << "BOOST_UNORDERED_CXX11_CONSTRUCTION: "                                \
+      << BOOST_UNORDERED_CXX11_CONSTRUCTION << "\n\n"                          \
+      << std::flush;                                                           \
+  }
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/seq/fold_left.hpp>
+#include <boost/preprocessor/seq/for_each_product.hpp>
+#include <boost/preprocessor/seq/seq.hpp>
+#include <boost/preprocessor/seq/to_tuple.hpp>
+
+// Run test with every combination of the parameters (a sequence of sequences)
+#define UNORDERED_TEST(name, parameters)                                       \
+  BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP, ((name))((1))parameters)
+
+#define UNORDERED_TEST_REPEAT(name, n, parameters)                             \
+  BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP, ((name))((n))parameters)
+
+#define UNORDERED_TEST_OP(r, product)                                          \
+  UNORDERED_TEST_OP2(BOOST_PP_SEQ_ELEM(0, product),                            \
+    BOOST_PP_SEQ_ELEM(1, product),                                             \
+    BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_TAIL(product)))
+
+#define UNORDERED_TEST_OP2(name, n, params)                                    \
+  UNORDERED_AUTO_TEST (                                                        \
+    BOOST_PP_SEQ_FOLD_LEFT(UNORDERED_TEST_OP_JOIN, name, params)) {            \
+    for (int i = 0; i < n; ++i)                                                \
+      name BOOST_PP_SEQ_TO_TUPLE(params);                                      \
+  }
+
+#define UNORDERED_TEST_OP_JOIN(s, state, elem)                                 \
+  BOOST_PP_CAT(state, BOOST_PP_CAT(_, elem))
+
+#define UNORDERED_MULTI_TEST(name, impl, parameters)                           \
+  UNORDERED_MULTI_TEST_REPEAT(name, impl, 1, parameters)
+
+#define UNORDERED_MULTI_TEST_REPEAT(name, impl, n, parameters)                 \
+  UNORDERED_AUTO_TEST (name) {                                                 \
+    BOOST_PP_SEQ_FOR_EACH_PRODUCT(                                             \
+      UNORDERED_MULTI_TEST_OP, ((impl))((n))parameters)                        \
+  }
+
+#define UNORDERED_MULTI_TEST_OP(r, product)                                    \
+  UNORDERED_MULTI_TEST_OP2(BOOST_PP_SEQ_ELEM(0, product),                      \
+    BOOST_PP_SEQ_ELEM(1, product),                                             \
+    BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_TAIL(product)))
+
+// Need to wrap UNORDERED_SUB_TEST in a block to avoid an msvc bug.
+// https://support.microsoft.com/en-gb/help/315481/bug-too-many-unnested-loops-incorrectly-causes-a-c1061-compiler-error-in-visual-c
+#define UNORDERED_MULTI_TEST_OP2(name, n, params)                              \
+  {                                                                            \
+    UNORDERED_SUB_TEST(BOOST_PP_STRINGIZE(                                     \
+      BOOST_PP_SEQ_FOLD_LEFT(UNORDERED_TEST_OP_JOIN, name, params)))           \
+    {                                                                          \
+      for (int i = 0; i < n; ++i)                                              \
+        name BOOST_PP_SEQ_TO_TUPLE(params);                                    \
+    }                                                                          \
+  }
+
+#endif
diff --git a/src/boost/libs/unordered/test/helpers/tracker.hpp b/src/boost/libs/unordered/test/helpers/tracker.hpp
new file mode 100644
index 000000000..0f86ba6f7
--- /dev/null
+++ b/src/boost/libs/unordered/test/helpers/tracker.hpp
@@ -0,0 +1,138 @@
+
+// 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 header contains metafunctions/functions to get the equivalent
+// associative container for an unordered container, and compare the contents.
+
+#if !defined(BOOST_UNORDERED_TEST_HELPERS_TRACKER_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_TRACKER_HEADER
+
+#include "../objects/fwd.hpp"
+#include "./equivalent.hpp"
+#include "./helpers.hpp"
+#include "./list.hpp"
+#include "./metafunctions.hpp"
+#include <algorithm>
+#include <iterator>
+#include <map>
+#include <set>
+
+namespace test {
+  template <typename X> struct equals_to_compare
+  {
+    typedef std::less<typename X::first_argument_type> type;
+  };
+
+  template <> struct equals_to_compare<test::equal_to>
+  {
+    typedef test::less type;
+  };
+
+  template <class X1, class X2> void compare_range(X1 const& x1, X2 const& x2)
+  {
+    typedef test::list<typename X1::value_type> value_list;
+    value_list values1(x1.begin(), x1.end());
+    value_list values2(x2.begin(), x2.end());
+    values1.sort();
+    values2.sort();
+    BOOST_TEST(values1.size() == values2.size() &&
+               test::equal(values1.begin(), values1.end(), values2.begin(),
+                 test::equivalent));
+  }
+
+  template <class X1, class X2, class T>
+  void compare_pairs(X1 const& x1, X2 const& x2, T*)
+  {
+    test::list<T> values1(x1.first, x1.second);
+    test::list<T> values2(x2.first, x2.second);
+    values1.sort();
+    values2.sort();
+    BOOST_TEST(values1.size() == values2.size() &&
+               test::equal(values1.begin(), values1.end(), values2.begin(),
+                 test::equivalent));
+  }
+
+  template <typename X, bool is_set = test::is_set<X>::value,
+    bool has_unique_keys = test::has_unique_keys<X>::value>
+  struct ordered_base;
+
+  template <typename X> struct ordered_base<X, true, true>
+  {
+    typedef std::set<typename X::value_type,
+      typename equals_to_compare<typename X::key_equal>::type>
+      type;
+  };
+
+  template <typename X> struct ordered_base<X, true, false>
+  {
+    typedef std::multiset<typename X::value_type,
+      typename equals_to_compare<typename X::key_equal>::type>
+      type;
+  };
+
+  template <typename X> struct ordered_base<X, false, true>
+  {
+    typedef std::map<typename X::key_type, typename X::mapped_type,
+      typename equals_to_compare<typename X::key_equal>::type>
+      type;
+  };
+
+  template <typename X> struct ordered_base<X, false, false>
+  {
+    typedef std::multimap<typename X::key_type, typename X::mapped_type,
+      typename equals_to_compare<typename X::key_equal>::type>
+      type;
+  };
+
+  template <class X> class ordered : public ordered_base<X>::type
+  {
+    typedef typename ordered_base<X>::type base;
+
+  public:
+    typedef typename base::key_compare key_compare;
+
+    ordered() : base() {}
+
+    explicit ordered(key_compare const& kc) : base(kc) {}
+
+    void compare(X const& x) { compare_range(x, *this); }
+
+    void compare_key(X const& x, typename X::value_type const& val)
+    {
+      compare_pairs(x.equal_range(get_key<X>(val)),
+        this->equal_range(get_key<X>(val)), (typename X::value_type*)0);
+    }
+
+    template <class It> void insert_range(It b, It e)
+    {
+      while (b != e) {
+        this->insert(*b);
+        ++b;
+      }
+    }
+  };
+
+  template <class Equals>
+  typename equals_to_compare<Equals>::type create_compare(Equals const&)
+  {
+    typename equals_to_compare<Equals>::type x;
+    return x;
+  }
+
+  template <class X> ordered<X> create_ordered(X const& container)
+  {
+    return ordered<X>(create_compare(container.key_eq()));
+  }
+
+  template <class X1, class X2>
+  void check_container(X1 const& container, X2 const& values)
+  {
+    ordered<X1> tracker = create_ordered(container);
+    tracker.insert_range(values.begin(), values.end());
+    tracker.compare(container);
+  }
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/objects/cxx11_allocator.hpp b/src/boost/libs/unordered/test/objects/cxx11_allocator.hpp
new file mode 100644
index 000000000..e96f8d944
--- /dev/null
+++ b/src/boost/libs/unordered/test/objects/cxx11_allocator.hpp
@@ -0,0 +1,344 @@
+
+// Copyright 2006-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)
+
+#if !defined(BOOST_UNORDERED_TEST_CXX11_ALLOCATOR_HEADER)
+#define BOOST_UNORDERED_TEST_CXX11_ALLOCATOR_HEADER
+
+#include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <cstddef>
+
+#include "../helpers/fwd.hpp"
+#include "../helpers/memory.hpp"
+
+namespace test {
+  struct allocator_false
+  {
+    enum
+    {
+      is_select_on_copy = 0,
+      is_propagate_on_swap = 0,
+      is_propagate_on_assign = 0,
+      is_propagate_on_move = 0,
+      cxx11_construct = 0
+    };
+  };
+
+  struct allocator_flags_all
+  {
+    enum
+    {
+      is_select_on_copy = 1,
+      is_propagate_on_swap = 1,
+      is_propagate_on_assign = 1,
+      is_propagate_on_move = 1,
+      cxx11_construct = 1
+    };
+  };
+
+  struct select_copy : allocator_false
+  {
+    enum
+    {
+      is_select_on_copy = 1
+    };
+  };
+  struct propagate_swap : allocator_false
+  {
+    enum
+    {
+      is_propagate_on_swap = 1
+    };
+  };
+  struct propagate_assign : allocator_false
+  {
+    enum
+    {
+      is_propagate_on_assign = 1
+    };
+  };
+  struct propagate_move : allocator_false
+  {
+    enum
+    {
+      is_propagate_on_move = 1
+    };
+  };
+
+  struct no_select_copy : allocator_flags_all
+  {
+    enum
+    {
+      is_select_on_copy = 0
+    };
+  };
+  struct no_propagate_swap : allocator_flags_all
+  {
+    enum
+    {
+      is_propagate_on_swap = 0
+    };
+  };
+  struct no_propagate_assign : allocator_flags_all
+  {
+    enum
+    {
+      is_propagate_on_assign = 0
+    };
+  };
+  struct no_propagate_move : allocator_flags_all
+  {
+    enum
+    {
+      is_propagate_on_move = 0
+    };
+  };
+
+  template <typename Flag> struct swap_allocator_base
+  {
+    struct propagate_on_container_swap
+    {
+      enum
+      {
+        value = Flag::is_propagate_on_swap
+      };
+    };
+  };
+
+  template <typename Flag> struct assign_allocator_base
+  {
+    struct propagate_on_container_copy_assignment
+    {
+      enum
+      {
+        value = Flag::is_propagate_on_assign
+      };
+    };
+  };
+
+  template <typename Flag> struct move_allocator_base
+  {
+    struct propagate_on_container_move_assignment
+    {
+      enum
+      {
+        value = Flag::is_propagate_on_move
+      };
+    };
+  };
+
+  namespace {
+    // boostinspect:nounnamed
+    bool force_equal_allocator_value = false;
+  }
+
+  struct force_equal_allocator
+  {
+    bool old_value_;
+
+    explicit force_equal_allocator(bool value)
+        : old_value_(force_equal_allocator_value)
+    {
+      force_equal_allocator_value = value;
+    }
+
+    ~force_equal_allocator() { force_equal_allocator_value = old_value_; }
+  };
+
+  template <typename T> struct cxx11_allocator_base
+  {
+    int tag_;
+    int selected_;
+
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T* pointer;
+    typedef T const* const_pointer;
+    typedef T& reference;
+    typedef T const& const_reference;
+    typedef T value_type;
+
+    explicit cxx11_allocator_base(int t) : tag_(t), selected_(0)
+    {
+      detail::tracker.allocator_ref();
+    }
+
+    template <typename Y>
+    cxx11_allocator_base(cxx11_allocator_base<Y> const& x)
+        : tag_(x.tag_), selected_(x.selected_)
+    {
+      detail::tracker.allocator_ref();
+    }
+
+    cxx11_allocator_base(cxx11_allocator_base const& x)
+        : tag_(x.tag_), selected_(x.selected_)
+    {
+      detail::tracker.allocator_ref();
+    }
+
+    ~cxx11_allocator_base() { detail::tracker.allocator_unref(); }
+
+    pointer address(reference r) { return pointer(&r); }
+
+    const_pointer address(const_reference r) { return const_pointer(&r); }
+
+    pointer allocate(size_type n)
+    {
+      pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+      detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+      return ptr;
+    }
+
+    pointer allocate(size_type n, void const*)
+    {
+      pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+      detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+      return ptr;
+    }
+
+    void deallocate(pointer p, size_type n)
+    {
+      // Only checking tags when propagating swap.
+      // Note that tags will be tested
+      // properly in the normal allocator.
+      detail::tracker.track_deallocate(
+        (void*)p, n, sizeof(T), tag_, !force_equal_allocator_value);
+      ::operator delete((void*)p);
+    }
+
+    void construct(T* p, T const& t)
+    {
+      detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+      new (p) T(t);
+    }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template <typename... Args>
+    void construct(T* p, BOOST_FWD_REF(Args)... args)
+    {
+      detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+      new (p) T(boost::forward<Args>(args)...);
+    }
+#endif
+
+    void destroy(T* p)
+    {
+      detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+      p->~T();
+    }
+
+    size_type max_size() const
+    {
+      return (std::numeric_limits<size_type>::max)();
+    }
+  };
+
+  template <typename T, typename Flags = propagate_swap, typename Enable = void>
+  struct cxx11_allocator;
+
+  template <typename T, typename Flags>
+  struct cxx11_allocator<T, Flags,
+    typename boost::disable_if_c<Flags::is_select_on_copy>::type>
+    : public cxx11_allocator_base<T>,
+      public swap_allocator_base<Flags>,
+      public assign_allocator_base<Flags>,
+      public move_allocator_base<Flags>,
+      Flags
+  {
+#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
+    template <typename U> struct rebind
+    {
+      typedef cxx11_allocator<U, Flags> other;
+    };
+#endif
+
+    explicit cxx11_allocator(int t = 0) : cxx11_allocator_base<T>(t) {}
+
+    template <typename Y>
+    cxx11_allocator(cxx11_allocator<Y, Flags> const& x)
+        : cxx11_allocator_base<T>(x)
+    {
+    }
+
+    cxx11_allocator(cxx11_allocator const& x) : cxx11_allocator_base<T>(x) {}
+
+    // When not propagating swap, allocators are always equal
+    // to avoid undefined behaviour.
+    bool operator==(cxx11_allocator const& x) const
+    {
+      return force_equal_allocator_value || (this->tag_ == x.tag_);
+    }
+
+    bool operator!=(cxx11_allocator const& x) const { return !(*this == x); }
+  };
+
+  template <typename T, typename Flags>
+  struct cxx11_allocator<T, Flags,
+    typename boost::enable_if_c<Flags::is_select_on_copy>::type>
+    : public cxx11_allocator_base<T>,
+      public swap_allocator_base<Flags>,
+      public assign_allocator_base<Flags>,
+      public move_allocator_base<Flags>,
+      Flags
+  {
+    cxx11_allocator select_on_container_copy_construction() const
+    {
+      cxx11_allocator tmp(*this);
+      ++tmp.selected_;
+      return tmp;
+    }
+
+#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
+    template <typename U> struct rebind
+    {
+      typedef cxx11_allocator<U, Flags> other;
+    };
+#endif
+
+    explicit cxx11_allocator(int t = 0) : cxx11_allocator_base<T>(t) {}
+
+    template <typename Y>
+    cxx11_allocator(cxx11_allocator<Y, Flags> const& x)
+        : cxx11_allocator_base<T>(x)
+    {
+    }
+
+    cxx11_allocator(cxx11_allocator const& x) : cxx11_allocator_base<T>(x) {}
+
+    // When not propagating swap, allocators are always equal
+    // to avoid undefined behaviour.
+    bool operator==(cxx11_allocator const& x) const
+    {
+      return force_equal_allocator_value || (this->tag_ == x.tag_);
+    }
+
+    bool operator!=(cxx11_allocator const& x) const { return !(*this == x); }
+  };
+
+  template <typename T, typename Flags>
+  bool equivalent_impl(cxx11_allocator<T, Flags> const& x,
+    cxx11_allocator<T, Flags> const& y, test::derived_type)
+  {
+    return x.tag_ == y.tag_;
+  }
+
+  // Function to check how many times an allocator has been selected,
+  // return 0 for other allocators.
+
+  struct convert_from_anything
+  {
+    template <typename T> convert_from_anything(T const&) {}
+  };
+
+  inline int selected_count(convert_from_anything) { return 0; }
+
+  template <typename T, typename Flags>
+  int selected_count(cxx11_allocator<T, Flags> const& x)
+  {
+    return x.selected_;
+  }
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/objects/exception.hpp b/src/boost/libs/unordered/test/objects/exception.hpp
new file mode 100644
index 000000000..07f343fb9
--- /dev/null
+++ b/src/boost/libs/unordered/test/objects/exception.hpp
@@ -0,0 +1,752 @@
+
+// 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)
+
+#if !defined(BOOST_UNORDERED_EXCEPTION_TEST_OBJECTS_HEADER)
+#define BOOST_UNORDERED_EXCEPTION_TEST_OBJECTS_HEADER
+
+#include "../helpers/exception_test.hpp"
+
+#include "../helpers/count.hpp"
+#include "../helpers/fwd.hpp"
+#include "../helpers/generators.hpp"
+#include "../helpers/memory.hpp"
+#include "./fwd.hpp"
+#include <boost/limits.hpp>
+#include <cstddef>
+#include <new>
+
+namespace test {
+  namespace exception {
+    class object;
+    class hash;
+    class equal_to;
+    template <class T> class allocator;
+    object generate(object const*, random_generator);
+    std::pair<object, object> generate(
+      std::pair<object, object> const*, random_generator);
+
+    struct true_type
+    {
+      enum
+      {
+        value = true
+      };
+    };
+
+    struct false_type
+    {
+      enum
+      {
+        value = false
+      };
+    };
+
+    class object : private counted_object
+    {
+    public:
+      int tag1_, tag2_;
+
+      explicit object() : tag1_(0), tag2_(0)
+      {
+        UNORDERED_SCOPE(object::object())
+        {
+          UNORDERED_EPOINT("Mock object default constructor.");
+        }
+      }
+
+      explicit object(int t1, int t2 = 0) : tag1_(t1), tag2_(t2)
+      {
+        UNORDERED_SCOPE(object::object(int))
+        {
+          UNORDERED_EPOINT("Mock object constructor by value.");
+        }
+      }
+
+      object(object const& x)
+          : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
+      {
+        UNORDERED_SCOPE(object::object(object))
+        {
+          UNORDERED_EPOINT("Mock object copy constructor.");
+        }
+      }
+
+      ~object()
+      {
+        tag1_ = -1;
+        tag2_ = -1;
+      }
+
+      object& operator=(object const& x)
+      {
+        UNORDERED_SCOPE(object::operator=(object))
+        {
+          tag1_ = x.tag1_;
+          UNORDERED_EPOINT("Mock object assign operator 1.");
+          tag2_ = x.tag2_;
+          // UNORDERED_EPOINT("Mock object assign operator 2.");
+        }
+        return *this;
+      }
+
+      friend bool operator==(object const& x1, object const& x2)
+      {
+        UNORDERED_SCOPE(operator==(object, object))
+        {
+          UNORDERED_EPOINT("Mock object equality operator.");
+        }
+
+        return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
+      }
+
+      friend bool operator!=(object const& x1, object const& x2)
+      {
+        UNORDERED_SCOPE(operator!=(object, object))
+        {
+          UNORDERED_EPOINT("Mock object inequality operator.");
+        }
+
+        return !(x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_);
+      }
+
+      // None of the last few functions are used by the unordered associative
+      // containers - so there aren't any exception points.
+      friend bool operator<(object const& x1, object const& x2)
+      {
+        return x1.tag1_ < x2.tag1_ ||
+               (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
+      }
+
+      friend object generate(object const*, random_generator g)
+      {
+        int* x = 0;
+        return object(::test::generate(x, g), ::test::generate(x, g));
+      }
+
+      friend std::ostream& operator<<(std::ostream& out, object const& o)
+      {
+        return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+      }
+    };
+
+    std::pair<object, object> generate(
+      std::pair<object, object> const*, random_generator g)
+    {
+      int* x = 0;
+      return std::make_pair(
+        object(::test::generate(x, g), ::test::generate(x, g)),
+        object(::test::generate(x, g), ::test::generate(x, g)));
+    }
+
+    class hash
+    {
+      int tag_;
+
+    public:
+      hash(int t = 0) : tag_(t)
+      {
+        UNORDERED_SCOPE(hash::object())
+        {
+          UNORDERED_EPOINT("Mock hash default constructor.");
+        }
+      }
+
+      hash(hash const& x) : tag_(x.tag_)
+      {
+        UNORDERED_SCOPE(hash::hash(hash))
+        {
+          UNORDERED_EPOINT("Mock hash copy constructor.");
+        }
+      }
+
+      hash& operator=(hash const& x)
+      {
+        UNORDERED_SCOPE(hash::operator=(hash))
+        {
+          UNORDERED_EPOINT("Mock hash assign operator 1.");
+          tag_ = x.tag_;
+          UNORDERED_EPOINT("Mock hash assign operator 2.");
+        }
+        return *this;
+      }
+
+      std::size_t operator()(object const& x) const
+      {
+        UNORDERED_SCOPE(hash::operator()(object))
+        {
+          UNORDERED_EPOINT("Mock hash function.");
+        }
+
+        return hash_impl(x);
+      }
+
+      std::size_t operator()(std::pair<object, object> const& x) const
+      {
+        UNORDERED_SCOPE(hash::operator()(std::pair<object, object>))
+        {
+          UNORDERED_EPOINT("Mock hash pair function.");
+        }
+
+        return hash_impl(x.first) * 193ul + hash_impl(x.second) * 97ul + 29ul;
+      }
+
+      std::size_t hash_impl(object const& x) const
+      {
+        int result;
+        switch (tag_) {
+        case 1:
+          result = x.tag1_;
+          break;
+        case 2:
+          result = x.tag2_;
+          break;
+        default:
+          result = x.tag1_ + x.tag2_;
+        }
+        return static_cast<std::size_t>(result);
+      }
+
+      friend bool operator==(hash const& x1, hash const& x2)
+      {
+        UNORDERED_SCOPE(operator==(hash, hash))
+        {
+          UNORDERED_EPOINT("Mock hash equality function.");
+        }
+        return x1.tag_ == x2.tag_;
+      }
+
+      friend bool operator!=(hash const& x1, hash const& x2)
+      {
+        UNORDERED_SCOPE(hash::operator!=(hash, hash))
+        {
+          UNORDERED_EPOINT("Mock hash inequality function.");
+        }
+        return x1.tag_ != x2.tag_;
+      }
+    };
+
+    class less
+    {
+      int tag_;
+
+    public:
+      less(int t = 0) : tag_(t) {}
+
+      less(less const& x) : tag_(x.tag_) {}
+
+      bool operator()(object const& x1, object const& x2) const
+      {
+        return less_impl(x1, x2);
+      }
+
+      bool operator()(std::pair<object, object> const& x1,
+        std::pair<object, object> const& x2) const
+      {
+        if (less_impl(x1.first, x2.first)) {
+          return true;
+        }
+        if (!less_impl(x1.first, x2.first)) {
+          return false;
+        }
+        return less_impl(x1.second, x2.second);
+      }
+
+      bool less_impl(object const& x1, object const& x2) const
+      {
+        switch (tag_) {
+        case 1:
+          return x1.tag1_ < x2.tag1_;
+        case 2:
+          return x1.tag2_ < x2.tag2_;
+        default:
+          return x1 < x2;
+        }
+      }
+
+      friend bool operator==(less const& x1, less const& x2)
+      {
+        return x1.tag_ == x2.tag_;
+      }
+
+      friend bool operator!=(less const& x1, less const& x2)
+      {
+        return x1.tag_ != x2.tag_;
+      }
+    };
+
+    class equal_to
+    {
+      int tag_;
+
+    public:
+      equal_to(int t = 0) : tag_(t)
+      {
+        UNORDERED_SCOPE(equal_to::equal_to())
+        {
+          UNORDERED_EPOINT("Mock equal_to default constructor.");
+        }
+      }
+
+      equal_to(equal_to const& x) : tag_(x.tag_)
+      {
+        UNORDERED_SCOPE(equal_to::equal_to(equal_to))
+        {
+          UNORDERED_EPOINT("Mock equal_to copy constructor.");
+        }
+      }
+
+      equal_to& operator=(equal_to const& x)
+      {
+        UNORDERED_SCOPE(equal_to::operator=(equal_to))
+        {
+          UNORDERED_EPOINT("Mock equal_to assign operator 1.");
+          tag_ = x.tag_;
+          UNORDERED_EPOINT("Mock equal_to assign operator 2.");
+        }
+        return *this;
+      }
+
+      bool operator()(object const& x1, object const& x2) const
+      {
+        UNORDERED_SCOPE(equal_to::operator()(object, object))
+        {
+          UNORDERED_EPOINT("Mock equal_to function.");
+        }
+
+        return equal_impl(x1, x2);
+      }
+
+      bool operator()(std::pair<object, object> const& x1,
+        std::pair<object, object> const& x2) const
+      {
+        UNORDERED_SCOPE(equal_to::operator()(
+          std::pair<object, object>, std::pair<object, object>))
+        {
+          UNORDERED_EPOINT("Mock equal_to function.");
+        }
+
+        return equal_impl(x1.first, x2.first) &&
+               equal_impl(x1.second, x2.second);
+      }
+
+      bool equal_impl(object const& x1, object const& x2) const
+      {
+        switch (tag_) {
+        case 1:
+          return x1.tag1_ == x2.tag1_;
+        case 2:
+          return x1.tag2_ == x2.tag2_;
+        default:
+          return x1 == x2;
+        }
+      }
+
+      friend bool operator==(equal_to const& x1, equal_to const& x2)
+      {
+        UNORDERED_SCOPE(operator==(equal_to, equal_to))
+        {
+          UNORDERED_EPOINT("Mock equal_to equality function.");
+        }
+        return x1.tag_ == x2.tag_;
+      }
+
+      friend bool operator!=(equal_to const& x1, equal_to const& x2)
+      {
+        UNORDERED_SCOPE(operator!=(equal_to, equal_to))
+        {
+          UNORDERED_EPOINT("Mock equal_to inequality function.");
+        }
+        return x1.tag_ != x2.tag_;
+      }
+
+      friend less create_compare(equal_to x) { return less(x.tag_); }
+    };
+
+    template <class T> class allocator
+    {
+    public:
+      int tag_;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef T* pointer;
+      typedef T const* const_pointer;
+      typedef T& reference;
+      typedef T const& const_reference;
+      typedef T value_type;
+
+      template <class U> struct rebind
+      {
+        typedef allocator<U> other;
+      };
+
+      explicit allocator(int t = 0) : tag_(t)
+      {
+        UNORDERED_SCOPE(allocator::allocator())
+        {
+          UNORDERED_EPOINT("Mock allocator default constructor.");
+        }
+        test::detail::tracker.allocator_ref();
+      }
+
+      template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_)
+      {
+        test::detail::tracker.allocator_ref();
+      }
+
+      allocator(allocator const& x) : tag_(x.tag_)
+      {
+        test::detail::tracker.allocator_ref();
+      }
+
+      ~allocator() { test::detail::tracker.allocator_unref(); }
+
+      allocator& operator=(allocator const& x)
+      {
+        tag_ = x.tag_;
+        return *this;
+      }
+
+      // If address throws, then it can't be used in erase or the
+      // destructor, which is very limiting. I need to check up on
+      // this.
+
+      pointer address(reference r)
+      {
+        // UNORDERED_SCOPE(allocator::address(reference)) {
+        //    UNORDERED_EPOINT("Mock allocator address function.");
+        //}
+        return pointer(&r);
+      }
+
+      const_pointer address(const_reference r)
+      {
+        // UNORDERED_SCOPE(allocator::address(const_reference)) {
+        //    UNORDERED_EPOINT("Mock allocator const address function.");
+        //}
+        return const_pointer(&r);
+      }
+
+      pointer allocate(size_type n)
+      {
+        T* ptr = 0;
+        UNORDERED_SCOPE(allocator::allocate(size_type))
+        {
+          UNORDERED_EPOINT("Mock allocator allocate function.");
+
+          using namespace std;
+          ptr = (T*)malloc(n * sizeof(T));
+          if (!ptr)
+            throw std::bad_alloc();
+        }
+        test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return pointer(ptr);
+
+        // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+      }
+
+      pointer allocate(size_type n, void const*)
+      {
+        T* ptr = 0;
+        UNORDERED_SCOPE(allocator::allocate(size_type, const_pointer))
+        {
+          UNORDERED_EPOINT("Mock allocator allocate function.");
+
+          using namespace std;
+          ptr = (T*)malloc(n * sizeof(T));
+          if (!ptr)
+            throw std::bad_alloc();
+        }
+        test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return pointer(ptr);
+
+        // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+      }
+
+      void deallocate(pointer p, size_type n)
+      {
+        //::operator delete((void*) p);
+        if (p) {
+          test::detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
+          using namespace std;
+          free(p);
+        }
+      }
+
+      void construct(pointer p, T const& t)
+      {
+        UNORDERED_SCOPE(allocator::construct(T*, T))
+        {
+          UNORDERED_EPOINT("Mock allocator construct function.");
+          new (p) T(t);
+        }
+        test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+      }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+      template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+      {
+        UNORDERED_SCOPE(allocator::construct(pointer, BOOST_FWD_REF(Args)...))
+        {
+          UNORDERED_EPOINT("Mock allocator construct function.");
+          new (p) T(boost::forward<Args>(args)...);
+        }
+        test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+      }
+#endif
+
+      void destroy(T* p)
+      {
+        test::detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+        p->~T();
+      }
+
+      size_type max_size() const
+      {
+        UNORDERED_SCOPE(allocator::construct(pointer, T))
+        {
+          UNORDERED_EPOINT("Mock allocator max_size function.");
+        }
+        return (std::numeric_limits<std::size_t>::max)();
+      }
+
+      typedef true_type propagate_on_container_copy_assignment;
+      typedef true_type propagate_on_container_move_assignment;
+      typedef true_type propagate_on_container_swap;
+    };
+
+    template <class T> void swap(allocator<T>& x, allocator<T>& y)
+    {
+      std::swap(x.tag_, y.tag_);
+    }
+
+    // It's pretty much impossible to write a compliant swap when these
+    // two can throw. So they don't.
+
+    template <class T>
+    inline bool operator==(allocator<T> const& x, allocator<T> const& y)
+    {
+      // UNORDERED_SCOPE(operator==(allocator, allocator)) {
+      //    UNORDERED_EPOINT("Mock allocator equality operator.");
+      //}
+      return x.tag_ == y.tag_;
+    }
+
+    template <class T>
+    inline bool operator!=(allocator<T> const& x, allocator<T> const& y)
+    {
+      // UNORDERED_SCOPE(operator!=(allocator, allocator)) {
+      //    UNORDERED_EPOINT("Mock allocator inequality operator.");
+      //}
+      return x.tag_ != y.tag_;
+    }
+
+    template <class T> class allocator2
+    {
+    public:
+      int tag_;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef T* pointer;
+      typedef T const* const_pointer;
+      typedef T& reference;
+      typedef T const& const_reference;
+      typedef T value_type;
+
+      template <class U> struct rebind
+      {
+        typedef allocator2<U> other;
+      };
+
+      explicit allocator2(int t = 0) : tag_(t)
+      {
+        UNORDERED_SCOPE(allocator2::allocator2())
+        {
+          UNORDERED_EPOINT("Mock allocator2 default constructor.");
+        }
+        test::detail::tracker.allocator_ref();
+      }
+
+      allocator2(allocator<T> const& x) : tag_(x.tag_)
+      {
+        test::detail::tracker.allocator_ref();
+      }
+
+      template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
+      {
+        test::detail::tracker.allocator_ref();
+      }
+
+      allocator2(allocator2 const& x) : tag_(x.tag_)
+      {
+        test::detail::tracker.allocator_ref();
+      }
+
+      ~allocator2() { test::detail::tracker.allocator_unref(); }
+
+      allocator2& operator=(allocator2 const&) { return *this; }
+
+      // If address throws, then it can't be used in erase or the
+      // destructor, which is very limiting. I need to check up on
+      // this.
+
+      pointer address(reference r)
+      {
+        // UNORDERED_SCOPE(allocator2::address(reference)) {
+        //    UNORDERED_EPOINT("Mock allocator2 address function.");
+        //}
+        return pointer(&r);
+      }
+
+      const_pointer address(const_reference r)
+      {
+        // UNORDERED_SCOPE(allocator2::address(const_reference)) {
+        //    UNORDERED_EPOINT("Mock allocator2 const address function.");
+        //}
+        return const_pointer(&r);
+      }
+
+      pointer allocate(size_type n)
+      {
+        T* ptr = 0;
+        UNORDERED_SCOPE(allocator2::allocate(size_type))
+        {
+          UNORDERED_EPOINT("Mock allocator2 allocate function.");
+
+          using namespace std;
+          ptr = (T*)malloc(n * sizeof(T));
+          if (!ptr)
+            throw std::bad_alloc();
+        }
+        test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return pointer(ptr);
+
+        // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+      }
+
+      pointer allocate(size_type n, void const*)
+      {
+        T* ptr = 0;
+        UNORDERED_SCOPE(allocator2::allocate(size_type, const_pointer))
+        {
+          UNORDERED_EPOINT("Mock allocator2 allocate function.");
+
+          using namespace std;
+          ptr = (T*)malloc(n * sizeof(T));
+          if (!ptr)
+            throw std::bad_alloc();
+        }
+        test::detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return pointer(ptr);
+
+        // return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+      }
+
+      void deallocate(pointer p, size_type n)
+      {
+        //::operator delete((void*) p);
+        if (p) {
+          test::detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
+          using namespace std;
+          free(p);
+        }
+      }
+
+      void construct(pointer p, T const& t)
+      {
+        UNORDERED_SCOPE(allocator2::construct(T*, T))
+        {
+          UNORDERED_EPOINT("Mock allocator2 construct function.");
+          new (p) T(t);
+        }
+        test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+      }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+      template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+      {
+        UNORDERED_SCOPE(allocator2::construct(pointer, BOOST_FWD_REF(Args)...))
+        {
+          UNORDERED_EPOINT("Mock allocator2 construct function.");
+          new (p) T(boost::forward<Args>(args)...);
+        }
+        test::detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+      }
+#endif
+
+      void destroy(T* p)
+      {
+        test::detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+        p->~T();
+      }
+
+      size_type max_size() const
+      {
+        UNORDERED_SCOPE(allocator2::construct(pointer, T))
+        {
+          UNORDERED_EPOINT("Mock allocator2 max_size function.");
+        }
+        return (std::numeric_limits<std::size_t>::max)();
+      }
+
+      typedef false_type propagate_on_container_copy_assignment;
+      typedef false_type propagate_on_container_move_assignment;
+      typedef false_type propagate_on_container_swap;
+    };
+
+    template <class T> void swap(allocator2<T>& x, allocator2<T>& y)
+    {
+      std::swap(x.tag_, y.tag_);
+    }
+
+    // It's pretty much impossible to write a compliant swap when these
+    // two can throw. So they don't.
+
+    template <class T>
+    inline bool operator==(allocator2<T> const& x, allocator2<T> const& y)
+    {
+      // UNORDERED_SCOPE(operator==(allocator2, allocator2)) {
+      //    UNORDERED_EPOINT("Mock allocator2 equality operator.");
+      //}
+      return x.tag_ == y.tag_;
+    }
+
+    template <class T>
+    inline bool operator!=(allocator2<T> const& x, allocator2<T> const& y)
+    {
+      // UNORDERED_SCOPE(operator!=(allocator2, allocator2)) {
+      //    UNORDERED_EPOINT("Mock allocator2 inequality operator.");
+      //}
+      return x.tag_ != y.tag_;
+    }
+  }
+}
+
+namespace test {
+  template <typename X> struct equals_to_compare;
+  template <> struct equals_to_compare<test::exception::equal_to>
+  {
+    typedef test::exception::less type;
+  };
+}
+
+// Workaround for ADL deficient compilers
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace test {
+  test::exception::object generate(
+    test::exception::object const* x, random_generator g)
+  {
+    return test::exception::generate(x, g);
+  }
+
+  std::pair<test::exception::object, test::exception::object> generate(
+    std::pair<test::exception::object, test::exception::object> const* x,
+    random_generator g)
+  {
+    return test::exception::generate(x, g);
+  }
+}
+#endif
+
+#endif
diff --git a/src/boost/libs/unordered/test/objects/fwd.hpp b/src/boost/libs/unordered/test/objects/fwd.hpp
new file mode 100644
index 000000000..802b95af4
--- /dev/null
+++ b/src/boost/libs/unordered/test/objects/fwd.hpp
@@ -0,0 +1,17 @@
+
+// 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)
+
+#if !defined(BOOST_UNORDERED_TEST_OBJECTS_FWD_HEADER)
+#define BOOST_UNORDERED_TEST_OBJECTS_FWD_HEADER
+
+namespace test {
+  class object;
+  class hash;
+  class less;
+  class equal_to;
+  template <class T> class allocator;
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/objects/minimal.hpp b/src/boost/libs/unordered/test/objects/minimal.hpp
new file mode 100644
index 000000000..b89e0af82
--- /dev/null
+++ b/src/boost/libs/unordered/test/objects/minimal.hpp
@@ -0,0 +1,627 @@
+
+// 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)
+
+// Define some minimal classes which provide the bare minimum concepts to
+// test that the containers don't rely on something that they shouldn't.
+// They are not intended to be good examples of how to implement the concepts.
+
+#if !defined(BOOST_UNORDERED_OBJECTS_MINIMAL_HEADER)
+#define BOOST_UNORDERED_OBJECTS_MINIMAL_HEADER
+
+#include <boost/move/move.hpp>
+#include <cstddef>
+#include <utility>
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable : 4100) // unreferenced formal parameter
+#endif
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, == 1500)
+#define BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED 1
+#else
+#define BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED 0
+#endif
+
+namespace test {
+  namespace minimal {
+    class destructible;
+    class copy_constructible;
+    class copy_constructible_equality_comparable;
+    class default_assignable;
+    class assignable;
+
+    struct ampersand_operator_used
+    {
+      ampersand_operator_used() { BOOST_TEST(false); }
+    };
+
+    template <class T> class hash;
+    template <class T> class equal_to;
+    template <class T> class ptr;
+    template <class T> class const_ptr;
+    template <class T> class allocator;
+    template <class T> class cxx11_allocator;
+
+    struct constructor_param
+    {
+      operator int() const { return 0; }
+    };
+
+    class destructible
+    {
+    public:
+      destructible(constructor_param const&) {}
+      ~destructible() {}
+      void dummy_member() const {}
+
+    private:
+      destructible(destructible const&);
+      destructible& operator=(destructible const&);
+    };
+
+    class copy_constructible
+    {
+    public:
+      copy_constructible(constructor_param const&) {}
+      copy_constructible(copy_constructible const&) {}
+      ~copy_constructible() {}
+      void dummy_member() const {}
+
+    private:
+      copy_constructible& operator=(copy_constructible const&);
+      copy_constructible() {}
+    };
+
+    class copy_constructible_equality_comparable
+    {
+    public:
+      copy_constructible_equality_comparable(constructor_param const&) {}
+
+      copy_constructible_equality_comparable(
+        copy_constructible_equality_comparable const&)
+      {
+      }
+
+      ~copy_constructible_equality_comparable() {}
+
+      void dummy_member() const {}
+
+    private:
+      copy_constructible_equality_comparable& operator=(
+        copy_constructible_equality_comparable const&);
+      copy_constructible_equality_comparable() {}
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+      ampersand_operator_used operator&() const
+      {
+        return ampersand_operator_used();
+      }
+#endif
+    };
+
+    bool operator==(copy_constructible_equality_comparable,
+      copy_constructible_equality_comparable)
+    {
+      return true;
+    }
+
+    bool operator!=(copy_constructible_equality_comparable,
+      copy_constructible_equality_comparable)
+    {
+      return false;
+    }
+
+    class default_assignable
+    {
+    public:
+      default_assignable(constructor_param const&) {}
+
+      default_assignable() {}
+
+      default_assignable(default_assignable const&) {}
+
+      default_assignable& operator=(default_assignable const&) { return *this; }
+
+      ~default_assignable() {}
+
+      void dummy_member() const {}
+
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+      ampersand_operator_used operator&() const
+      {
+        return ampersand_operator_used();
+      }
+#endif
+    };
+
+    class assignable
+    {
+    public:
+      assignable(constructor_param const&) {}
+      assignable(assignable const&) {}
+      assignable& operator=(assignable const&) { return *this; }
+      ~assignable() {}
+      void dummy_member() const {}
+
+    private:
+      assignable() {}
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+      ampersand_operator_used operator&() const
+      {
+        return ampersand_operator_used();
+      }
+#endif
+    };
+
+    struct movable_init
+    {
+    };
+
+    class movable1
+    {
+      BOOST_MOVABLE_BUT_NOT_COPYABLE(movable1)
+
+    public:
+      movable1(constructor_param const&) {}
+      movable1() {}
+      explicit movable1(movable_init) {}
+      movable1(BOOST_RV_REF(movable1)) {}
+      movable1& operator=(BOOST_RV_REF(movable1)) { return *this; }
+      ~movable1() {}
+      void dummy_member() const {}
+    };
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    class movable2
+    {
+    public:
+      movable2(constructor_param const&) {}
+      explicit movable2(movable_init) {}
+      movable2(movable2&&) {}
+      ~movable2() {}
+      movable2& operator=(movable2&&) { return *this; }
+      void dummy_member() const {}
+
+    private:
+      movable2() {}
+      movable2(movable2 const&);
+      movable2& operator=(movable2 const&);
+    };
+#else
+    typedef movable1 movable2;
+#endif
+
+    template <class T> class hash
+    {
+    public:
+      hash(constructor_param const&) {}
+      hash() {}
+      hash(hash const&) {}
+      hash& operator=(hash const&) { return *this; }
+      ~hash() {}
+
+      std::size_t operator()(T const&) const { return 0; }
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+      ampersand_operator_used operator&() const
+      {
+        return ampersand_operator_used();
+      }
+#endif
+    };
+
+    template <class T> class equal_to
+    {
+    public:
+      equal_to(constructor_param const&) {}
+      equal_to() {}
+      equal_to(equal_to const&) {}
+      equal_to& operator=(equal_to const&) { return *this; }
+      ~equal_to() {}
+
+      bool operator()(T const&, T const&) const { return true; }
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+      ampersand_operator_used operator&() const
+      {
+        return ampersand_operator_used();
+      }
+#endif
+    };
+
+    template <class T> class ptr;
+    template <class T> class const_ptr;
+
+    struct void_ptr
+    {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+      template <typename T> friend class ptr;
+
+    private:
+#endif
+
+      void* ptr_;
+
+    public:
+      void_ptr() : ptr_(0) {}
+
+      template <typename T> explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+
+      // I'm not using the safe bool idiom because the containers should be
+      // able to cope with bool conversions.
+      operator bool() const { return !!ptr_; }
+
+      bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
+      bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
+    };
+
+    class void_const_ptr
+    {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+      template <typename T> friend class const_ptr;
+
+    private:
+#endif
+
+      void* ptr_;
+
+    public:
+      void_const_ptr() : ptr_(0) {}
+
+      template <typename T>
+      explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_)
+      {
+      }
+
+      // I'm not using the safe bool idiom because the containers should be
+      // able to cope with bool conversions.
+      operator bool() const { return !!ptr_; }
+
+      bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
+      bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
+    };
+
+    template <class T> class ptr
+    {
+      friend class allocator<T>;
+      friend class const_ptr<T>;
+      friend struct void_ptr;
+
+      T* ptr_;
+
+      ptr(T* x) : ptr_(x) {}
+
+    public:
+      ptr() : ptr_(0) {}
+      explicit ptr(void_ptr const& x) : ptr_((T*)x.ptr_) {}
+
+      T& operator*() const { return *ptr_; }
+      T* operator->() const { return ptr_; }
+      ptr& operator++()
+      {
+        ++ptr_;
+        return *this;
+      }
+      ptr operator++(int)
+      {
+        ptr tmp(*this);
+        ++ptr_;
+        return tmp;
+      }
+      ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
+      friend ptr operator+(std::ptrdiff_t s, ptr p)
+      {
+        return ptr<T>(s + p.ptr_);
+      }
+      T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
+      bool operator!() const { return !ptr_; }
+
+      // I'm not using the safe bool idiom because the containers should be
+      // able to cope with bool conversions.
+      operator bool() const { return !!ptr_; }
+
+      bool operator==(ptr const& x) const { return ptr_ == x.ptr_; }
+      bool operator!=(ptr const& x) const { return ptr_ != x.ptr_; }
+      bool operator<(ptr const& x) const { return ptr_ < x.ptr_; }
+      bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
+      bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
+      bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+      ampersand_operator_used operator&() const
+      {
+        return ampersand_operator_used();
+      }
+#endif
+    };
+
+    template <class T> class const_ptr
+    {
+      friend class allocator<T>;
+      friend struct const_void_ptr;
+
+      T const* ptr_;
+
+      const_ptr(T const* ptr) : ptr_(ptr) {}
+
+    public:
+      const_ptr() : ptr_(0) {}
+      const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+      explicit const_ptr(void_const_ptr const& x) : ptr_((T const*)x.ptr_) {}
+
+      T const& operator*() const { return *ptr_; }
+      T const* operator->() const { return ptr_; }
+      const_ptr& operator++()
+      {
+        ++ptr_;
+        return *this;
+      }
+      const_ptr operator++(int)
+      {
+        const_ptr tmp(*this);
+        ++ptr_;
+        return tmp;
+      }
+      const_ptr operator+(std::ptrdiff_t s) const
+      {
+        return const_ptr(ptr_ + s);
+      }
+      friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
+      {
+        return ptr<T>(s + p.ptr_);
+      }
+      T const& operator[](int s) const { return ptr_[s]; }
+      bool operator!() const { return !ptr_; }
+      operator bool() const { return !!ptr_; }
+
+      bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
+      bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
+      bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
+      bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
+      bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
+      bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+      ampersand_operator_used operator&() const
+      {
+        return ampersand_operator_used();
+      }
+#endif
+    };
+
+    template <class T> class allocator
+    {
+    public:
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef void_ptr void_pointer;
+      typedef void_const_ptr const_void_pointer;
+      typedef ptr<T> pointer;
+      typedef const_ptr<T> const_pointer;
+      typedef T& reference;
+      typedef T const& const_reference;
+      typedef T value_type;
+
+      template <class U> struct rebind
+      {
+        typedef allocator<U> other;
+      };
+
+      allocator() {}
+      template <class Y> allocator(allocator<Y> const&) {}
+      allocator(allocator const&) {}
+      ~allocator() {}
+
+      pointer address(reference r) { return pointer(&r); }
+      const_pointer address(const_reference r) { return const_pointer(&r); }
+
+      pointer allocate(size_type n)
+      {
+        return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+      }
+
+      template <class Y> pointer allocate(size_type n, const_ptr<Y>)
+      {
+        return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+      }
+
+      void deallocate(pointer p, size_type)
+      {
+        ::operator delete((void*)p.ptr_);
+      }
+
+      void construct(T* p, T const& t) { new ((void*)p) T(t); }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+      template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+      {
+        new ((void*)p) T(boost::forward<Args>(args)...);
+      }
+#endif
+
+      void destroy(T* p) { p->~T(); }
+
+      size_type max_size() const { return 1000; }
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) ||                             \
+  BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    public:
+      allocator& operator=(allocator const&) { return *this; }
+#else
+    private:
+      allocator& operator=(allocator const&);
+#endif
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+      ampersand_operator_used operator&() const
+      {
+        return ampersand_operator_used();
+      }
+#endif
+    };
+
+    template <class T> class allocator<T const>
+    {
+    public:
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef void_ptr void_pointer;
+      typedef void_const_ptr const_void_pointer;
+      // Maybe these two should be const_ptr<T>
+      typedef ptr<T const> pointer;
+      typedef const_ptr<T const> const_pointer;
+      typedef T const& reference;
+      typedef T const& const_reference;
+      typedef T const value_type;
+
+      template <class U> struct rebind
+      {
+        typedef allocator<U> other;
+      };
+
+      allocator() {}
+      template <class Y> allocator(allocator<Y> const&) {}
+      allocator(allocator const&) {}
+      ~allocator() {}
+
+      const_pointer address(const_reference r) { return const_pointer(&r); }
+
+      pointer allocate(size_type n)
+      {
+        return pointer(static_cast<T const*>(::operator new(n * sizeof(T))));
+      }
+
+      template <class Y> pointer allocate(size_type n, const_ptr<Y>)
+      {
+        return pointer(static_cast<T const*>(::operator new(n * sizeof(T))));
+      }
+
+      void deallocate(pointer p, size_type)
+      {
+        ::operator delete((void*)p.ptr_);
+      }
+
+      void construct(T const* p, T const& t) { new ((void*)p) T(t); }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+      template <class... Args>
+      void construct(T const* p, BOOST_FWD_REF(Args)... args)
+      {
+        new ((void*)p) T(boost::forward<Args>(args)...);
+      }
+#endif
+
+      void destroy(T const* p) { p->~T(); }
+
+      size_type max_size() const { return 1000; }
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) ||                             \
+  BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    public:
+      allocator& operator=(allocator const&) { return *this; }
+#else
+    private:
+      allocator& operator=(allocator const&);
+#endif
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+      ampersand_operator_used operator&() const
+      {
+        return ampersand_operator_used();
+      }
+#endif
+    };
+
+    template <class T>
+    inline bool operator==(allocator<T> const&, allocator<T> const&)
+    {
+      return true;
+    }
+
+    template <class T>
+    inline bool operator!=(allocator<T> const&, allocator<T> const&)
+    {
+      return false;
+    }
+
+    template <class T> void swap(allocator<T>&, allocator<T>&) {}
+
+    // C++11 allocator
+    //
+    // Not a fully minimal C++11 allocator, just what I support. Hopefully will
+    // cut down further in the future.
+
+    template <class T> class cxx11_allocator
+    {
+    public:
+      typedef T value_type;
+      // template <class U> struct rebind { typedef cxx11_allocator<U> other; };
+
+      cxx11_allocator() {}
+      template <class Y> cxx11_allocator(cxx11_allocator<Y> const&) {}
+      cxx11_allocator(cxx11_allocator const&) {}
+      ~cxx11_allocator() {}
+
+      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)));
+      }
+
+      template <class Y> T* allocate(std::size_t n, const_ptr<Y>)
+      {
+        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 ((void*)p) T(t); }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+      template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+      {
+        new ((void*)p) T(boost::forward<Args>(args)...);
+      }
+#endif
+
+      void destroy(T* p) { p->~T(); }
+
+      std::size_t max_size() const { return 1000u; }
+    };
+
+    template <class T>
+    inline bool operator==(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+    {
+      return true;
+    }
+
+    template <class T>
+    inline bool operator!=(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+    {
+      return false;
+    }
+
+    template <class T> void swap(cxx11_allocator<T>&, cxx11_allocator<T>&) {}
+  }
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace boost {
+#else
+namespace test {
+  namespace minimal {
+#endif
+  std::size_t hash_value(test::minimal::copy_constructible_equality_comparable)
+  {
+    return 1;
+  }
+#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+}
+}
+#else
+  }
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/src/boost/libs/unordered/test/objects/test.hpp b/src/boost/libs/unordered/test/objects/test.hpp
new file mode 100644
index 000000000..7ce21fa95
--- /dev/null
+++ b/src/boost/libs/unordered/test/objects/test.hpp
@@ -0,0 +1,700 @@
+
+// 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)
+
+#if !defined(BOOST_UNORDERED_TEST_OBJECTS_HEADER)
+#define BOOST_UNORDERED_TEST_OBJECTS_HEADER
+
+#include "../helpers/count.hpp"
+#include "../helpers/fwd.hpp"
+#include "../helpers/memory.hpp"
+#include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <cstddef>
+
+namespace test {
+  // Note that the default hash function will work for any equal_to (but not
+  // very well).
+  class object;
+  class movable;
+  class implicitly_convertible;
+  class hash;
+  class less;
+  class equal_to;
+  template <class T> class allocator1;
+  template <class T> class allocator2;
+  object generate(object const*, random_generator);
+  movable generate(movable const*, random_generator);
+  implicitly_convertible generate(
+    implicitly_convertible const*, random_generator);
+
+  inline void ignore_variable(void const*) {}
+
+  class object : private counted_object
+  {
+    friend class hash;
+    friend class equal_to;
+    friend class less;
+    int tag1_, tag2_;
+
+  public:
+    explicit object(int t1 = 0, int t2 = 0) : tag1_(t1), tag2_(t2) {}
+
+    ~object()
+    {
+      tag1_ = -1;
+      tag2_ = -1;
+    }
+
+    friend bool operator==(object const& x1, object const& x2)
+    {
+      return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
+    }
+
+    friend bool operator!=(object const& x1, object const& x2)
+    {
+      return x1.tag1_ != x2.tag1_ || x1.tag2_ != x2.tag2_;
+    }
+
+    friend bool operator<(object const& x1, object const& x2)
+    {
+      return x1.tag1_ < x2.tag1_ ||
+             (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
+    }
+
+    friend object generate(object const*, random_generator g)
+    {
+      int* x = 0;
+      return object(generate(x, g), generate(x, g));
+    }
+
+    friend std::ostream& operator<<(std::ostream& out, object const& o)
+    {
+      return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+    }
+  };
+
+  class movable : private counted_object
+  {
+    friend class hash;
+    friend class equal_to;
+    friend class less;
+    int tag1_, tag2_;
+
+    BOOST_COPYABLE_AND_MOVABLE(movable)
+  public:
+    explicit movable(int t1 = 0, int t2 = 0) : tag1_(t1), tag2_(t2) {}
+
+    movable(movable const& x)
+        : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
+    {
+      BOOST_TEST(x.tag1_ != -1);
+    }
+
+    movable(BOOST_RV_REF(movable) x)
+        : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
+    {
+      BOOST_TEST(x.tag1_ != -1);
+      x.tag1_ = -1;
+      x.tag2_ = -1;
+    }
+
+    movable& operator=(BOOST_COPY_ASSIGN_REF(movable) x) // Copy assignment
+    {
+      BOOST_TEST(x.tag1_ != -1);
+      tag1_ = x.tag1_;
+      tag2_ = x.tag2_;
+      return *this;
+    }
+
+    movable& operator=(BOOST_RV_REF(movable) x) // Move assignment
+    {
+      BOOST_TEST(x.tag1_ != -1);
+      tag1_ = x.tag1_;
+      tag2_ = x.tag2_;
+      x.tag1_ = -1;
+      x.tag2_ = -1;
+      return *this;
+    }
+
+    ~movable()
+    {
+      tag1_ = -1;
+      tag2_ = -1;
+    }
+
+    friend bool operator==(movable const& x1, movable const& x2)
+    {
+      BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
+      return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
+    }
+
+    friend bool operator!=(movable const& x1, movable const& x2)
+    {
+      BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
+      return x1.tag1_ != x2.tag1_ || x1.tag2_ != x2.tag2_;
+    }
+
+    friend bool operator<(movable const& x1, movable const& x2)
+    {
+      BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
+      return x1.tag1_ < x2.tag1_ ||
+             (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
+    }
+
+    friend movable generate(movable const*, random_generator g)
+    {
+      int* x = 0;
+      return movable(generate(x, g), generate(x, g));
+    }
+
+    friend std::ostream& operator<<(std::ostream& out, movable const& o)
+    {
+      return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+    }
+  };
+
+  class implicitly_convertible : private counted_object
+  {
+    int tag1_, tag2_;
+
+  public:
+    explicit implicitly_convertible(int t1 = 0, int t2 = 0)
+        : tag1_(t1), tag2_(t2)
+    {
+    }
+
+    operator object() const { return object(tag1_, tag2_); }
+
+    operator movable() const { return movable(tag1_, tag2_); }
+
+    friend implicitly_convertible generate(
+      implicitly_convertible const*, random_generator g)
+    {
+      int* x = 0;
+      return implicitly_convertible(generate(x, g), generate(x, g));
+    }
+
+    friend std::ostream& operator<<(
+      std::ostream& out, implicitly_convertible const& o)
+    {
+      return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
+    }
+  };
+
+  // Note: This is a deliberately bad hash function.
+  class hash
+  {
+    int type_;
+
+  public:
+    hash() : type_(0) {}
+
+    explicit hash(int t) : type_(t) {}
+
+    std::size_t operator()(object const& x) const
+    {
+      int result;
+      switch (type_) {
+      case 1:
+        result = x.tag1_;
+        break;
+      case 2:
+        result = x.tag2_;
+        break;
+      default:
+        result = x.tag1_ + x.tag2_;
+      }
+      return static_cast<std::size_t>(result);
+    }
+
+    std::size_t operator()(movable const& x) const
+    {
+      int result;
+      switch (type_) {
+      case 1:
+        result = x.tag1_;
+        break;
+      case 2:
+        result = x.tag2_;
+        break;
+      default:
+        result = x.tag1_ + x.tag2_;
+      }
+      return static_cast<std::size_t>(result);
+    }
+
+    std::size_t operator()(int x) const
+    {
+      int result;
+      switch (type_) {
+      case 1:
+        result = x;
+        break;
+      case 2:
+        result = x * 7;
+        break;
+      default:
+        result = x * 256;
+      }
+      return static_cast<std::size_t>(result);
+    }
+
+    friend bool operator==(hash const& x1, hash const& x2)
+    {
+      return x1.type_ == x2.type_;
+    }
+
+    friend bool operator!=(hash const& x1, hash const& x2)
+    {
+      return x1.type_ != x2.type_;
+    }
+  };
+
+  std::size_t hash_value(test::object const& x) { return hash()(x); }
+
+  std::size_t hash_value(test::movable const& x) { return hash()(x); }
+
+  class less
+  {
+    int type_;
+
+  public:
+    explicit less(int t = 0) : type_(t) {}
+
+    bool operator()(object const& x1, object const& x2) const
+    {
+      switch (type_) {
+      case 1:
+        return x1.tag1_ < x2.tag1_;
+      case 2:
+        return x1.tag2_ < x2.tag2_;
+      default:
+        return x1 < x2;
+      }
+    }
+
+    bool operator()(movable const& x1, movable const& x2) const
+    {
+      switch (type_) {
+      case 1:
+        return x1.tag1_ < x2.tag1_;
+      case 2:
+        return x1.tag2_ < x2.tag2_;
+      default:
+        return x1 < x2;
+      }
+    }
+
+    std::size_t operator()(int x1, int x2) const { return x1 < x2; }
+
+    friend bool operator==(less const& x1, less const& x2)
+    {
+      return x1.type_ == x2.type_;
+    }
+  };
+
+  class equal_to
+  {
+    int type_;
+
+  public:
+    equal_to() : type_(0) {}
+
+    explicit equal_to(int t) : type_(t) {}
+
+    bool operator()(object const& x1, object const& x2) const
+    {
+      switch (type_) {
+      case 1:
+        return x1.tag1_ == x2.tag1_;
+      case 2:
+        return x1.tag2_ == x2.tag2_;
+      default:
+        return x1 == x2;
+      }
+    }
+
+    bool operator()(movable const& x1, movable const& x2) const
+    {
+      switch (type_) {
+      case 1:
+        return x1.tag1_ == x2.tag1_;
+      case 2:
+        return x1.tag2_ == x2.tag2_;
+      default:
+        return x1 == x2;
+      }
+    }
+
+    std::size_t operator()(int x1, int x2) const { return x1 == x2; }
+
+    friend bool operator==(equal_to const& x1, equal_to const& x2)
+    {
+      return x1.type_ == x2.type_;
+    }
+
+    friend bool operator!=(equal_to const& x1, equal_to const& x2)
+    {
+      return x1.type_ != x2.type_;
+    }
+
+    friend less create_compare(equal_to x) { return less(x.type_); }
+  };
+
+  // allocator1 only has the old fashioned 'construct' method and has
+  // a few less typedefs. allocator2 uses a custom pointer class.
+
+  template <class T> class allocator1
+  {
+  public:
+    int tag_;
+
+    typedef T value_type;
+
+    template <class U> struct rebind
+    {
+      typedef allocator1<U> other;
+    };
+
+    allocator1() : tag_(0) { detail::tracker.allocator_ref(); }
+
+    explicit allocator1(int t) : tag_(t) { detail::tracker.allocator_ref(); }
+
+    template <class Y> allocator1(allocator1<Y> const& x) : tag_(x.tag_)
+    {
+      detail::tracker.allocator_ref();
+    }
+
+    allocator1(allocator1 const& x) : tag_(x.tag_)
+    {
+      detail::tracker.allocator_ref();
+    }
+
+    ~allocator1() { detail::tracker.allocator_unref(); }
+
+    T* allocate(std::size_t n)
+    {
+      T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+      detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+      return ptr;
+    }
+
+    T* allocate(std::size_t n, void const*)
+    {
+      T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+      detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+      return ptr;
+    }
+
+    void deallocate(T* p, std::size_t n)
+    {
+      detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
+      ::operator delete((void*)p);
+    }
+
+#if BOOST_UNORDERED_CXX11_CONSTRUCTION
+    template <typename U, typename... Args> void construct(U* p, Args&&... args)
+    {
+      detail::tracker.track_construct((void*)p, sizeof(U), tag_);
+      new (p) U(boost::forward<Args>(args)...);
+    }
+
+    template <typename U> void destroy(U* p)
+    {
+      detail::tracker.track_destroy((void*)p, sizeof(U), tag_);
+      p->~U();
+
+      // Work around MSVC buggy unused parameter warning.
+      ignore_variable(&p);
+    }
+#else
+  private:
+    // I'm going to claim in the documentation that construct/destroy
+    // is never used when C++11 support isn't available, so might as
+    // well check that in the text.
+    // TODO: Or maybe just disallow them for values?
+    template <typename U> void construct(U* p);
+    template <typename U, typename A0> void construct(U* p, A0 const&);
+    template <typename U, typename A0, typename A1>
+    void construct(U* p, A0 const&, A1 const&);
+    template <typename U, typename A0, typename A1, typename A2>
+    void construct(U* p, A0 const&, A1 const&, A2 const&);
+    template <typename U> void destroy(U* p);
+
+  public:
+#endif
+
+    bool operator==(allocator1 const& x) const { return tag_ == x.tag_; }
+
+    bool operator!=(allocator1 const& x) const { return tag_ != x.tag_; }
+
+    enum
+    {
+      is_select_on_copy = false,
+      is_propagate_on_swap = false,
+      is_propagate_on_assign = false,
+      is_propagate_on_move = false
+    };
+  };
+
+  template <class T> class ptr;
+  template <class T> class const_ptr;
+
+  struct void_ptr
+  {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+    template <typename T> friend class ptr;
+
+  private:
+#endif
+
+    void* ptr_;
+
+  public:
+    void_ptr() : ptr_(0) {}
+
+    template <typename T> explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
+
+    bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
+  };
+
+  class void_const_ptr
+  {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+    template <typename T> friend class const_ptr;
+
+  private:
+#endif
+
+    void* ptr_;
+
+  public:
+    void_const_ptr() : ptr_(0) {}
+
+    template <typename T>
+    explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_)
+    {
+    }
+
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
+
+    bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
+  };
+
+  template <class T> class ptr
+  {
+    friend class allocator2<T>;
+    friend class const_ptr<T>;
+    friend struct void_ptr;
+
+    T* ptr_;
+
+    ptr(T* x) : ptr_(x) {}
+
+  public:
+    ptr() : ptr_(0) {}
+    explicit ptr(void_ptr const& x) : ptr_((T*)x.ptr_) {}
+
+    T& operator*() const { return *ptr_; }
+    T* operator->() const { return ptr_; }
+    ptr& operator++()
+    {
+      ++ptr_;
+      return *this;
+    }
+    ptr operator++(int)
+    {
+      ptr tmp(*this);
+      ++ptr_;
+      return tmp;
+    }
+    ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
+    friend ptr operator+(std::ptrdiff_t s, ptr p) { return ptr<T>(s + p.ptr_); }
+    T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
+    bool operator!() const { return !ptr_; }
+
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
+
+    bool operator==(ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(ptr const& x) const { return ptr_ != x.ptr_; }
+    bool operator<(ptr const& x) const { return ptr_ < x.ptr_; }
+    bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
+    bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
+    bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
+  };
+
+  template <class T> class const_ptr
+  {
+    friend class allocator2<T>;
+    friend struct const_void_ptr;
+
+    T const* ptr_;
+
+    const_ptr(T const* ptr) : ptr_(ptr) {}
+
+  public:
+    const_ptr() : ptr_(0) {}
+    const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+    explicit const_ptr(void_const_ptr const& x) : ptr_((T const*)x.ptr_) {}
+
+    T const& operator*() const { return *ptr_; }
+    T const* operator->() const { return ptr_; }
+    const_ptr& operator++()
+    {
+      ++ptr_;
+      return *this;
+    }
+    const_ptr operator++(int)
+    {
+      const_ptr tmp(*this);
+      ++ptr_;
+      return tmp;
+    }
+    const_ptr operator+(std::ptrdiff_t s) const { return const_ptr(ptr_ + s); }
+    friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
+    {
+      return ptr<T>(s + p.ptr_);
+    }
+    T const& operator[](int s) const { return ptr_[s]; }
+    bool operator!() const { return !ptr_; }
+    operator bool() const { return !!ptr_; }
+
+    bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
+    bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
+    bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
+    bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
+    bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
+  };
+
+  template <class T> class allocator2
+  {
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+  public:
+#else
+    template <class> friend class allocator2;
+#endif
+    int tag_;
+
+  public:
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef void_ptr void_pointer;
+    typedef void_const_ptr const_void_pointer;
+    typedef ptr<T> pointer;
+    typedef const_ptr<T> const_pointer;
+    typedef T& reference;
+    typedef T const& const_reference;
+    typedef T value_type;
+
+    template <class U> struct rebind
+    {
+      typedef allocator2<U> other;
+    };
+
+    allocator2() : tag_(0) { detail::tracker.allocator_ref(); }
+
+    explicit allocator2(int t) : tag_(t) { detail::tracker.allocator_ref(); }
+
+    template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
+    {
+      detail::tracker.allocator_ref();
+    }
+
+    allocator2(allocator2 const& x) : tag_(x.tag_)
+    {
+      detail::tracker.allocator_ref();
+    }
+
+    ~allocator2() { detail::tracker.allocator_unref(); }
+
+    pointer address(reference r) { return pointer(&r); }
+
+    const_pointer address(const_reference r) { return const_pointer(&r); }
+
+    pointer allocate(size_type n)
+    {
+      pointer p(static_cast<T*>(::operator new(n * sizeof(T))));
+      detail::tracker.track_allocate((void*)p.ptr_, n, sizeof(T), tag_);
+      return p;
+    }
+
+    pointer allocate(size_type n, void const*)
+    {
+      pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+      detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+      return ptr;
+    }
+
+    void deallocate(pointer p, size_type n)
+    {
+      detail::tracker.track_deallocate((void*)p.ptr_, n, sizeof(T), tag_);
+      ::operator delete((void*)p.ptr_);
+    }
+
+    void construct(T* p, T const& t)
+    {
+      detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+      new (p) T(t);
+    }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+    {
+      detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+      new (p) T(boost::forward<Args>(args)...);
+    }
+#endif
+
+    void destroy(T* p)
+    {
+      detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+      p->~T();
+    }
+
+    size_type max_size() const
+    {
+      return (std::numeric_limits<size_type>::max)();
+    }
+
+    bool operator==(allocator2 const& x) const { return tag_ == x.tag_; }
+
+    bool operator!=(allocator2 const& x) const { return tag_ != x.tag_; }
+
+    enum
+    {
+      is_select_on_copy = false,
+      is_propagate_on_swap = false,
+      is_propagate_on_assign = false,
+      is_propagate_on_move = false
+    };
+  };
+
+  template <class T>
+  bool equivalent_impl(
+    allocator1<T> const& x, allocator1<T> const& y, test::derived_type)
+  {
+    return x == y;
+  }
+
+  template <class T>
+  bool equivalent_impl(
+    allocator2<T> const& x, allocator2<T> const& y, test::derived_type)
+  {
+    return x == y;
+  }
+}
+
+#endif
diff --git a/src/boost/libs/unordered/test/unordered/allocator_traits.cpp b/src/boost/libs/unordered/test/unordered/allocator_traits.cpp
new file mode 100644
index 000000000..476205b7b
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/allocator_traits.cpp
@@ -0,0 +1,288 @@
+
+// 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/core/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&) const { return true; }                       \
+  bool operator!=(name<T> const&) 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(traits::is_always_equal::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;
+  typedef yes_type is_always_equal;
+
+  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(traits::is_always_equal::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;
+  typedef no_type is_always_equal;
+};
+
+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(!traits::is_always_equal::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;
+
+  int x; // Just to make it non-empty, so that is_always_equal is false.
+
+  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(!traits::is_always_equal::value);
+  BOOST_TEST(call_select<allocator>() == 1);
+}
+
+int main()
+{
+  test_empty_allocator();
+  test_allocator1();
+  test_allocator2();
+  test_allocator3();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/unordered/test/unordered/assign_tests.cpp b/src/boost/libs/unordered/test/unordered/assign_tests.cpp
new file mode 100644
index 000000000..f3d633b0a
--- /dev/null
+++ b/src/boost/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)
+  {
+    typename T::hasher hf;
+    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)
+  {
+    typename T::hasher hf1(1);
+    typename T::hasher hf2(2);
+    typename T::key_equal eq1(1);
+    typename T::key_equal eq2(2);
+    typename T::allocator_type al1(1);
+    typename T::allocator_type al2(2);
+
+    typedef 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()
diff --git a/src/boost/libs/unordered/test/unordered/at_tests.cpp b/src/boost/libs/unordered/test/unordered/at_tests.cpp
new file mode 100644
index 000000000..25b0951ad
--- /dev/null
+++ b/src/boost/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()
diff --git a/src/boost/libs/unordered/test/unordered/bucket_tests.cpp b/src/boost/libs/unordered/test/unordered/bucket_tests.cpp
new file mode 100644
index 000000000..c314d2c56
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/bucket_tests.cpp
@@ -0,0 +1,94 @@
+
+// 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 typename X::size_type size_type;
+    typedef 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 (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()
diff --git a/src/boost/libs/unordered/test/unordered/compile_map.cpp b/src/boost/libs/unordered/test/unordered/compile_map.cpp
new file mode 100644
index 000000000..6a84d595a
--- /dev/null
+++ b/src/boost/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()
diff --git a/src/boost/libs/unordered/test/unordered/compile_set.cpp b/src/boost/libs/unordered/test/unordered/compile_set.cpp
new file mode 100644
index 000000000..727294f39
--- /dev/null
+++ b/src/boost/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()
diff --git a/src/boost/libs/unordered/test/unordered/compile_tests.hpp b/src/boost/libs/unordered/test/unordered/compile_tests.hpp
new file mode 100644
index 000000000..bb5256f8b
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/compile_tests.hpp
@@ -0,0 +1,913 @@
+
+// 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/core/pointer_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_const.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 typename X::iterator iterator;
+  typedef typename X::const_iterator const_iterator;
+  typedef typename X::difference_type difference_type;
+  typedef typename X::size_type size_type;
+
+  typedef
+    typename std::iterator_traits<iterator>::value_type iterator_value_type;
+  typedef typename std::iterator_traits<const_iterator>::value_type
+    const_iterator_value_type;
+  typedef typename std::iterator_traits<iterator>::difference_type
+    iterator_difference_type;
+  typedef typename std::iterator_traits<const_iterator>::difference_type
+    const_iterator_difference_type;
+
+  typedef typename X::value_type value_type;
+  typedef typename X::reference reference;
+  typedef typename X::const_reference const_reference;
+
+  typedef typename X::node_type node_type;
+
+  typedef 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, 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 typename X::iterator iterator;
+  typedef typename X::const_iterator const_iterator;
+  typedef 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 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 typename X::value_type value_type;
+  typedef typename X::key_type key_type;
+
+  BOOST_STATIC_ASSERT((boost::is_same<value_type, key_type>::value));
+
+  // iterator pointer / const_pointer_type
+
+  typedef typename X::iterator iterator;
+  typedef typename X::const_iterator const_iterator;
+  typedef typename X::local_iterator local_iterator;
+  typedef typename X::const_local_iterator const_local_iterator;
+  typedef typename std::iterator_traits<iterator>::pointer iterator_pointer;
+  typedef typename std::iterator_traits<const_iterator>::pointer
+    const_iterator_pointer;
+  typedef typename std::iterator_traits<local_iterator>::pointer
+    local_iterator_pointer;
+  typedef typename std::iterator_traits<const_local_iterator>::pointer
+    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));
+
+  // pointer_traits<iterator>
+
+  BOOST_STATIC_ASSERT((boost::is_same<iterator,
+    typename boost::pointer_traits<iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<value_type const,
+    typename boost::pointer_traits<iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
+    typename boost::pointer_traits<iterator>::difference_type>::value));
+
+  // pointer_traits<const_iterator>
+
+  BOOST_STATIC_ASSERT((boost::is_same<const_iterator,
+    typename boost::pointer_traits<const_iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<value_type const,
+    typename boost::pointer_traits<const_iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
+    typename boost::pointer_traits<const_iterator>::difference_type>::value));
+
+  // pointer_traits<local_iterator>
+
+  BOOST_STATIC_ASSERT((boost::is_same<local_iterator,
+    typename boost::pointer_traits<local_iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<value_type const,
+    typename boost::pointer_traits<local_iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
+    typename boost::pointer_traits<local_iterator>::difference_type>::value));
+
+  // pointer_traits<const_local_iterator>
+
+  BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator,
+    typename boost::pointer_traits<const_local_iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<value_type const,
+    typename boost::pointer_traits<const_local_iterator>::element_type>::
+      value));
+  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
+    typename boost::pointer_traits<const_local_iterator>::difference_type>::
+      value));
+
+  typedef typename X::node_type node_type;
+  typedef 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 typename X::value_type value_type;
+  typedef 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 typename X::iterator iterator;
+  typedef typename X::const_iterator const_iterator;
+  typedef typename X::local_iterator local_iterator;
+  typedef typename X::const_local_iterator const_local_iterator;
+  typedef typename std::iterator_traits<iterator>::pointer iterator_pointer;
+  typedef typename std::iterator_traits<const_iterator>::pointer
+    const_iterator_pointer;
+  typedef typename std::iterator_traits<local_iterator>::pointer
+    local_iterator_pointer;
+  typedef typename std::iterator_traits<const_local_iterator>::pointer
+    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));
+
+  // pointer_traits<iterator>
+
+  BOOST_STATIC_ASSERT((boost::is_same<iterator,
+    typename boost::pointer_traits<iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<value_type,
+    typename boost::pointer_traits<iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
+    typename boost::pointer_traits<iterator>::difference_type>::value));
+
+  // pointer_traits<const_iterator>
+
+  BOOST_STATIC_ASSERT((boost::is_same<const_iterator,
+    typename boost::pointer_traits<const_iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<value_type const,
+    typename boost::pointer_traits<const_iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
+    typename boost::pointer_traits<const_iterator>::difference_type>::value));
+
+  // pointer_traits<local_iterator>
+
+  BOOST_STATIC_ASSERT((boost::is_same<local_iterator,
+    typename boost::pointer_traits<local_iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<value_type,
+    typename boost::pointer_traits<local_iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
+    typename boost::pointer_traits<local_iterator>::difference_type>::value));
+
+  // pointer_traits<const_local_iterator>
+
+  BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator,
+    typename boost::pointer_traits<const_local_iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<value_type const,
+    typename boost::pointer_traits<const_local_iterator>::element_type>::
+      value));
+  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
+    typename boost::pointer_traits<const_local_iterator>::difference_type>::
+      value));
+
+  typedef typename X::node_type node_type;
+  typedef typename node_type::key_type node_key_type;
+  typedef 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 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 typename X::node_type node_type;
+  typedef 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 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 typename X::mapped_type mapped_type;
+  typedef 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 typename X::key_type key_type;
+  typedef typename X::hasher hasher;
+  typedef typename X::key_equal key_equal;
+  typedef typename X::size_type size_type;
+
+  typedef typename X::iterator iterator;
+  typedef typename X::const_iterator const_iterator;
+  typedef typename X::local_iterator local_iterator;
+  typedef typename X::const_local_iterator const_local_iterator;
+
+  typedef typename std::iterator_traits<iterator>::iterator_category
+    iterator_category;
+  typedef typename std::iterator_traits<iterator>::difference_type
+    iterator_difference;
+  typedef typename std::iterator_traits<iterator>::pointer iterator_pointer;
+  typedef typename std::iterator_traits<iterator>::reference iterator_reference;
+
+  typedef typename std::iterator_traits<local_iterator>::iterator_category
+    local_iterator_category;
+  typedef typename std::iterator_traits<local_iterator>::difference_type
+    local_iterator_difference;
+  typedef typename std::iterator_traits<local_iterator>::pointer
+    local_iterator_pointer;
+  typedef typename std::iterator_traits<local_iterator>::reference
+    local_iterator_reference;
+
+  typedef typename std::iterator_traits<const_iterator>::iterator_category
+    const_iterator_category;
+  typedef typename std::iterator_traits<const_iterator>::difference_type
+    const_iterator_difference;
+  typedef typename std::iterator_traits<const_iterator>::pointer
+    const_iterator_pointer;
+  typedef typename std::iterator_traits<const_iterator>::reference
+    const_iterator_reference;
+
+  typedef typename std::iterator_traits<const_local_iterator>::iterator_category
+    const_local_iterator_category;
+  typedef typename std::iterator_traits<const_local_iterator>::difference_type
+    const_local_iterator_difference;
+  typedef typename std::iterator_traits<const_local_iterator>::pointer
+    const_local_iterator_pointer;
+  typedef typename std::iterator_traits<const_local_iterator>::reference
+    const_local_iterator_reference;
+  typedef 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 typename X::iterator iterator;
+  typedef typename X::const_iterator const_iterator;
+  typedef typename X::allocator_type allocator_type;
+
+  X a;
+  allocator_type m = a.get_allocator();
+
+  typename X::value_type* i = 0;
+  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 typename X::node_type node_type;
+  typedef 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 typename X::iterator iterator;
+  typedef typename X::const_iterator const_iterator;
+  typedef 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();
+}
diff --git a/src/boost/libs/unordered/test/unordered/constructor_tests.cpp b/src/boost/libs/unordered/test/unordered/constructor_tests.cpp
new file mode 100644
index 000000000..5f5719864
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/constructor_tests.cpp
@@ -0,0 +1,446 @@
+
+// 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)
+  {
+    typename T::hasher hf;
+    typename T::key_equal eq;
+    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)
+  {
+    typename T::hasher hf;
+    typename T::hasher hf1(1);
+    typename T::hasher hf2(2);
+    typename T::key_equal eq;
+    typename T::key_equal eq1(1);
+    typename T::key_equal eq2(2);
+    typename T::allocator_type al;
+    typename T::allocator_type al1(1);
+    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);
+      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);
+      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<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<typename T::key_type, 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()
diff --git a/src/boost/libs/unordered/test/unordered/copy_tests.cpp b/src/boost/libs/unordered/test/unordered/copy_tests.cpp
new file mode 100644
index 000000000..1f1ac8f5a
--- /dev/null
+++ b/src/boost/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 typename T::allocator_type allocator_type;
+
+    typename T::hasher hf;
+    typename T::key_equal eq;
+    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)
+  {
+    typename T::hasher hf(1);
+    typename T::key_equal eq(1);
+    typename T::allocator_type al(1);
+    typename T::allocator_type al2(2);
+
+    typedef 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()
diff --git a/src/boost/libs/unordered/test/unordered/deduction_tests.cpp b/src/boost/libs/unordered/test/unordered/deduction_tests.cpp
new file mode 100644
index 000000000..673c0609e
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/deduction_tests.cpp
@@ -0,0 +1,352 @@
+
+// Copyright 2017-2018 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 <iostream>
+#include <vector>
+
+#if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
+struct hash_equals
+{
+  template <typename T> bool operator()(T const& x) const
+  {
+    boost::hash<T> hf;
+    return hf(x);
+  }
+
+  template <typename T> bool operator()(T const& x, T const& y) const
+  {
+    std::equal_to<T> eq;
+    return eq(x, y);
+  }
+};
+
+template <typename T> struct test_allocator
+{
+  typedef T value_type;
+  test_allocator() = default;
+  template <typename T2> test_allocator(test_allocator<T2> const&) {}
+  T* allocate(std::size_t n) const { return (T*)malloc(sizeof(T) * n); }
+  void deallocate(T* ptr, std::size_t) const { free(ptr); }
+  bool operator==(test_allocator const&) { return true; }
+  bool operator!=(test_allocator const&) { return false; }
+};
+#endif
+
+int main()
+{
+  std::cout << "BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES: "
+            << BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES << std::endl;
+
+#if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
+  std::vector<std::pair<int, int> > x;
+  x.push_back(std::make_pair(1, 3));
+  x.push_back(std::make_pair(5, 10));
+  test_allocator<std::pair<const int, int> > pair_allocator;
+  hash_equals f;
+
+  // unordered_map
+
+  /*
+   template<class InputIterator,
+           class Hash = hash<iter_key_t<InputIterator>>,
+           class Pred = equal_to<iter_key_t<InputIterator>>,
+           class Allocator = allocator<iter_to_alloc_t<InputIterator>>>
+    unordered_map(InputIterator, InputIterator, typename see below::size_type =
+   see below,
+                  Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+      -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
+   Hash, Pred,
+                       Allocator>;
+  */
+
+  {
+    boost::unordered_map m(x.begin(), x.end());
+    static_assert(
+      std::is_same<decltype(m), boost::unordered_map<int, int> >::value);
+  }
+
+  /* Ambiguous:
+  {
+    boost::unordered_map m(x.begin(), x.end(), 0, std::hash<int>());
+    static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
+  std::hash<int>>>::value);
+  }
+
+  {
+    boost::unordered_map m(x.begin(), x.end(), 0, std::hash<int>(),
+  std::equal_to<int>());
+    static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
+  std::hash<int>, std::equal_to<int>>>::value);
+  }
+  */
+
+  {
+    boost::unordered_map m(x.begin(), x.end(), 0, std::hash<int>(),
+      std::equal_to<int>(), pair_allocator);
+    static_assert(std::is_same<decltype(m),
+      boost::unordered_map<int, int, std::hash<int>, std::equal_to<int>,
+        test_allocator<std::pair<const int, int> > > >::value);
+  }
+
+  /*
+  template<class Key, class T, class Hash = hash<Key>,
+           class Pred = equal_to<Key>, class Allocator = allocator<pair<const
+  Key, T>>>
+    unordered_map(initializer_list<pair<const Key, T>>,
+                  typename see below::size_type = see below, Hash = Hash(),
+                  Pred = Pred(), Allocator = Allocator())
+      -> unordered_map<Key, T, Hash, Pred, Allocator>;
+  */
+
+  {
+    boost::unordered_map m({std::pair<int const, int>(1, 2)});
+    static_assert(
+      std::is_same<decltype(m), boost::unordered_map<int, int> >::value);
+  }
+
+  /* Ambiguous
+  {
+    boost::unordered_map m({std::pair<int const, int>(1,2)}, 0,
+  std::hash<int>());
+    static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
+  std::hash<int>>>::value);
+  }
+
+  {
+    boost::unordered_map m({std::pair<int const, int>(1,2)}, 0,
+  std::hash<int>(), std::equal_to<int>());
+    static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
+  std::hash<int>, std::equal_to<int>>>::value);
+  }
+  */
+
+  {
+    boost::unordered_map m(
+      {std::pair<int const, int>(1, 2)}, 0, f, f, pair_allocator);
+    static_assert(std::is_same<decltype(m),
+      boost::unordered_map<int, int, hash_equals, hash_equals,
+        test_allocator<std::pair<const int, int> > > >::value);
+  }
+
+  /*
+  template<class InputIterator, class Allocator>
+    unordered_map(InputIterator, InputIterator, typename see below::size_type,
+  Allocator)
+      -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
+                       hash<iter_key_t<InputIterator>>,
+  equal_to<iter_key_t<InputIterator>>,
+                       Allocator>;
+  */
+
+  /* Ambiguous
+  {
+    boost::unordered_map m(x.begin(), x.end(), 0u, pair_allocator);
+    static_assert(std::is_same<decltype(m), boost::unordered_map<int, int,
+  boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
+  int>>>>::value);
+  }
+  */
+
+  /*
+    template<class InputIterator, class Allocator>
+    unordered_map(InputIterator, InputIterator, Allocator)
+      -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
+                       hash<iter_key_t<InputIterator>>,
+    equal_to<iter_key_t<InputIterator>>,
+                       Allocator>;
+  */
+
+  /* No constructor:
+  {
+    boost::unordered_map m(x.begin(), x.end(), pair_allocator);
+    static_assert(std::is_same<decltype(m), boost::unordered_map<int, int,
+  boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
+  int>>>>::value);
+  }
+  */
+
+  /*
+  template<class InputIterator, class Hash, class Allocator>
+    unordered_map(InputIterator, InputIterator, typename see below::size_type,
+  Hash, Allocator)
+      -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
+  Hash,
+                       equal_to<iter_key_t<InputIterator>>, Allocator>;
+  */
+
+  /* Ambiguous
+  {
+    boost::unordered_map m(x.begin(), x.end(), 0u, f, pair_allocator);
+    static_assert(std::is_same<decltype(m), boost::unordered_map<int, int,
+  hash_equals, std::equal_to<int>, test_allocator<std::pair<const int,
+  int>>>>::value);
+  }
+  */
+
+  /*
+    template<class Key, class T, typename Allocator>
+    unordered_map(initializer_list<pair<const Key, T>>, typename see
+    below::size_type,
+                  Allocator)
+      -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+  */
+
+  /* Ambiguous
+  {
+    boost::unordered_map m({std::pair<int const, int>(1,2)}, 0, pair_allocator);
+    static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
+  boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
+  int>>>>::value);
+  }
+  */
+
+  /*
+  template<class Key, class T, typename Allocator>
+    unordered_map(initializer_list<pair<const Key, T>>, Allocator)
+      -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+  */
+
+  {
+    boost::unordered_map m({std::pair<int const, int>(1, 2)}, pair_allocator);
+    static_assert(std::is_same<decltype(m),
+      boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+        test_allocator<std::pair<const int, int> > > >::value);
+  }
+
+  /*
+  template<class Key, class T, class Hash, class Allocator>
+    unordered_map(initializer_list<pair<const Key, T>>, typename see
+  below::size_type, Hash,
+                  Allocator)
+      -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
+  */
+
+  /* Ambiguous
+  {
+    boost::unordered_map m({std::pair<int const, int>(1,2)}, 0, f,
+  pair_allocator);
+    static_assert(std::is_same<decltype(m),boost::unordered_map<int, int,
+  boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
+  int>>>>::value);
+  }
+  */
+
+  // unordered_multimap
+
+  {
+    boost::unordered_multimap m(x.begin(), x.end());
+    static_assert(
+      std::is_same<decltype(m), boost::unordered_multimap<int, int> >::value);
+  }
+
+  /* Ambiguous:
+  {
+    boost::unordered_multimap m(x.begin(), x.end(), 0, std::hash<int>());
+    static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
+  std::hash<int>>>::value);
+  }
+
+  {
+    boost::unordered_multimap m(x.begin(), x.end(), 0, std::hash<int>(),
+  std::equal_to<int>());
+    static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
+  std::hash<int>, std::equal_to<int>>>::value);
+  }
+  */
+
+  {
+    boost::unordered_multimap m(x.begin(), x.end(), 0, std::hash<int>(),
+      std::equal_to<int>(), pair_allocator);
+    static_assert(std::is_same<decltype(m),
+      boost::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>,
+        test_allocator<std::pair<const int, int> > > >::value);
+  }
+
+  {
+    boost::unordered_multimap m({std::pair<int const, int>(1, 2)});
+    static_assert(
+      std::is_same<decltype(m), boost::unordered_multimap<int, int> >::value);
+  }
+
+  /* Ambiguous
+  {
+    boost::unordered_multimap m({std::pair<int const, int>(1,2)}, 0,
+  std::hash<int>());
+    static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
+  std::hash<int>>>::value);
+  }
+
+  {
+    boost::unordered_multimap m({std::pair<int const, int>(1,2)}, 0,
+  std::hash<int>(), std::equal_to<int>());
+    static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
+  std::hash<int>, std::equal_to<int>>>::value);
+  }
+  */
+
+  {
+    boost::unordered_multimap m(
+      {std::pair<int const, int>(1, 2)}, 0, f, f, pair_allocator);
+    static_assert(std::is_same<decltype(m),
+      boost::unordered_multimap<int, int, hash_equals, hash_equals,
+        test_allocator<std::pair<const int, int> > > >::value);
+  }
+
+  /* Ambiguous
+  {
+    boost::unordered_multimap m(x.begin(), x.end(), 0u, pair_allocator);
+    static_assert(std::is_same<decltype(m), boost::unordered_multimap<int, int,
+  boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
+  int>>>>::value);
+  }
+  */
+
+  /* No constructor:
+  {
+    boost::unordered_multimap m(x.begin(), x.end(), pair_allocator);
+    static_assert(std::is_same<decltype(m), boost::unordered_multimap<int, int,
+  boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
+  int>>>>::value);
+  }
+  */
+
+  /* Ambiguous
+  {
+    boost::unordered_multimap m(x.begin(), x.end(), 0u, f, pair_allocator);
+    static_assert(std::is_same<decltype(m), boost::unordered_multimap<int, int,
+  hash_equals, std::equal_to<int>, test_allocator<std::pair<const int,
+  int>>>>::value);
+  }
+
+  {
+    boost::unordered_multimap m({std::pair<int const, int>(1,2)}, 0,
+  pair_allocator);
+    static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
+  boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
+  int>>>>::value);
+  }
+  */
+
+  {
+    boost::unordered_multimap m(
+      {std::pair<int const, int>(1, 2)}, pair_allocator);
+    static_assert(std::is_same<decltype(m),
+      boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
+        test_allocator<std::pair<const int, int> > > >::value);
+  }
+
+/* Ambiguous
+{
+  boost::unordered_multimap m({std::pair<int const, int>(1,2)}, 0, f,
+pair_allocator);
+  static_assert(std::is_same<decltype(m),boost::unordered_multimap<int, int,
+boost::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int,
+int>>>>::value);
+}
+*/
+
+#endif
+}
diff --git a/src/boost/libs/unordered/test/unordered/detail_tests.cpp b/src/boost/libs/unordered/test/unordered/detail_tests.cpp
new file mode 100644
index 000000000..545c83813
--- /dev/null
+++ b/src/boost/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()
diff --git a/src/boost/libs/unordered/test/unordered/emplace_tests.cpp b/src/boost/libs/unordered/test/unordered/emplace_tests.cpp
new file mode 100644
index 000000000..b424d3d7a
--- /dev/null
+++ b/src/boost/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()
diff --git a/src/boost/libs/unordered/test/unordered/equality_tests.cpp b/src/boost/libs/unordered/test/unordered/equality_tests.cpp
new file mode 100644
index 000000000..b1029af40
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/equality_tests.cpp
@@ -0,0 +1,156 @@
+
+// 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)                            \
+  {                                                                            \
+    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);                                                  \
+  }
+
+#define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2)                       \
+  {                                                                            \
+    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);                                                  \
+  }
+
+#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2)                            \
+  {                                                                            \
+    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);                                                  \
+  }
+
+#define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2)                       \
+  {                                                                            \
+    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);                                                  \
+  }
+
+#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()
diff --git a/src/boost/libs/unordered/test/unordered/equivalent_keys_tests.cpp b/src/boost/libs/unordered/test/unordered/equivalent_keys_tests.cpp
new file mode 100644
index 000000000..f040819db
--- /dev/null
+++ b/src/boost/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()
diff --git a/src/boost/libs/unordered/test/unordered/erase_equiv_tests.cpp b/src/boost/libs/unordered/test/unordered/erase_equiv_tests.cpp
new file mode 100644
index 000000000..effe0cd54
--- /dev/null
+++ b/src/boost/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()
diff --git a/src/boost/libs/unordered/test/unordered/erase_tests.cpp b/src/boost/libs/unordered/test/unordered/erase_tests.cpp
new file mode 100644
index 000000000..fecb7dc0a
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/erase_tests.cpp
@@ -0,0 +1,267 @@
+
+// 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 typename Container::iterator iterator;
+    typedef 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 (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()) {
+        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);
+        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);
+          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()) {
+        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());
+        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);
+        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()
diff --git a/src/boost/libs/unordered/test/unordered/extract_tests.cpp b/src/boost/libs/unordered/test/unordered/extract_tests.cpp
new file mode 100644
index 000000000..143387386
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/extract_tests.cpp
@@ -0,0 +1,133 @@
+
+// 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"
+
+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 (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()) {
+        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();
+        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);
+        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 == test::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()
diff --git a/src/boost/libs/unordered/test/unordered/find_tests.cpp b/src/boost/libs/unordered/test/unordered/find_tests.cpp
new file mode 100644
index 000000000..031371c32
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/find_tests.cpp
@@ -0,0 +1,157 @@
+
+// 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 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 (typename test::ordered<X>::const_iterator it1 = tracker.begin();
+           it1 != tracker.end(); ++it1) {
+        typename X::key_type key = test::get_key<X>(*it1);
+        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),
+          (typename X::value_type*)0);
+        test::compare_pairs(x_const.equal_range(key), tracker.equal_range(key),
+          (typename X::value_type*)0);
+      }
+
+      test::random_values<X> v2(500, generator);
+      for (typename test::random_values<X>::const_iterator it2 = v2.begin();
+           it2 != v2.end(); ++it2) {
+        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 (typename test::random_values<X>::const_iterator it3 = v2.begin();
+           it3 != v2.end(); ++it3) {
+        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 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) {
+      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) {
+      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()
diff --git a/src/boost/libs/unordered/test/unordered/fwd_map_test.cpp b/src/boost/libs/unordered/test/unordered/fwd_map_test.cpp
new file mode 100644
index 000000000..0c7df04fd
--- /dev/null
+++ b/src/boost/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()
diff --git a/src/boost/libs/unordered/test/unordered/fwd_set_test.cpp b/src/boost/libs/unordered/test/unordered/fwd_set_test.cpp
new file mode 100644
index 000000000..6512522a8
--- /dev/null
+++ b/src/boost/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()
diff --git a/src/boost/libs/unordered/test/unordered/incomplete_test.cpp b/src/boost/libs/unordered/test/unordered/incomplete_test.cpp
new file mode 100644
index 000000000..09afcba63
--- /dev/null
+++ b/src/boost/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();
+}
diff --git a/src/boost/libs/unordered/test/unordered/insert_hint_tests.cpp b/src/boost/libs/unordered/test/unordered/insert_hint_tests.cpp
new file mode 100644
index 000000000..c77fc2dc8
--- /dev/null
+++ b/src/boost/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()
diff --git a/src/boost/libs/unordered/test/unordered/insert_node_type_fail.cpp b/src/boost/libs/unordered/test/unordered/insert_node_type_fail.cpp
new file mode 100644
index 000000000..eb34930fb
--- /dev/null
+++ b/src/boost/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
+}
diff --git a/src/boost/libs/unordered/test/unordered/insert_stable_tests.cpp b/src/boost/libs/unordered/test/unordered/insert_stable_tests.cpp
new file mode 100644
index 000000000..4ea6a84bd
--- /dev/null
+++ b/src/boost/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()
diff --git a/src/boost/libs/unordered/test/unordered/insert_tests.cpp b/src/boost/libs/unordered/test/unordered/insert_tests.cpp
new file mode 100644
index 000000000..7ddb41fd9
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/insert_tests.cpp
@@ -0,0 +1,1425 @@
+
+// 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)
+
+#if !defined(PIECEWISE_TEST_NAME)
+
+// 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/invariants.hpp"
+#include "../helpers/input_iterator.hpp"
+#include "../helpers/helpers.hpp"
+
+namespace insert_tests {
+
+  test::seed_t initialize_seed(243432);
+
+  template <class X>
+  void unique_insert_tests1(X*, test::random_generator generator)
+  {
+    test::check_instances check_;
+
+    typedef typename X::iterator iterator;
+    typedef test::ordered<X> ordered;
+
+    UNORDERED_SUB_TEST("insert(value) tests for containers with unique keys")
+    {
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        std::pair<iterator, bool> r1 = x.insert(*it);
+        std::pair<typename ordered::iterator, bool> r2 = tracker.insert(*it);
+
+        BOOST_TEST(r1.second == r2.second);
+        BOOST_TEST(*r1.first == *r2.first);
+
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert(rvalue) tests for containers with unique keys")
+    {
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        typename X::value_type value = *it;
+        std::pair<iterator, bool> r1 = x.insert(boost::move(value));
+        std::pair<typename ordered::iterator, bool> r2 = tracker.insert(*it);
+
+        BOOST_TEST(r1.second == r2.second);
+        BOOST_TEST(*r1.first == *r2.first);
+
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
+    }
+  }
+
+  template <class X>
+  void equivalent_insert_tests1(X*, test::random_generator generator)
+  {
+    test::check_instances check_;
+
+    UNORDERED_SUB_TEST(
+      "insert(value) tests for containers with equivalent keys")
+    {
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        typename X::iterator r1 = x.insert(*it);
+        typename test::ordered<X>::iterator r2 = tracker.insert(*it);
+
+        BOOST_TEST(*r1 == *r2);
+
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST(
+      "insert(rvalue) tests for containers with equivalent keys")
+    {
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        typename X::value_type value = *it;
+        typename X::iterator r1 = x.insert(boost::move(value));
+        typename test::ordered<X>::iterator r2 = tracker.insert(*it);
+
+        BOOST_TEST(*r1 == *r2);
+
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
+    }
+  }
+
+  template <class X> void insert_tests2(X*, test::random_generator generator)
+  {
+    typedef typename test::ordered<X> tracker_type;
+    typedef typename X::iterator iterator;
+    typedef typename X::const_iterator const_iterator;
+    typedef typename tracker_type::iterator tracker_iterator;
+
+    UNORDERED_SUB_TEST("insert(begin(), value) tests")
+    {
+      test::check_instances check_;
+
+      X x;
+      tracker_type tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        iterator r1 = x.insert(x.begin(), *it);
+        tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
+        BOOST_TEST(*r1 == *r2);
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert(end(), value) tests")
+    {
+      test::check_instances check_;
+
+      X x;
+      X const& x_const = x;
+      tracker_type tracker = test::create_ordered(x);
+
+      test::random_values<X> v(100, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        const_iterator r1 = x.insert(x_const.end(), *it);
+        tracker_iterator r2 = tracker.insert(tracker.end(), *it);
+        BOOST_TEST(*r1 == *r2);
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert(pos, value) tests")
+    {
+      test::check_instances check_;
+
+      X x;
+      const_iterator pos = x.begin();
+      tracker_type tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        pos = x.insert(pos, *it);
+        tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
+        BOOST_TEST(*pos == *r2);
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert(pos, rvalue) tests")
+    {
+      test::check_instances check_;
+
+      X x;
+      const_iterator pos = x.begin();
+      tracker_type tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        typename X::value_type value = *it;
+        pos = x.insert(pos, boost::move(value));
+        tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
+        BOOST_TEST(*pos == *r2);
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert single item range tests")
+    {
+      test::check_instances check_;
+
+      X x;
+      tracker_type tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        x.insert(it, test::next(it));
+        tracker.insert(*it);
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <=
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert range tests")
+    {
+      test::check_instances check_;
+
+      X x;
+
+      test::random_values<X> v(1000, generator);
+      x.insert(v.begin(), v.end());
+
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert range with rehash tests")
+    {
+      test::check_instances check_;
+
+      X x;
+
+      test::random_values<X> v(1000, generator);
+
+      x.insert(*v.begin());
+      x.clear();
+
+      x.insert(v.begin(), v.end());
+
+      test::check_container(x, v);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert input iterator range tests")
+    {
+      test::check_instances check_;
+
+      X x;
+
+      test::random_values<X> v(1000, generator);
+      typename test::random_values<X>::const_iterator begin = v.begin(),
+                                                      end = v.end();
+      x.insert(test::input_iterator(begin), test::input_iterator(end));
+      test::check_container(x, v);
+
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert copy iterator range tests")
+    {
+      test::check_instances check_;
+
+      X x;
+
+      test::random_values<X> v(1000, generator);
+      x.insert(test::copy_iterator(v.begin()), test::copy_iterator(v.end()));
+      test::check_container(x, v);
+
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert copy iterator range test 2")
+    {
+      test::check_instances check_;
+
+      X x;
+
+      test::random_values<X> v1(500, generator);
+      test::random_values<X> v2(500, generator);
+      x.insert(test::copy_iterator(v1.begin()), test::copy_iterator(v1.end()));
+      x.insert(test::copy_iterator(v2.begin()), test::copy_iterator(v2.end()));
+
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert various ranges")
+    {
+      for (int i = 0; i < 100; ++i) {
+        X x;
+        test::ordered<X> tracker = test::create_ordered(x);
+
+        test::random_values<X> v(1000, generator);
+
+        for (typename test::random_values<X>::iterator it = v.begin();
+             it != v.end();) {
+          typename X::size_type old_bucket_count = x.bucket_count();
+          float b = x.max_load_factor();
+
+          typename test::random_values<X>::iterator next = it;
+          for (std::size_t j = test::random_value(20); j > 0; ++j) {
+            ++next;
+            if (next == v.end()) {
+              break;
+            }
+          }
+
+          x.insert(it, next);
+          tracker.insert(it, next);
+          it = next;
+
+          tracker.compare(x); // Slow, but I can't see any other way.
+
+          if (static_cast<double>(x.size()) <=
+              b * static_cast<double>(old_bucket_count))
+            BOOST_TEST(x.bucket_count() == old_bucket_count);
+        }
+
+        test::check_equivalent_keys(x);
+      }
+    }
+  }
+
+  template <class X>
+  void unique_emplace_tests1(X*, test::random_generator generator)
+  {
+    typedef typename X::iterator iterator;
+    typedef test::ordered<X> ordered;
+
+    X x;
+    test::ordered<X> tracker = test::create_ordered(x);
+
+    test::random_values<X> v(1000, generator);
+
+    for (typename test::random_values<X>::iterator it = v.begin();
+         it != v.end(); ++it) {
+
+      typename X::size_type old_bucket_count = x.bucket_count();
+      float b = x.max_load_factor();
+
+      std::pair<iterator, bool> r1 = x.emplace(*it);
+      std::pair<typename ordered::iterator, bool> r2 = tracker.insert(*it);
+
+      BOOST_TEST(r1.second == r2.second);
+      BOOST_TEST(*r1.first == *r2.first);
+
+      tracker.compare_key(x, *it);
+
+      if (static_cast<double>(x.size()) <=
+          b * static_cast<double>(old_bucket_count))
+        BOOST_TEST(x.bucket_count() == old_bucket_count);
+    }
+
+    tracker.compare(x);
+    test::check_equivalent_keys(x);
+  }
+
+  template <class X>
+  void equivalent_emplace_tests1(X*, test::random_generator generator)
+  {
+    X x;
+    test::ordered<X> tracker = test::create_ordered(x);
+
+    test::random_values<X> v(1000, generator);
+    for (typename test::random_values<X>::iterator it = v.begin();
+         it != v.end(); ++it) {
+      typename X::size_type old_bucket_count = x.bucket_count();
+      float b = x.max_load_factor();
+
+      typename X::iterator r1 = x.emplace(*it);
+      typename test::ordered<X>::iterator r2 = tracker.insert(*it);
+
+      BOOST_TEST(*r1 == *r2);
+
+      tracker.compare_key(x, *it);
+
+      if (static_cast<double>(x.size()) <=
+          b * static_cast<double>(old_bucket_count))
+        BOOST_TEST(x.bucket_count() == old_bucket_count);
+    }
+
+    tracker.compare(x);
+    test::check_equivalent_keys(x);
+  }
+
+  template <class X>
+  void move_emplace_tests(X*, test::random_generator generator)
+  {
+    X x;
+    test::ordered<X> tracker = test::create_ordered(x);
+
+    test::random_values<X> v(1000, generator);
+
+    for (typename test::random_values<X>::iterator it = v.begin();
+         it != v.end(); ++it) {
+
+      typename X::size_type old_bucket_count = x.bucket_count();
+      float b = x.max_load_factor();
+
+      typename X::value_type value = *it;
+      x.emplace(boost::move(value));
+      tracker.insert(*it);
+      tracker.compare_key(x, *it);
+
+      if (static_cast<double>(x.size()) <=
+          b * static_cast<double>(old_bucket_count))
+        BOOST_TEST(x.bucket_count() == old_bucket_count);
+    }
+
+    tracker.compare(x);
+    test::check_equivalent_keys(x);
+  }
+
+  template <class X> void default_emplace_tests(X*, test::random_generator)
+  {
+#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
+    bool is_unique = test::has_unique_keys<X>::value;
+
+    X x;
+
+    x.emplace();
+    BOOST_TEST(x.size() == 1);
+    x.emplace();
+    BOOST_TEST(x.size() == (is_unique ? 1u : 2u));
+    x.emplace();
+    BOOST_TEST(x.size() == (is_unique ? 1u : 3u));
+
+    typename X::value_type y;
+    BOOST_TEST(x.count(test::get_key<X>(y)) == (is_unique ? 1u : 3u));
+    BOOST_TEST(*x.equal_range(test::get_key<X>(y)).first == y);
+
+    x.emplace(y);
+    BOOST_TEST(x.size() == (is_unique ? 1u : 4u));
+    BOOST_TEST(x.count(test::get_key<X>(y)) == (is_unique ? 1u : 4u));
+    BOOST_TEST(*x.equal_range(test::get_key<X>(y)).first == y);
+
+    x.clear();
+    BOOST_TEST(x.empty());
+    x.emplace(y);
+    BOOST_TEST(x.size() == 1);
+    x.emplace(y);
+    BOOST_TEST(x.size() == (is_unique ? 1u : 2u));
+
+    BOOST_TEST(x.count(test::get_key<X>(y)) == (is_unique ? 1u : 2u));
+    BOOST_TEST(*x.equal_range(test::get_key<X>(y)).first == y);
+#endif
+  }
+
+  template <class X> void map_tests(X*, test::random_generator generator)
+  {
+    X x;
+    test::ordered<X> tracker = test::create_ordered(x);
+
+    test::random_values<X> v(1000, generator);
+    for (typename test::random_values<X>::iterator it = v.begin();
+         it != v.end(); ++it) {
+      typename X::size_type old_bucket_count = x.bucket_count();
+      float b = x.max_load_factor();
+
+      x[it->first] = it->second;
+      tracker[it->first] = it->second;
+
+      tracker.compare_key(x, *it);
+
+      if (static_cast<double>(x.size()) <=
+          b * static_cast<double>(old_bucket_count))
+        BOOST_TEST(x.bucket_count() == old_bucket_count);
+    }
+
+    tracker.compare(x);
+    test::check_equivalent_keys(x);
+  }
+
+  template <class X> void map_tests2(X*, test::random_generator generator)
+  {
+    typedef typename X::iterator iterator;
+
+    UNORDERED_SUB_TEST("insert_or_assign")
+    {
+      test::check_instances check_;
+
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        std::pair<iterator, bool> r = x.insert_or_assign(it->first, it->second);
+        BOOST_TEST(*r.first == *it);
+
+        tracker[it->first] = it->second;
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert_or_assign(begin)")
+    {
+      test::check_instances check_;
+
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        iterator r = x.insert_or_assign(x.begin(), it->first, it->second);
+        BOOST_TEST(*r == *it);
+
+        tracker[it->first] = it->second;
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert_or_assign(end)")
+    {
+      test::check_instances check_;
+
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        iterator r = x.insert_or_assign(x.end(), it->first, it->second);
+        BOOST_TEST(*r == *it);
+
+        tracker[it->first] = it->second;
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
+    }
+
+    UNORDERED_SUB_TEST("insert_or_assign(last)")
+    {
+      test::check_instances check_;
+
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+      iterator last = x.begin();
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        iterator r = x.insert_or_assign(last, it->first, it->second);
+        BOOST_TEST(*r == *it);
+
+        tracker[it->first] = it->second;
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+
+        last = r;
+      }
+
+      tracker.compare(x);
+      test::check_equivalent_keys(x);
+    }
+  }
+
+  template <class X>
+  void try_emplace_tests(X*, test::random_generator generator)
+  {
+    typedef typename X::iterator iterator;
+
+    UNORDERED_SUB_TEST("try_emplace(key, value)")
+    {
+      test::check_instances check_;
+
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        iterator pos = x.find(it->first);
+        bool found = pos != x.end();
+
+        std::pair<typename X::iterator, bool> r =
+          x.try_emplace(it->first, it->second);
+        if (found) {
+          BOOST_TEST(pos == r.first);
+          BOOST_TEST(!r.second);
+        } else {
+          BOOST_TEST(r.second);
+        }
+        BOOST_TEST_EQ(r.first->first, it->first);
+        BOOST_TEST_EQ(r.first->second, it->second);
+
+        tracker.insert(*it);
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
+    }
+
+    typedef typename X::iterator iterator;
+
+    UNORDERED_SUB_TEST("try_emplace(begin(), key, value)")
+    {
+      test::check_instances check_;
+
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        iterator pos = x.find(it->first);
+        bool found = pos != x.end();
+
+        typename X::iterator r =
+          x.try_emplace(r.begin(), it->first, it->second);
+        if (found) {
+          BOOST_TEST(pos == r);
+        }
+        BOOST_TEST_EQ(r->first, it->first);
+        BOOST_TEST_EQ(r->second, it->second);
+
+        tracker.insert(*it);
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
+    }
+
+    typedef typename X::iterator iterator;
+
+    UNORDERED_SUB_TEST("try_emplace(end(), key, value)")
+    {
+      test::check_instances check_;
+
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        iterator pos = x.find(it->first);
+        bool found = pos != x.end();
+
+        typename X::iterator r = x.try_emplace(r.end(), it->first, it->second);
+        if (found) {
+          BOOST_TEST(pos == r);
+        }
+        BOOST_TEST_EQ(r->first, it->first);
+        BOOST_TEST_EQ(r->second, it->second);
+
+        tracker.insert(*it);
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
+    }
+
+    typedef typename X::iterator iterator;
+
+    UNORDERED_SUB_TEST("try_emplace(pos, key, value)")
+    {
+      test::check_instances check_;
+
+      X x;
+      test::ordered<X> tracker = test::create_ordered(x);
+
+      test::random_values<X> v(1000, generator);
+      for (typename test::random_values<X>::iterator it = v.begin();
+           it != v.end(); ++it) {
+        typename X::size_type old_bucket_count = x.bucket_count();
+        float b = x.max_load_factor();
+
+        iterator pos = x.find(it->first);
+        bool found = pos != x.end();
+
+        typename X::iterator r = x.try_emplace(pos, it->first, it->second);
+        if (found) {
+          BOOST_TEST(pos == r);
+        }
+        BOOST_TEST_EQ(r->first, it->first);
+        BOOST_TEST_EQ(r->second, it->second);
+
+        tracker.insert(*it);
+        tracker.compare_key(x, *it);
+
+        if (static_cast<double>(x.size()) <
+            b * static_cast<double>(old_bucket_count))
+          BOOST_TEST(x.bucket_count() == old_bucket_count);
+      }
+
+      test::check_equivalent_keys(x);
+    }
+  }
+
+  // Some tests for when the range's value type doesn't match the container's
+  // value type.
+
+  template <class X>
+  void map_insert_range_test1(X*, test::random_generator generator)
+  {
+    test::check_instances check_;
+
+    typedef test::list<
+      std::pair<typename X::key_type, typename X::mapped_type> >
+      list;
+    test::random_values<X> v(1000, generator);
+    list l(v.begin(), v.end());
+
+    X x;
+    x.insert(l.begin(), l.end());
+
+    test::check_equivalent_keys(x);
+  }
+
+  template <class X>
+  void map_insert_range_test2(X*, test::random_generator generator)
+  {
+    test::check_instances check_;
+
+    typedef test::list<
+      std::pair<typename X::key_type const, test::implicitly_convertible> >
+      list;
+    test::random_values<
+      boost::unordered_map<typename X::key_type, test::implicitly_convertible> >
+      v(1000, generator);
+    list l(v.begin(), v.end());
+
+    X x;
+    x.insert(l.begin(), l.end());
+
+    test::check_equivalent_keys(x);
+  }
+
+  boost::unordered_set<test::movable, test::hash, test::equal_to,
+    std::allocator<test::movable> >* test_set_std_alloc;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, std::allocator<test::object> >* test_multimap_std_alloc;
+
+  boost::unordered_set<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_set;
+  boost::unordered_multiset<test::movable, test::hash, test::equal_to,
+    test::allocator2<test::movable> >* test_multiset;
+  boost::unordered_map<test::movable, test::movable, test::hash, test::equal_to,
+    test::allocator2<test::movable> >* test_map;
+  boost::unordered_multimap<test::object, test::object, test::hash,
+    test::equal_to, test::allocator1<test::object> >* test_multimap;
+
+  using test::default_generator;
+  using test::generate_collisions;
+  using test::limited_range;
+
+  UNORDERED_TEST(unique_insert_tests1,
+    ((test_set_std_alloc)(test_set)(test_map))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(equivalent_insert_tests1,
+    ((test_multimap_std_alloc)(test_multiset)(test_multimap))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(insert_tests2,
+    ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(
+      test_multimap))((default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(unique_emplace_tests1,
+    ((test_set_std_alloc)(test_set)(test_map))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(equivalent_emplace_tests1,
+    ((test_multimap_std_alloc)(test_multiset)(test_multimap))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(move_emplace_tests,
+    ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)(
+      test_multiset)(test_multimap))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(default_emplace_tests,
+    ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)(
+      test_multiset)(test_multimap))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(map_tests,
+    ((test_map))((default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(
+    map_tests2, ((test_map))((default_generator)(generate_collisions)))
+
+  UNORDERED_TEST(map_insert_range_test1,
+    ((test_multimap_std_alloc)(test_map)(test_multimap))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(map_insert_range_test2,
+    ((test_multimap_std_alloc)(test_map)(test_multimap))(
+      (default_generator)(generate_collisions)(limited_range)))
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+
+  struct initialize_from_two_ints
+  {
+    int a, b;
+
+    friend std::size_t hash_value(initialize_from_two_ints const& x)
+    {
+      return static_cast<std::size_t>(x.a + x.b);
+    }
+
+    bool operator==(initialize_from_two_ints const& x) const
+    {
+      return a == x.a && b == x.b;
+    }
+  };
+
+  UNORDERED_AUTO_TEST (insert_initializer_list_set) {
+    boost::unordered_set<int> set;
+    set.insert({1, 2, 3, 1});
+    BOOST_TEST_EQ(set.size(), 3u);
+    BOOST_TEST(set.find(1) != set.end());
+    BOOST_TEST(set.find(4) == set.end());
+
+    boost::unordered_set<initialize_from_two_ints> set2;
+
+#if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5))
+    set2.insert({{1, 2}});
+#else
+    set2.insert({1, 2});
+#endif
+    BOOST_TEST(set2.size() == 1);
+    BOOST_TEST(set2.find({1, 2}) != set2.end());
+    BOOST_TEST(set2.find({2, 1}) == set2.end());
+
+    set2.insert({{3, 4}, {5, 6}, {7, 8}});
+    BOOST_TEST(set2.size() == 4);
+    BOOST_TEST(set2.find({1, 2}) != set2.end());
+    BOOST_TEST(set2.find({3, 4}) != set2.end());
+    BOOST_TEST(set2.find({5, 6}) != set2.end());
+    BOOST_TEST(set2.find({7, 8}) != set2.end());
+    BOOST_TEST(set2.find({8, 7}) == set2.end());
+
+    set2.insert({{2, 1}, {3, 4}});
+    BOOST_TEST(set2.size() == 5);
+    BOOST_TEST(set2.find({1, 2}) != set2.end());
+    BOOST_TEST(set2.find({2, 1}) != set2.end());
+    BOOST_TEST(set2.find({3, 4}) != set2.end());
+    BOOST_TEST(set2.find({5, 6}) != set2.end());
+    BOOST_TEST(set2.find({7, 8}) != set2.end());
+    BOOST_TEST(set2.find({8, 7}) == set2.end());
+  }
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, == 1800)
+
+  UNORDERED_AUTO_TEST (insert_initializer_list_multiset) {
+    boost::unordered_multiset<std::string> multiset;
+    // multiset.insert({});
+    BOOST_TEST(multiset.empty());
+    multiset.insert({"a"});
+    BOOST_TEST_EQ(multiset.size(), 1u);
+    BOOST_TEST(multiset.find("a") != multiset.end());
+    BOOST_TEST(multiset.find("b") == multiset.end());
+    multiset.insert({"a", "b"});
+    BOOST_TEST(multiset.size() == 3);
+    BOOST_TEST_EQ(multiset.count("a"), 2u);
+    BOOST_TEST_EQ(multiset.count("b"), 1u);
+    BOOST_TEST_EQ(multiset.count("c"), 0u);
+  }
+
+#endif
+
+  UNORDERED_AUTO_TEST (insert_initializer_list_map) {
+    boost::unordered_map<std::string, std::string> map;
+    // map.insert({});
+    BOOST_TEST(map.empty());
+    map.insert({{"a", "b"}, {"a", "b"}, {"d", ""}});
+    BOOST_TEST_EQ(map.size(), 2u);
+  }
+
+  UNORDERED_AUTO_TEST (insert_initializer_list_multimap) {
+    boost::unordered_multimap<std::string, std::string> multimap;
+    // multimap.insert({});
+    BOOST_TEST(multimap.empty());
+    multimap.insert({{"a", "b"}, {"a", "b"}, {"d", ""}});
+    BOOST_TEST_EQ(multimap.size(), 3u);
+    BOOST_TEST_EQ(multimap.count("a"), 2u);
+  }
+
+#endif
+
+  struct overloaded_constructor
+  {
+    overloaded_constructor(int x1_ = 1, int x2_ = 2, int x3_ = 3, int x4_ = 4)
+        : x1(x1_), x2(x2_), x3(x3_), x4(x4_)
+    {
+    }
+
+    int x1, x2, x3, x4;
+
+    bool operator==(overloaded_constructor const& rhs) const
+    {
+      return x1 == rhs.x1 && x2 == rhs.x2 && x3 == rhs.x3 && x4 == rhs.x4;
+    }
+
+    friend std::size_t hash_value(overloaded_constructor const& x)
+    {
+      std::size_t hash = 0;
+      boost::hash_combine(hash, x.x1);
+      boost::hash_combine(hash, x.x2);
+      boost::hash_combine(hash, x.x3);
+      boost::hash_combine(hash, x.x4);
+      return hash;
+    }
+  };
+
+  UNORDERED_AUTO_TEST (map_emplace_test) {
+    {
+      boost::unordered_map<int, overloaded_constructor, test::hash,
+        test::equal_to,
+        test::allocator1<std::pair<int const, overloaded_constructor> > >
+        x;
+
+#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
+      x.emplace();
+      BOOST_TEST(
+        x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
+#endif
+
+      x.emplace(2, 3);
+      BOOST_TEST(
+        x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
+
+      x.try_emplace(5);
+      BOOST_TEST(
+        x.find(5) != x.end() && x.find(5)->second == overloaded_constructor());
+    }
+
+    {
+      boost::unordered_multimap<int, overloaded_constructor, test::hash,
+        test::equal_to,
+        test::allocator1<std::pair<int const, overloaded_constructor> > >
+        x;
+
+#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
+      x.emplace();
+      BOOST_TEST(
+        x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
+#endif
+
+      x.emplace(2, 3);
+      BOOST_TEST(
+        x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
+    }
+  }
+
+  UNORDERED_AUTO_TEST (set_emplace_test) {
+    boost::unordered_set<overloaded_constructor> x;
+    overloaded_constructor check;
+
+#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
+    x.emplace();
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+#endif
+
+    x.clear();
+    x.emplace(1);
+    check = overloaded_constructor(1);
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+
+    x.clear();
+    x.emplace(2, 3);
+    check = overloaded_constructor(2, 3);
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+
+    x.clear();
+    x.emplace(4, 5, 6);
+    check = overloaded_constructor(4, 5, 6);
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+
+    x.clear();
+    x.emplace(7, 8, 9, 10);
+    check = overloaded_constructor(7, 8, 9, 10);
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+  }
+
+  struct derived_from_piecewise_construct_t
+    : boost::unordered::piecewise_construct_t
+  {
+  };
+
+  derived_from_piecewise_construct_t piecewise_rvalue()
+  {
+    return derived_from_piecewise_construct_t();
+  }
+
+  struct convertible_to_piecewise
+  {
+    operator boost::unordered::piecewise_construct_t() const
+    {
+      return boost::unordered::piecewise_construct;
+    }
+  };
+
+  UNORDERED_AUTO_TEST (map_emplace_test2) {
+    // Emulating piecewise construction with boost::tuple bypasses the
+    // allocator's construct method, but still uses test destroy method.
+    test::detail::disable_construction_tracking _scoped;
+
+    {
+      boost::unordered_map<overloaded_constructor, overloaded_constructor,
+        boost::hash<overloaded_constructor>,
+        std::equal_to<overloaded_constructor>,
+        test::allocator1<
+          std::pair<overloaded_constructor const, overloaded_constructor> > >
+        x;
+
+      x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
+        boost::make_tuple());
+      BOOST_TEST(
+        x.find(overloaded_constructor()) != x.end() &&
+        x.find(overloaded_constructor())->second == overloaded_constructor());
+
+      x.emplace(
+        convertible_to_piecewise(), boost::make_tuple(1), boost::make_tuple());
+      BOOST_TEST(
+        x.find(overloaded_constructor(1)) != x.end() &&
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
+
+      x.emplace(piecewise_rvalue(), boost::make_tuple(2, 3),
+        boost::make_tuple(4, 5, 6));
+      BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+                 x.find(overloaded_constructor(2, 3))->second ==
+                   overloaded_constructor(4, 5, 6));
+
+      derived_from_piecewise_construct_t d;
+      x.emplace(d, boost::make_tuple(9, 3, 1), boost::make_tuple(10));
+      BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
+                 x.find(overloaded_constructor(9, 3, 1))->second ==
+                   overloaded_constructor(10));
+
+      x.clear();
+
+      x.try_emplace(overloaded_constructor());
+      BOOST_TEST(
+        x.find(overloaded_constructor()) != x.end() &&
+        x.find(overloaded_constructor())->second == overloaded_constructor());
+
+      x.try_emplace(1);
+      BOOST_TEST(
+        x.find(overloaded_constructor(1)) != x.end() &&
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
+
+      x.try_emplace(overloaded_constructor(2, 3), 4, 5, 6);
+      BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+                 x.find(overloaded_constructor(2, 3))->second ==
+                   overloaded_constructor(4, 5, 6));
+
+      x.clear();
+
+      x.try_emplace(x.begin(), overloaded_constructor());
+      BOOST_TEST(
+        x.find(overloaded_constructor()) != x.end() &&
+        x.find(overloaded_constructor())->second == overloaded_constructor());
+
+      x.try_emplace(x.end(), 1);
+      BOOST_TEST(
+        x.find(overloaded_constructor(1)) != x.end() &&
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
+
+      x.try_emplace(x.begin(), overloaded_constructor(2, 3), 4, 5, 6);
+      BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+                 x.find(overloaded_constructor(2, 3))->second ==
+                   overloaded_constructor(4, 5, 6));
+    }
+
+    {
+      boost::unordered_multimap<overloaded_constructor, overloaded_constructor,
+        boost::hash<overloaded_constructor>,
+        std::equal_to<overloaded_constructor>,
+        test::allocator1<
+          std::pair<overloaded_constructor const, overloaded_constructor> > >
+        x;
+
+      x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
+        boost::make_tuple());
+      BOOST_TEST(
+        x.find(overloaded_constructor()) != x.end() &&
+        x.find(overloaded_constructor())->second == overloaded_constructor());
+
+      x.emplace(
+        convertible_to_piecewise(), boost::make_tuple(1), boost::make_tuple());
+      BOOST_TEST(
+        x.find(overloaded_constructor(1)) != x.end() &&
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
+
+      x.emplace(piecewise_rvalue(), boost::make_tuple(2, 3),
+        boost::make_tuple(4, 5, 6));
+      BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+                 x.find(overloaded_constructor(2, 3))->second ==
+                   overloaded_constructor(4, 5, 6));
+
+      derived_from_piecewise_construct_t d;
+      x.emplace(d, boost::make_tuple(9, 3, 1), boost::make_tuple(10));
+      BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
+                 x.find(overloaded_constructor(9, 3, 1))->second ==
+                   overloaded_constructor(10));
+    }
+  }
+
+  UNORDERED_AUTO_TEST (set_emplace_test2) {
+    boost::unordered_set<
+      std::pair<overloaded_constructor, overloaded_constructor> >
+      x;
+    std::pair<overloaded_constructor, overloaded_constructor> check;
+
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
+      boost::make_tuple());
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+
+    x.clear();
+    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(1),
+      boost::make_tuple(2, 3));
+    check =
+      std::make_pair(overloaded_constructor(1), overloaded_constructor(2, 3));
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+  }
+
+// Use the preprocessor to generate tests using different combinations of
+// boost/std piecewise_construct_t/tuple.
+
+#define PIECEWISE_TEST_NAME boost_tuple_piecewise_tests
+#define PIECEWISE_NAMESPACE boost::unordered
+#define TUPLE_NAMESPACE boost
+#define EMULATING_PIECEWISE_CONSTRUCTION 1
+#include "./insert_tests.cpp"
+
+#if BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
+
+#define PIECEWISE_TEST_NAME boost_tuple_std_piecewise_tests
+#define PIECEWISE_NAMESPACE std
+#define TUPLE_NAMESPACE boost
+#define EMULATING_PIECEWISE_CONSTRUCTION 1
+#include "./insert_tests.cpp"
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+#define PIECEWISE_TEST_NAME std_tuple_boost_piecewise_tests
+#define PIECEWISE_NAMESPACE boost::unordered
+#define TUPLE_NAMESPACE std
+#define EMULATING_PIECEWISE_CONSTRUCTION 0
+#include "./insert_tests.cpp"
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) &&                                      \
+  BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
+
+#define PIECEWISE_TEST_NAME std_piecewise_tests
+#define PIECEWISE_NAMESPACE std
+#define TUPLE_NAMESPACE std
+#define EMULATING_PIECEWISE_CONSTRUCTION 0
+#include "./insert_tests.cpp"
+
+#endif
+}
+
+RUN_TESTS_QUIET()
+
+#else // PIECEWISE_TEST_NAME
+
+UNORDERED_AUTO_TEST (PIECEWISE_TEST_NAME) {
+#if EMULATING_PIECEWISE_CONSTRUCTION
+  test::detail::disable_construction_tracking _scoped;
+#endif
+
+  {
+    boost::unordered_map<overloaded_constructor, overloaded_constructor,
+      boost::hash<overloaded_constructor>,
+      std::equal_to<overloaded_constructor>,
+      test::allocator1<
+        std::pair<overloaded_constructor const, overloaded_constructor> > >
+      x;
+
+    x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
+      TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
+    BOOST_TEST(
+      x.find(overloaded_constructor()) != x.end() &&
+      x.find(overloaded_constructor())->second == overloaded_constructor());
+
+    x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
+      TUPLE_NAMESPACE::make_tuple());
+    BOOST_TEST(
+      x.find(overloaded_constructor(1)) != x.end() &&
+      x.find(overloaded_constructor(1))->second == overloaded_constructor());
+
+    x.emplace(piecewise_rvalue(), TUPLE_NAMESPACE::make_tuple(2, 3),
+      TUPLE_NAMESPACE::make_tuple(4, 5, 6));
+    BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+               x.find(overloaded_constructor(2, 3))->second ==
+                 overloaded_constructor(4, 5, 6));
+
+    derived_from_piecewise_construct_t d;
+    x.emplace(
+      d, TUPLE_NAMESPACE::make_tuple(9, 3, 1), TUPLE_NAMESPACE::make_tuple(10));
+    BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
+               x.find(overloaded_constructor(9, 3, 1))->second ==
+                 overloaded_constructor(10));
+
+    x.clear();
+
+    x.try_emplace(overloaded_constructor());
+    BOOST_TEST(
+      x.find(overloaded_constructor()) != x.end() &&
+      x.find(overloaded_constructor())->second == overloaded_constructor());
+
+    x.try_emplace(1);
+    BOOST_TEST(
+      x.find(overloaded_constructor(1)) != x.end() &&
+      x.find(overloaded_constructor(1))->second == overloaded_constructor());
+
+    x.try_emplace(overloaded_constructor(2, 3), 4, 5, 6);
+    BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+               x.find(overloaded_constructor(2, 3))->second ==
+                 overloaded_constructor(4, 5, 6));
+  }
+  {
+    boost::unordered_multimap<overloaded_constructor, overloaded_constructor,
+      boost::hash<overloaded_constructor>,
+      std::equal_to<overloaded_constructor>,
+      test::allocator1<
+        std::pair<overloaded_constructor const, overloaded_constructor> > >
+      x;
+
+    x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
+      TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
+    BOOST_TEST(
+      x.find(overloaded_constructor()) != x.end() &&
+      x.find(overloaded_constructor())->second == overloaded_constructor());
+
+    x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
+      TUPLE_NAMESPACE::make_tuple());
+    BOOST_TEST(
+      x.find(overloaded_constructor(1)) != x.end() &&
+      x.find(overloaded_constructor(1))->second == overloaded_constructor());
+
+    x.emplace(piecewise_rvalue(), TUPLE_NAMESPACE::make_tuple(2, 3),
+      TUPLE_NAMESPACE::make_tuple(4, 5, 6));
+    BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+               x.find(overloaded_constructor(2, 3))->second ==
+                 overloaded_constructor(4, 5, 6));
+
+    derived_from_piecewise_construct_t d;
+    x.emplace(
+      d, TUPLE_NAMESPACE::make_tuple(9, 3, 1), TUPLE_NAMESPACE::make_tuple(10));
+    BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
+               x.find(overloaded_constructor(9, 3, 1))->second ==
+                 overloaded_constructor(10));
+  }
+}
+
+UNORDERED_AUTO_TEST (BOOST_PP_CAT(PIECEWISE_TEST_NAME, 2)) {
+#if EMULATING_PIECEWISE_CONSTRUCTION
+  test::detail::disable_construction_tracking _scoped;
+#endif
+
+  boost::unordered_set<
+    std::pair<overloaded_constructor, overloaded_constructor> >
+    x;
+  std::pair<overloaded_constructor, overloaded_constructor> check;
+
+  x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
+    TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
+  BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+
+  x.clear();
+  x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
+    TUPLE_NAMESPACE::make_tuple(1), TUPLE_NAMESPACE::make_tuple(2, 3));
+  check =
+    std::make_pair(overloaded_constructor(1), overloaded_constructor(2, 3));
+  BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+}
+
+#undef PIECEWISE_TEST_NAME
+#undef PIECEWISE_NAMESPACE
+#undef TUPLE_NAMESPACE
+#undef EMULATING_PIECEWISE_CONSTRUCTION
+
+#endif
diff --git a/src/boost/libs/unordered/test/unordered/link_test_1.cpp b/src/boost/libs/unordered/test/unordered/link_test_1.cpp
new file mode 100644
index 000000000..c32c3ac91
--- /dev/null
+++ b/src/boost/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;
+}
diff --git a/src/boost/libs/unordered/test/unordered/link_test_2.cpp b/src/boost/libs/unordered/test/unordered/link_test_2.cpp
new file mode 100644
index 000000000..5ccf60d54
--- /dev/null
+++ b/src/boost/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));
+}
diff --git a/src/boost/libs/unordered/test/unordered/load_factor_tests.cpp b/src/boost/libs/unordered/test/unordered/load_factor_tests.cpp
new file mode 100644
index 000000000..9006c1bdf
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/load_factor_tests.cpp
@@ -0,0 +1,97 @@
+
+// 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 (typename test::random_values<X>::const_iterator it = values.begin(),
+                                                         end = values.end();
+         it != end; ++it) {
+      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
diff --git a/src/boost/libs/unordered/test/unordered/merge_tests.cpp b/src/boost/libs/unordered/test/unordered/merge_tests.cpp
new file mode 100644
index 000000000..897abb34c
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/merge_tests.cpp
@@ -0,0 +1,337 @@
+
+// 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"
+
+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(), test::next(v2.begin(), 100));
+    v2.insert(v1.begin(), test::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(), test::next(v2.begin(), 100));
+    v2.insert(v1.begin(), test::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()
diff --git a/src/boost/libs/unordered/test/unordered/minimal_allocator.cpp b/src/boost/libs/unordered/test/unordered/minimal_allocator.cpp
new file mode 100644
index 000000000..a692443ee
--- /dev/null
+++ b/src/boost/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/core/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();
+}
diff --git a/src/boost/libs/unordered/test/unordered/move_tests.cpp b/src/boost/libs/unordered/test/unordered/move_tests.cpp
new file mode 100644
index 000000000..82ba60113
--- /dev/null
+++ b/src/boost/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,
+    typename T::hasher hf, typename T::key_equal eq,
+    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)
+  {
+    typename T::hasher hf;
+    typename T::key_equal eq;
+    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)
+  {
+    typename T::hasher hf(1);
+    typename T::key_equal eq(1);
+    typename T::allocator_type al(1);
+    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)
+  {
+    typename T::hasher hf(1);
+    typename T::key_equal eq(1);
+    typename T::allocator_type al1(1);
+    typename T::allocator_type al2(2);
+    typedef 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()
diff --git a/src/boost/libs/unordered/test/unordered/node_handle_tests.cpp b/src/boost/libs/unordered/test/unordered/node_handle_tests.cpp
new file mode 100644
index 000000000..2d5b1eab2
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/node_handle_tests.cpp
@@ -0,0 +1,424 @@
+
+// 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/core/pointer_traits.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, typename NodeHandle::value_type const& x)
+{
+  return x == nh.value();
+}
+
+template <typename NodeHandle>
+bool node_handle_compare(
+  NodeHandle const& nh, std::pair<typename NodeHandle::key_type const,
+                          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 typename Container::node_type node_type;
+
+  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);
+
+  typename Container::value_type value1 = *c.begin();
+  n1 = c.extract(c.begin());
+  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 typename Container1::node_type node_type;
+  typedef typename Container1::value_type value_type;
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<node_type, typename Container2::node_type>::value));
+
+  typedef typename Container1::insert_return_type insert_return_type1;
+  typedef 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::to_address(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::to_address(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 typename Container1::node_type node_type;
+  typedef typename Container1::value_type value_type;
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<node_type, typename Container2::node_type>::value));
+
+  // typedef typename Container1::insert_return_type
+  // insert_return_type1;
+  typedef typename Container2::insert_return_type insert_return_type2;
+
+  while (!c1.empty()) {
+    value_type v = *c1.begin();
+    value_type const* v_ptr = boost::to_address(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::to_address(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 typename Container1::node_type node_type;
+  typedef typename Container1::value_type value_type;
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<node_type, typename Container2::node_type>::value));
+
+  typedef typename Container1::iterator iterator1;
+  typedef 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::to_address(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::to_address(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()
diff --git a/src/boost/libs/unordered/test/unordered/noexcept_tests.cpp b/src/boost/libs/unordered/test/unordered/noexcept_tests.cpp
new file mode 100644
index 000000000..454e7c23c
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/noexcept_tests.cpp
@@ -0,0 +1,320 @@
+
+// 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"
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+// conditional expression is constant
+#pragma warning(disable : 4127)
+#endif
+
+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&) {}
+    hash_possible_exception& operator=(hash_possible_exception const&)
+    {
+      return *this;
+    }
+  };
+
+  struct equal_to_possible_exception : std::equal_to<int>
+  {
+    equal_to_possible_exception(equal_to_possible_exception const&) {}
+    equal_to_possible_exception& operator=(equal_to_possible_exception const&)
+    {
+      return *this;
+    }
+  };
+
+  // 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();
+    }
+  }
+
+  template <bool nothrow_move_construct, bool nothrow_move_assign,
+    bool nothrow_swap>
+  class hash_nothrow : boost::hash<int>
+  {
+    BOOST_COPYABLE_AND_MOVABLE(hash_nothrow)
+
+    typedef boost::hash<int> base;
+
+  public:
+    hash_nothrow(BOOST_RV_REF(hash_nothrow))
+      BOOST_NOEXCEPT_IF(nothrow_move_construct)
+    {
+      if (!nothrow_move_construct) {
+        test_throw("Move Constructor");
+      }
+    }
+
+    hash_nothrow() { test_throw("Constructor"); }
+    hash_nothrow(hash_nothrow const&) { test_throw("Copy"); }
+    hash_nothrow& operator=(BOOST_COPY_ASSIGN_REF(hash_nothrow))
+    {
+      test_throw("Assign");
+      return *this;
+    }
+    hash_nothrow& operator=(BOOST_RV_REF(hash_nothrow))
+      BOOST_NOEXCEPT_IF(nothrow_move_assign)
+    {
+      if (!nothrow_move_assign) {
+        test_throw("Move Assign");
+      }
+      return *this;
+    }
+    std::size_t operator()(int x) const
+    {
+      test_throw("Operator");
+      return static_cast<base const&>(*this)(x);
+    }
+    friend void swap(hash_nothrow&, hash_nothrow&)
+      BOOST_NOEXCEPT_IF(nothrow_swap)
+    {
+      if (!nothrow_swap) {
+        test_throw("Swap");
+      }
+    }
+  };
+
+  typedef hash_nothrow<true, false, false> hash_nothrow_move_construct;
+  typedef hash_nothrow<false, true, false> hash_nothrow_move_assign;
+  typedef hash_nothrow<false, false, true> hash_nothrow_swap;
+
+  template <bool nothrow_move_construct, bool nothrow_move_assign,
+    bool nothrow_swap>
+  class equal_to_nothrow
+  {
+    BOOST_COPYABLE_AND_MOVABLE(equal_to_nothrow)
+
+    typedef boost::hash<int> base;
+
+  public:
+    equal_to_nothrow(BOOST_RV_REF(equal_to_nothrow))
+      BOOST_NOEXCEPT_IF(nothrow_move_construct)
+    {
+      if (!nothrow_move_construct) {
+        test_throw("Move Constructor");
+      }
+    }
+
+    equal_to_nothrow() { test_throw("Constructor"); }
+    equal_to_nothrow(equal_to_nothrow const&) { test_throw("Copy"); }
+    equal_to_nothrow& operator=(BOOST_COPY_ASSIGN_REF(equal_to_nothrow))
+    {
+      test_throw("Assign");
+      return *this;
+    }
+    equal_to_nothrow& operator=(BOOST_RV_REF(equal_to_nothrow))
+      BOOST_NOEXCEPT_IF(nothrow_move_assign)
+    {
+      if (!nothrow_move_assign) {
+        test_throw("Move Assign");
+      }
+      return *this;
+    }
+    std::size_t operator()(int x, int y) const
+    {
+      test_throw("Operator");
+      return x == y;
+    }
+    friend void swap(equal_to_nothrow&, equal_to_nothrow&)
+      BOOST_NOEXCEPT_IF(nothrow_swap)
+    {
+      if (!nothrow_swap) {
+        test_throw("Swap");
+      }
+    }
+  };
+
+  typedef equal_to_nothrow<true, false, false> equal_to_nothrow_move_construct;
+  typedef equal_to_nothrow<false, true, false> equal_to_nothrow_move_assign;
+  typedef equal_to_nothrow<false, false, true> equal_to_nothrow_swap;
+
+  bool have_is_nothrow_move = false;
+  bool have_is_nothrow_move_assign = false;
+  bool have_is_nothrow_swap = false;
+
+  UNORDERED_AUTO_TEST (check_is_nothrow_move) {
+    BOOST_TEST(
+      !boost::is_nothrow_move_constructible<hash_possible_exception>::value);
+    BOOST_TEST(
+      !boost::is_nothrow_move_assignable<hash_possible_exception>::value);
+    BOOST_TEST(!boost::is_nothrow_swappable<hash_possible_exception>::value);
+    BOOST_TEST((!boost::is_nothrow_move_constructible<
+                equal_to_nothrow<false, false, false> >::value));
+    BOOST_TEST((!boost::is_nothrow_move_assignable<
+                equal_to_nothrow<false, false, false> >::value));
+    BOOST_TEST((!boost::is_nothrow_swappable<
+                equal_to_nothrow<false, false, false> >::value));
+
+    have_is_nothrow_move =
+      boost::is_nothrow_move_constructible<hash_nothrow_move_construct>::value;
+    have_is_nothrow_move_assign =
+      boost::is_nothrow_move_assignable<hash_nothrow_move_assign>::value;
+    have_is_nothrow_swap =
+      boost::is_nothrow_swappable<hash_nothrow_swap>::value;
+
+// Check that the traits work when expected.
+#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) &&     \
+  !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40800)
+    BOOST_TEST(have_is_nothrow_move);
+    BOOST_TEST(have_is_nothrow_move_assign);
+#endif
+
+#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_NOEXCEPT) &&     \
+  !defined(BOOST_NO_CXX11_DECLTYPE) &&                                         \
+  !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+    BOOST_TEST(have_is_nothrow_swap);
+#endif
+
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+      << "have_is_nothrow_move: " << have_is_nothrow_move << std::endl
+      << "have_is_nothrow_swap: " << have_is_nothrow_swap << std::endl;
+  }
+
+  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_nothrow_move_when_noexcept) {
+    typedef boost::unordered_set<int, hash_nothrow_move_construct,
+      equal_to_nothrow_move_construct>
+      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);
+      BOOST_TEST(have_is_nothrow_move);
+    } catch (test_exception) {
+      BOOST_TEST(!have_is_nothrow_move);
+    }
+
+    throwing_test_exception = false;
+  }
+
+  UNORDERED_AUTO_TEST (test_nothrow_move_assign_when_noexcept) {
+    typedef boost::unordered_set<int, hash_nothrow_move_assign,
+      equal_to_nothrow_move_assign>
+      throwing_set;
+
+    if (have_is_nothrow_move_assign) {
+      BOOST_TEST(boost::is_nothrow_move_assignable<throwing_set>::value);
+    }
+
+    throwing_test_exception = false;
+
+    throwing_set x1;
+    throwing_set x2;
+    x1.insert(10);
+    x1.insert(50);
+    for (int i = 0; i < 100; ++i) {
+      x2.insert(i);
+    }
+
+    try {
+      throwing_test_exception = true;
+
+      x2 = boost::move(x1);
+      BOOST_TEST(x2.size() == 2);
+      BOOST_TEST(*x2.begin() == 10 || *x2.begin() == 50);
+      BOOST_TEST(have_is_nothrow_move_assign);
+    } catch (test_exception) {
+      BOOST_TEST(!have_is_nothrow_move_assign);
+    }
+
+    throwing_test_exception = false;
+  }
+
+  UNORDERED_AUTO_TEST (test_nothrow_swap_when_noexcept) {
+    typedef boost::unordered_set<int, hash_nothrow_swap, equal_to_nothrow_swap>
+      throwing_set;
+
+    if (have_is_nothrow_swap) {
+      BOOST_TEST(boost::is_nothrow_swappable<throwing_set>::value);
+    }
+
+    throwing_test_exception = false;
+
+    throwing_set x1;
+    throwing_set x2;
+    x1.insert(10);
+    x1.insert(50);
+    for (int i = 0; i < 100; ++i) {
+      x2.insert(i);
+    }
+
+    try {
+      throwing_test_exception = true;
+
+      x1.swap(x2);
+      BOOST_TEST(x1.size() == 100);
+      BOOST_TEST(x2.size() == 2);
+      BOOST_TEST(*x2.begin() == 10 || *x2.begin() == 50);
+      BOOST_TEST(have_is_nothrow_swap);
+    } catch (test_exception) {
+      BOOST_TEST(!have_is_nothrow_swap);
+    }
+
+    throwing_test_exception = false;
+  }
+}
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+RUN_TESTS()
diff --git a/src/boost/libs/unordered/test/unordered/rehash_tests.cpp b/src/boost/libs/unordered/test/unordered/rehash_tests.cpp
new file mode 100644
index 000000000..65c089362
--- /dev/null
+++ b/src/boost/libs/unordered/test/unordered/rehash_tests.cpp
@@ -0,0 +1,229 @@
+
+// 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, 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()
diff --git a/src/boost/libs/unordered/test/unordered/simple_tests.cpp b/src/boost/libs/unordered/test/unordered/simple_tests.cpp
new file mode 100644
index 000000000..d8a9ce413
--- /dev/null
+++ b/src/boost/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<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()
diff --git a/src/boost/libs/unordered/test/unordered/swap_tests.cpp b/src/boost/libs/unordered/test/unordered/swap_tests.cpp
new file mode 100644
index 000000000..9a7106efc
--- /dev/null
+++ b/src/boost/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 typename X::hasher hasher;
+    typedef typename X::key_equal key_equal;
+    typedef 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()
diff --git a/src/boost/libs/unordered/test/unordered/unnecessary_copy_tests.cpp b/src/boost/libs/unordered/test/unordered/unnecessary_copy_tests.cpp
new file mode 100644
index 000000000..1c5ff4b7e
--- /dev/null
+++ b/src/boost/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;
+    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;
+    typename T::value_type a;
+    reset();
+    x.insert(boost::move(a));
+    COPY_COUNT(0);
+    MOVE_COUNT(1);
+
+    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;
+    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
+
+    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;
+    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<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;
+    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;
+    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;
+    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);
+    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()