Release 1.37.0

[SVN r51178]
2026-08-08 14:42:05 +02:00 · 2009-02-10 13:14:42 +00:00
78 changed files with 794 additions and 1381 deletions
@@ -1,9 +1,3 @@
-#
-# Copyright Troy D. Straszheim
-#
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
 #----------------------------------------------------------------------------
 # This file was automatically generated from the original CMakeLists.txt file
 # Add a variable to hold the headers for the library
@@ -17,7 +11,7 @@ set (lib_headers
 boost_library_project(
  unordered
  #  SRCDIRS 
-  TESTDIRS test
+  #  TESTDIRS 
  HEADERS ${lib_headers}
  #  DOCDIRS 
  #  DESCRIPTION 
@@ -8,11 +8,11 @@ path-constant admonishment_location : ../../../../doc/src/images ;

 xml unordered : unordered.qbk ;
 boostbook standalone : unordered :
-    <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
+    <xsl:param>admon.graphics.path=images/
+    <xsl:param>navig.graphics.path=images/
+    <xsl:param>html.stylesheet=boostbook.css
    <xsl:param>boost.root=../../../..
    <xsl:param>boost.libraries=../../../libraries.htm
-    <xsl:param>navig.graphics=1
-
    <xsl:param>chunk.first.sections=1
    <xsl:param>chunk.section.depth=2
    <xsl:param>generate.section.toc.level=2
@@ -23,6 +23,9 @@ boostbook standalone : unordered :
    <xsl:param>boost.compact.function=0
    <xsl:param>boost.compact.enum=0

+    <dependency>css
+    <dependency>images
+
    # PDF Options:
    # TOC Generation: this is needed for FOP-0.9 and later:
    <xsl:param>fop1.extensions=0
@@ -48,6 +51,11 @@ boostbook standalone : unordered :
    <format>pdf:<xsl:param>img.src.path=$(images_location)/
    #<format>pdf:<xsl:param>admon.graphics.path=$(admonishment_location)
    <format>pdf:<xsl:param>draft.mode="no"
-    <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/unordered/doc/html
    ;

+install css : [ glob $(BOOST_ROOT)/doc/src/*.css ]
+    : <location>html ;
+install images : [ glob $(BOOST_ROOT)/doc/src/images/*.png ]
+    : <location>html/images ;
+explicit css ;
+explicit images ;
@@ -1,5 +1,5 @@
 <!--
-Copyright Daniel James 2008-2009
+Copyright Daniel James 2008
 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)
 -->
@@ -115,15 +115,6 @@ or close to the hint - unless your hint is unreasonably small or large.
 [table Methods for Controlling Bucket Size
    [[Method] [Description]]

-    [
-        [`X(size_type n)`]
-        [Construct an empty container with at least `n` buckets (`X` is the container type).]
-    ]
-    [
-        [`X(InputIterator i, InputIterator j, size_type n)`]
-        [Construct an empty container with at least `n` buckets and insert elements
-         from the range \[`i`, `j`) (`X` is the container type).]
-    ]
    [
        [`float load_factor() const`]
        [The average number of elements per bucket.]
@@ -44,7 +44,7 @@ First official release.

 [h2 Boost 1.38.0]

-* Use [@boost:/libs/utility/swap.html `boost::swap`].
+* Use [@../../libs/utility/swap.html `boost::swap`].
 * [@https://svn.boost.org/trac/boost/ticket/2237 Ticket 2237]:
  Document that the equality and inequality operators are undefined for two
  objects if their equality predicates aren't equivalent. Thanks to Daniel
@@ -53,7 +53,7 @@ First official release.
  Use a larger prime number list. Thanks to Thorsten Ottosen and Hervé
  Brönnimann.
 * Use
-  [@boost:/libs/type_traits/doc/html/boost_typetraits/category/alignment.html
+  [@../../libs/type_traits/doc/html/boost_typetraits/category/alignment.html
  aligned storage] to store the types. This changes the way the allocator is
  used to construct nodes. It used to construct the node with two calls to
  the allocator's `construct` method - once for the pointers and once for the
@@ -62,30 +62,4 @@ First official release.
 * Add support for C++0x initializer lists where they're available (currently
  only g++ 4.4 in C++0x mode).

-[h2 Boost 1.39.0]
-
-* [@https://svn.boost.org/trac/boost/ticket/2756 Ticket 2756]: Avoid a warning
-  on Visual C++ 2009.
-* Some other minor internal changes to the implementation, tests and
-  documentation.
-* Avoid an unnecessary copy in `operator[]`.
-* [@https://svn.boost.org/trac/boost/ticket/2975 Ticket 2975]: Fix length of
-  prime number list.
-
-[h2 Boost 1.40.0]
-
-* [@https://svn.boost.org/trac/boost/ticket/2975 Ticket 2975]:
-  Store the prime list as a preprocessor sequence - so that it will always get
-  the length right if it changes again in the future.
-* [@https://svn.boost.org/trac/boost/ticket/1978 Ticket 1978]:
-  Implement `emplace` for all compilers.
-* [@https://svn.boost.org/trac/boost/ticket/2908 Ticket 2908],
-  [@https://svn.boost.org/trac/boost/ticket/3096 Ticket 3096]:
-  Some workarounds for old versions of borland, including adding explicit
-  destructors to all containers.
-* [@https://svn.boost.org/trac/boost/ticket/3082 Ticket 3082]:
-  Disable incorrect Visual C++ warnings.
-* Better configuration for C++0x features when the headers aren't available.
-* Create less buckets by default.
-
 [endsect]
@@ -13,7 +13,7 @@ is declared as:
            class Key, class Mapped,
            class Hash = ``[classref boost::hash]``<Key>,
            class Pred = std::equal_to<Key>,
-            class Alloc = std::allocator<std::pair<Key const, Mapped> > >
+            class Alloc = std::allocator<Key> >
        class ``[classref boost::unordered_map unordered_map]``;

 The hash function comes first as you might want to change the hash function
@@ -23,7 +23,7 @@ but not the equality predicate. For example, if you wanted to use the
 [import src_code/dictionary.cpp]
 [case_sensitive_dictionary_fnv]

-There is an [@boost:/libs/unordered/examples/fnv1.hpp implementation
+There is an [@../../libs/unordered/examples/fnv1.hpp implementation
 of FNV-1] in the examples directory.

 If you wish to use a different equality function,
@@ -38,7 +38,7 @@ Which you can then use in a case insensitive dictionary:
 [case_insensitive_dictionary]

 This is a simplified version of the example at
-[@boost:/libs/unordered/examples/case_insensitive.hpp /libs/unordered/examples/case_insensitive.hpp]
+[@../../libs/unordered/examples/case_insensitive.hpp /libs/unordered/examples/case_insensitive.hpp]
 which supports other locales and string types.

 [caution
@@ -1,5 +1,5 @@
 <!--
-Copyright Daniel James 2006-2009
+Copyright Daniel James 2006-2008
 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)
 --><library-reference>
@@ -19,12 +19,12 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              <default><type>std::allocator&lt;Value&gt;</type></default>
            </template-type-parameter>
          </template>
-          <purpose><simpara>
+          <purpose>
            An unordered associative container that stores unique values.
-          </simpara></purpose>
+          </purpose>
          <description>
            <para>For the normative reference see chapter 23 of
-              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008-2009/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
+              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
            <para><emphasis role="bold">Template Parameters</emphasis>
              <informaltable>
                <tgroup cols="2">
@@ -69,11 +69,11 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
          </typedef>
          <typedef name="reference">
            <type>typename allocator_type::reference</type>
-            <purpose><simpara>lvalue of <type>value_type</type>.</simpara></purpose>
+            <purpose>lvalue of <type>value_type</type>.</purpose>
          </typedef>
          <typedef name="const_reference">
            <type>typename allocator_type::const_reference</type>
-            <purpose><simpara>const lvalue of <type>value_type</type>.</simpara></purpose>
+            <purpose>const lvalue of <type>value_type</type>.</purpose>
          </typedef>
          <typedef name="size_type">
            <type><emphasis>implementation-defined</emphasis></type>
@@ -284,9 +284,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              <notes>
                <para>Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.</para>
                <para>Pointers and references to elements are never invalidated.</para>
-                <para>If the compiler doesn't support variadic template arguments or rvalue
-                      references, this is emulated for up to 10 arguments, with no support
-                      for rvalue references or move semantics.</para>
+                <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
              </notes>
            </method>
            <method name="emplace_hint">
@@ -315,9 +313,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                <para>The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same value. </para>
                <para>Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.</para>
                <para>Pointers and references to elements are never invalidated.</para>
-                <para>If the compiler doesn't support variadic template arguments or rvalue
-                      references, this is emulated for up to 10 arguments, with no support
-                      for rvalue references or move semantics.</para>
+                <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
              </notes>
            </method>
            <method name="insert">
@@ -757,12 +753,12 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              <default><type>std::allocator&lt;Value&gt;</type></default>
            </template-type-parameter>
          </template>
-          <purpose><simpara>
+          <purpose>
            An unordered associative container that stores  values. The same key can be stored multiple times.
-          </simpara></purpose>
+          </purpose>
          <description>
            <para>For the normative reference see chapter 23 of
-              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008-2009/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
+              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
            <para><emphasis role="bold">Template Parameters</emphasis>
              <informaltable>
                <tgroup cols="2">
@@ -807,11 +803,11 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
          </typedef>
          <typedef name="reference">
            <type>typename allocator_type::reference</type>
-            <purpose><simpara>lvalue of <type>value_type</type>.</simpara></purpose>
+            <purpose>lvalue of <type>value_type</type>.</purpose>
          </typedef>
          <typedef name="const_reference">
            <type>typename allocator_type::const_reference</type>
-            <purpose><simpara>const lvalue of <type>value_type</type>.</simpara></purpose>
+            <purpose>const lvalue of <type>value_type</type>.</purpose>
          </typedef>
          <typedef name="size_type">
            <type><emphasis>implementation-defined</emphasis></type>
@@ -1021,9 +1017,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              <notes>
                <para>Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.</para>
                <para>Pointers and references to elements are never invalidated.</para>
-                <para>If the compiler doesn't support variadic template arguments or rvalue
-                      references, this is emulated for up to 10 arguments, with no support
-                      for rvalue references or move semantics.</para>
+                <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
              </notes>
            </method>
            <method name="emplace_hint">
@@ -1052,9 +1046,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                <para>The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same value. </para>
                <para>Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.</para>
                <para>Pointers and references to elements are never invalidated.</para>
-                <para>If the compiler doesn't support variadic template arguments or rvalue
-                      references, this is emulated for up to 10 arguments, with no support
-                      for rvalue references or move semantics.</para>
+                <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
              </notes>
            </method>
            <method name="insert">
@@ -1499,12 +1491,12 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              <default><type>std::allocator&lt;std::pair&lt;Key const, Mapped&gt; &gt;</type></default>
            </template-type-parameter>
          </template>
-          <purpose><simpara>
+          <purpose>
            An unordered associative container that associates unique keys with another value.
-          </simpara></purpose>
+          </purpose>
          <description>
            <para>For the normative reference see chapter 23 of
-              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008-2009/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
+              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
            <para><emphasis role="bold">Template Parameters</emphasis>
              <informaltable>
                <tgroup cols="2">
@@ -1555,11 +1547,11 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
          </typedef>
          <typedef name="reference">
            <type>typename allocator_type::reference</type>
-            <purpose><simpara>lvalue of <type>value_type</type>.</simpara></purpose>
+            <purpose>lvalue of <type>value_type</type>.</purpose>
          </typedef>
          <typedef name="const_reference">
            <type>typename allocator_type::const_reference</type>
-            <purpose><simpara>const lvalue of <type>value_type</type>.</simpara></purpose>
+            <purpose>const lvalue of <type>value_type</type>.</purpose>
          </typedef>
          <typedef name="size_type">
            <type><emphasis>implementation-defined</emphasis></type>
@@ -1770,9 +1762,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              <notes>
                <para>Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.</para>
                <para>Pointers and references to elements are never invalidated.</para>
-                <para>If the compiler doesn't support variadic template arguments or rvalue
-                      references, this is emulated for up to 10 arguments, with no support
-                      for rvalue references or move semantics.</para>
+                <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
              </notes>
            </method>
            <method name="emplace_hint">
@@ -1801,9 +1791,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                <para>The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same key. </para>
                <para>Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.</para>
                <para>Pointers and references to elements are never invalidated.</para>
-                <para>If the compiler doesn't support variadic template arguments or rvalue
-                      references, this is emulated for up to 10 arguments, with no support
-                      for rvalue references or move semantics.</para>
+                <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
              </notes>
            </method>
            <method name="insert">
@@ -2286,12 +2274,12 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              <default><type>std::allocator&lt;std::pair&lt;Key const, Mapped&gt; &gt;</type></default>
            </template-type-parameter>
          </template>
-          <purpose><simpara>
+          <purpose>
            An unordered associative container that associates  keys with another value. The same key can be stored multiple times.
-          </simpara></purpose>
+          </purpose>
          <description>
            <para>For the normative reference see chapter 23 of
-              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008-2009/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
+              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
            <para><emphasis role="bold">Template Parameters</emphasis>
              <informaltable>
                <tgroup cols="2">
@@ -2342,11 +2330,11 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
          </typedef>
          <typedef name="reference">
            <type>typename allocator_type::reference</type>
-            <purpose><simpara>lvalue of <type>value_type</type>.</simpara></purpose>
+            <purpose>lvalue of <type>value_type</type>.</purpose>
          </typedef>
          <typedef name="const_reference">
            <type>typename allocator_type::const_reference</type>
-            <purpose><simpara>const lvalue of <type>value_type</type>.</simpara></purpose>
+            <purpose>const lvalue of <type>value_type</type>.</purpose>
          </typedef>
          <typedef name="size_type">
            <type><emphasis>implementation-defined</emphasis></type>
@@ -2556,9 +2544,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              <notes>
                <para>Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.</para>
                <para>Pointers and references to elements are never invalidated.</para>
-                <para>If the compiler doesn't support variadic template arguments or rvalue
-                      references, this is emulated for up to 10 arguments, with no support
-                      for rvalue references or move semantics.</para>
+                <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
              </notes>
            </method>
            <method name="emplace_hint">
@@ -2587,9 +2573,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                <para>The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same key. </para>
                <para>Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.</para>
                <para>Pointers and references to elements are never invalidated.</para>
-                <para>If the compiler doesn't support variadic template arguments or rvalue
-                      references, this is emulated for up to 10 arguments, with no support
-                      for rvalue references or move semantics.</para>
+                <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
              </notes>
            </method>
            <method name="insert">
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2008-2009 Daniel James.
+// Copyright 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)

@@ -1,5 +1,5 @@

-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-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)

@@ -1,5 +1,5 @@

-// Copyright 2008-2009 Daniel James.
+// Copyright 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)

@@ -19,12 +19,4 @@
 #  define BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
 #endif

-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-#   if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-        // STLport doesn't have std::forward.
-#   else
-#       define BOOST_UNORDERED_STD_FORWARD
-#   endif
-#endif
-
 #endif
@@ -1,6 +1,6 @@

 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
-// Copyright (C) 2005-2009 Daniel James
+// Copyright (C) 2005-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)

@@ -12,11 +12,6 @@
 #endif

 #include <boost/config.hpp>
-#include <boost/unordered/detail/config.hpp>
-
-#if !defined(BOOST_UNORDERED_EMPLACE_LIMIT)
-#define BOOST_UNORDERED_EMPLACE_LIMIT 10
-#endif

 #include <cstddef>
 #include <boost/config/no_tr1/cmath.hpp>
@@ -33,40 +28,18 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/aligned_storage.hpp>
 #include <boost/type_traits/alignment_of.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/and.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/not.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/utility/swap.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-#include <boost/preprocessor/seq/enum.hpp>

 #include <boost/mpl/aux_/config/eti.hpp>

-#if !(defined(BOOST_UNORDERED_STD_FORWARD))
-
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-
-#define BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
-    BOOST_PP_ENUM_PARAMS_Z(z, n, typename Arg)
-#define BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
-    BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, Arg, const& arg)
-#define BOOST_UNORDERED_CALL_PARAMS(z, n) \
-    BOOST_PP_ENUM_PARAMS_Z(z, n, arg)
-
-#endif
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#if BOOST_MSVC >= 1400
-#pragma warning(disable:4267) // conversion from 'size_t' to 'unsigned int',
-                              // possible loss of data.
-#endif
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/not.hpp>
 #endif

 #if BOOST_WORKAROUND(__BORLANDC__, <= 0x0582)
@@ -85,7 +58,7 @@ namespace boost {
    namespace unordered_detail {
        template <class T> struct type_wrapper {};

-        static const std::size_t default_initial_bucket_count = 11;
+        static const std::size_t default_initial_bucket_count = 50;
        static const float minimum_max_load_factor = 1e-3f;

        inline std::size_t double_to_size_t(double f)
@@ -103,25 +76,18 @@ namespace boost {
            static std::ptrdiff_t const length;
        };

-#define BOOST_UNORDERED_PRIMES \
-        (5ul)(11ul)(17ul)(29ul)(37ul)(53ul)(67ul)(79ul) \
-        (97ul)(131ul)(193ul)(257ul)(389ul)(521ul)(769ul) \
-        (1031ul)(1543ul)(2053ul)(3079ul)(6151ul)(12289ul)(24593ul) \
-        (49157ul)(98317ul)(196613ul)(393241ul)(786433ul) \
-        (1572869ul)(3145739ul)(6291469ul)(12582917ul)(25165843ul) \
-        (50331653ul)(100663319ul)(201326611ul)(402653189ul)(805306457ul) \
-        (1610612741ul)(3221225473ul)(4294967291ul)
-
        template<typename T>
        std::size_t const prime_list_template<T>::value[] = {
-            BOOST_PP_SEQ_ENUM(BOOST_UNORDERED_PRIMES)
-        };
+            5ul, 11ul, 17ul, 29ul, 37ul, 53ul, 67ul, 79ul,
+            97ul, 131ul, 193ul, 257ul, 389ul, 521ul, 769ul,
+            1031ul, 1543ul, 2053ul, 3079ul, 6151ul, 12289ul, 24593ul,
+            49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
+            1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
+            50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
+            1610612741ul, 3221225473ul, 4294967291ul };

        template<typename T>
-        std::ptrdiff_t const prime_list_template<T>::length
-            = BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
-
-#undef BOOST_UNORDERED_PRIMES
+        std::ptrdiff_t const prime_list_template<T>::length = 28;

        typedef prime_list_template<std::size_t> prime_list;

@@ -258,15 +224,10 @@ namespace boost {
            functions_ptr func_; // The currently active functions.
        };
        
-#if defined(BOOST_MSVC)
-#  define BOOST_UNORDERED_DESTRUCT(x, type) (x)->~type();
-#else
-#  define BOOST_UNORDERED_DESTRUCT(x, type) boost::unordered_detail::destroy(x)
        template <typename T>
        void destroy(T* x) {
            x->~T();
        }
-#endif
    }
 }

@@ -340,8 +301,4 @@ namespace boost {
 #undef BOOST_UNORDERED_BORLAND_BOOL
 #undef BOOST_UNORDERED_MSVC_RESET_PTR

-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
 #endif // BOOST_UNORDERED_DETAIL_HASH_TABLE_HPP_INCLUDED
@@ -1,6 +1,6 @@

 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
-// Copyright (C) 2005-2009 Daniel James
+// Copyright (C) 2005-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)

@@ -89,7 +89,7 @@ namespace boost {
            struct value_base {
                typename boost::aligned_storage<
                    sizeof(value_type),
-                    ::boost::alignment_of<value_type>::value>::type data_;
+                    boost::alignment_of<value_type>::value>::type data_;

                void* address() { return this; }
            };
@@ -130,7 +130,7 @@ namespace boost {
                void destroy(link_ptr ptr)
                {
                    node* raw_ptr = static_cast<node*>(&*ptr);
-                    BOOST_UNORDERED_DESTRUCT(&raw_ptr->value(), value_type);
+                    boost::unordered_detail::destroy(&raw_ptr->value());
                    node_ptr n(node_alloc_.address(*raw_ptr));
                    node_alloc_.destroy(n);
                    node_alloc_.deallocate(n, 1);
@@ -172,7 +172,7 @@ namespace boost {
                {
                    if (node_) {
                        if (value_constructed_) {
-                            BOOST_UNORDERED_DESTRUCT(&node_->value(), value_type);
+                            boost::unordered_detail::destroy(&node_->value());
                        }

                        if (node_constructed_)
@@ -181,102 +181,39 @@ namespace boost {
                    }
                }

-                void construct_preamble()
-                {
-                    if(!node_) {
-                        node_constructed_ = false;
-                        value_constructed_ = false;
-
-                        node_ = allocators_.node_alloc_.allocate(1);
-                        allocators_.node_alloc_.construct(node_, node());
-                        node_constructed_ = true;
-                    }
-                    else {
-                        BOOST_ASSERT(node_constructed_ && value_constructed_);
-                        BOOST_UNORDERED_DESTRUCT(&node_->value(), value_type);
-                        value_constructed_ = false;
-                    }
-                }
-
-#if defined(BOOST_UNORDERED_STD_FORWARD)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
                template <typename... Args>
                void construct(Args&&... args)
                {
-                    construct_preamble();
+                    BOOST_ASSERT(!node_);
+                    node_constructed_ = false;
+                    value_constructed_ = false;
+
+                    node_ = allocators_.node_alloc_.allocate(1);
+
+                    allocators_.node_alloc_.construct(node_, node());
+                    node_constructed_ = true;
+
                    new(node_->address()) value_type(std::forward<Args>(args)...);
                    value_constructed_ = true;
                }
 #else
-
-#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, n, _)                                 \
-                template <                                                      \
-                    BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                         \
-                >                                                               \
-                void construct(                                                 \
-                    BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                       \
-                )                                                               \
-                {                                                               \
-                    construct_preamble();                                       \
-                    construct_impl(                                             \
-                        (value_type*) 0,                                        \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                       \
-                    );                                                          \
-                    value_constructed_ = true;                                  \
-                }                                                               \
-                                                                                \
-                template <                                                      \
-                    typename T,                                                 \
-                    BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                         \
-                >                                                               \
-                void construct_impl(                                            \
-                    T*,                                                         \
-                    BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                       \
-                )                                                               \
-                {                                                               \
-                    new(node_->address()) value_type(                           \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                       \
-                    );                                                          \
-                }
-                                                                                
-#define BOOST_UNORDERED_CONSTRUCT_IMPL2(z, n, _)                                \
-                template <typename First, typename Second, typename Key,        \
-                    BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                         \
-                >                                                               \
-                void construct_impl(                                            \
-                    std::pair<First, Second>*,                                  \
-                    Key const& k,                                               \
-                    BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                       \
-                )                                                               \
-                {                                                               \
-                    new(node_->address()) value_type(k,                         \
-                        Second(                                                 \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                       \
-                        )                                                       \
-                    );                                                          \
-                }
-
-                BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
-                    BOOST_UNORDERED_CONSTRUCT_IMPL, _)
-                BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
-                    BOOST_UNORDERED_CONSTRUCT_IMPL2, _)
-                
-                template <typename First, typename Second, typename T1, typename T2>
-                void construct_impl(std::pair<First, Second>*,
-                    std::pair<T1, T2> const& arg0)
+                template <typename V>
+                void construct(V const& v)
                {
-                    new(node_->address()) value_type(arg0);
-                }
+                    BOOST_ASSERT(!node_);
+                    node_constructed_ = false;
+                    value_constructed_ = false;

-#undef BOOST_UNORDERED_CONSTRUCT_IMPL
+                    node_ = allocators_.node_alloc_.allocate(1);

-#endif
-                template <typename K, typename M>
-                void construct_pair(K const& k, M*)
-                {
-                    construct_preamble();
-                    new(node_->address()) value_type(k, M());                    
+                    allocators_.node_alloc_.construct(node_, node());
+                    node_constructed_ = true;
+
+                    new(node_->address()) value_type(v);
                    value_constructed_ = true;
                }
+#endif

                node_ptr get() const
                {
@@ -1166,7 +1103,7 @@ namespace boost {

                // This can throw, but BOOST_UNORDERED_TABLE_DATA's destructor will clean
                // up.
-                x.copy_buckets_to(data_);
+                copy_buckets(x.data_, data_, functions_.current());
            }

            // Copy Construct with allocator
@@ -1181,7 +1118,7 @@ namespace boost {

                // This can throw, but BOOST_UNORDERED_TABLE_DATA's destructor will clean
                // up.
-                x.copy_buckets_to(data_);
+                copy_buckets(x.data_, data_, functions_.current());
            }

            // Move Construct
@@ -1206,14 +1143,14 @@ namespace boost {
                if(x.data_.buckets_) {
                    // This can throw, but BOOST_UNORDERED_TABLE_DATA's destructor will clean
                    // up.
-                    x.copy_buckets_to(data_);
+                    copy_buckets(x.data_, data_, functions_.current());
                }
            }

            // Assign
            //
            // basic exception safety, if buffered_functions::buffer or reserver throws
-            // the container is left in a sane, empty state. If copy_buckets_to
+            // the container is left in a sane, empty state. If copy_buckets
            // throws the container is left with whatever was successfully
            // copied.

@@ -1227,7 +1164,7 @@ namespace boost {
                    mlf_ = x.mlf_;                        // no throw
                    calculate_max_load();                 // no throw
                    reserve(x.size());                    // throws
-                    x.copy_buckets_to(data_); // throws
+                    copy_buckets(x.data_, data_, functions_.current()); // throws
                }

                return *this;
@@ -1270,10 +1207,10 @@ namespace boost {
                    // which will clean up if anything throws an exception.
                    // (all can throw, but with no effect as these are new objects).
                    data new_this(data_, x.min_buckets_for_size(x.data_.size_));
-                    x.copy_buckets_to(new_this);
+                    copy_buckets(x.data_, new_this, functions_.*new_func_this);

                    data new_that(x.data_, min_buckets_for_size(data_.size_));
-                    copy_buckets_to(new_that);
+                    x.copy_buckets(data_, new_that, x.functions_.*new_func_that);

                    // Start updating the data here, no throw from now on.
                    data_.swap(new_this);
@@ -1314,7 +1251,7 @@ namespace boost {
                    // which will clean up if anything throws an exception.
                    // (all can throw, but with no effect as these are new objects).
                    data new_this(data_, x.min_buckets_for_size(x.data_.size_));
-                    x.copy_buckets_to(new_this);
+                    copy_buckets(x.data_, new_this, functions_.*new_func_this);

                    // Start updating the data here, no throw from now on.
                    data_.move(new_this);
@@ -1474,29 +1411,8 @@ namespace boost {
            }

            // key extractors
-            //
+
            // no throw
-            //
-            // 'extract_key' is called with the emplace parameters to return a
-            // key if available or 'no_key' is one isn't and will need to be
-            // constructed.
-
-            struct no_key {
-                no_key() {}
-                template <class T> no_key(T const&) {}
-            };
-
-
-            // If emplace is called with no arguments then there obviously
-            // isn't an available key.
-
-            static no_key extract_key()
-            {
-                return no_key();
-            }
-            
-            // Emplace or insert was called with the value type.
-            
            static key_type const& extract_key(value_type const& v)
            {
                return extract(v, (type_wrapper<value_type>*)0);
@@ -1513,67 +1429,40 @@ namespace boost {
            {
                return v.first;
            }
-            
-            // For maps, if emplace is called with just a key, then it's the value type
-            // with the second value default initialised.
-            
-            template <typename Arg>
-            static BOOST_DEDUCED_TYPENAME
-                boost::mpl::if_<boost::is_same<Arg, key_type>, key_type const&, no_key>::type
-                extract_key(Arg const& k)
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+            struct no_key {};
+
+            template <typename Arg1, typename... Args>
+            static typename boost::enable_if<
+                boost::mpl::and_<
+                    boost::mpl::not_<boost::is_same<key_type, value_type> >,
+                    boost::is_same<Arg1, key_type>
+                >,
+                key_type>::type const& extract_key(Arg1 const& k, Args const&...)
            {
                return k;
            }

-            // For a map, the argument might be a pair with the key as the first
-            // part and a convertible value as the second part.
-
            template <typename First, typename Second>
-            static BOOST_DEDUCED_TYPENAME
-                boost::mpl::if_<
-                    boost::mpl::and_<
-                        boost::mpl::not_<boost::is_same<key_type, value_type> >,
-                        boost::is_same<key_type,
-                            typename boost::remove_const<
-                                typename boost::remove_reference<First>::type
-                            >::type>
-                    >,
-                    key_type const&, no_key
-                >::type extract_key(std::pair<First, Second> const& v)
+            static typename boost::enable_if<
+                boost::mpl::and_<
+                    boost::mpl::not_<boost::is_same<key_type, value_type> >,
+                    boost::is_same<key_type,
+                        typename boost::remove_const<
+                            typename boost::remove_reference<First>::type
+                        >::type>
+                >,
+                key_type>::type const& extract_key(std::pair<First, Second> const& v)
            {
                return v.first;
            }

-            // For maps if there is more than one argument, the key can be the first argument.
-
-#if defined(BOOST_UNORDERED_STD_FORWARD)
-            template <typename Arg, typename Arg1, typename... Args>
-            static BOOST_DEDUCED_TYPENAME
-                boost::mpl::if_<
-                    boost::mpl::and_<
-                        boost::mpl::not_<boost::is_same<value_type, key_type> >,
-                        boost::is_same<Arg, key_type>
-                    >,
-                    key_type const&, no_key
-                >::type extract_key(Arg const& k, Arg1 const&, Args const&...)
+            template <typename... Args>
+            static no_key extract_key(Args const&...)
            {
-                return k;
+                return no_key();
            }
-
-#else
-            template <typename Arg, typename Arg1>
-            static BOOST_DEDUCED_TYPENAME
-                boost::mpl::if_<
-                    boost::mpl::and_<
-                        boost::mpl::not_<boost::is_same<value_type, key_type> >,
-                        boost::is_same<Arg, key_type>
-                    >,
-                    key_type const&, no_key
-                >::type extract_key(Arg const& k, Arg1 const&)
-            {
-                return k;
-            }
-
 #endif

        public:
@@ -1605,23 +1494,22 @@ namespace boost {
                    return;

                data new_buckets(data_, n); // throws, seperate
-                move_buckets_to(new_buckets);           // basic/no throw
+                move_buckets(data_, new_buckets, hash_function());
+                                                        // basic/no throw
                new_buckets.swap(data_);                // no throw
                calculate_max_load();                   // no throw
            }

-            // move_buckets_to & copy_buckets_to
+            // move_buckets & copy_buckets
            //
            // if the hash function throws, basic excpetion safety
            // no throw otherwise

-            void move_buckets_to(data& dst)
+            static void move_buckets(data& src, data& dst, hasher const& hf)
            {
                BOOST_ASSERT(dst.size_ == 0);
                //BOOST_ASSERT(src.allocators_.node_alloc_ == dst.allocators_.node_alloc_);

-                data& src = this->data_;
-                hasher const& hf = this->hash_function();
                bucket_ptr end = src.buckets_end();

                for(; src.cached_begin_bucket_ != end;
@@ -1645,14 +1533,12 @@ namespace boost {
            // basic excpetion safety. If an exception is thrown this will
            // leave dst partially filled.

-            void copy_buckets_to(data& dst) const
+            static void copy_buckets(data const& src, data& dst, functions const& f)
            {
                BOOST_ASSERT(dst.size_ == 0);
-
                // no throw:
-                data const& src = this->data_;
-                hasher const& hf = this->hash_function();
                bucket_ptr end = src.buckets_end();
+                hasher const& hf = f.hash_function();

                // no throw:
                for(bucket_ptr i = src.cached_begin_bucket_; i != end; ++i) {
@@ -1677,78 +1563,72 @@ namespace boost {

 #if BOOST_UNORDERED_EQUIVALENT_KEYS

-#if defined(BOOST_UNORDERED_STD_FORWARD)
-
-            // Emplace (equivalent key containers)
-            // (I'm using an overloaded emplace for both 'insert' and 'emplace')
+#if !(defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL))
+            // Insert (equivalent key containers)

            // if hash function throws, basic exception safety
            // strong otherwise
-            template <class... Args>
-            iterator_base emplace(Args&&... args)
+            iterator_base insert(value_type const& v)
            {
                // Create the node before rehashing in case it throws an
                // exception (need strong safety in such a case).
                node_constructor a(data_.allocators_);
-                a.construct(std::forward<Args>(args)...);
+                a.construct(v);

-                return emplace_impl(a);
+                return insert_impl(a);
            }

-            // Emplace (equivalent key containers)
-            // (I'm using an overloaded emplace for both 'insert' and 'emplace')
+            // Insert (equivalent key containers)

            // if hash function throws, basic exception safety
            // strong otherwise
-            template <class... Args>
-            iterator_base emplace_hint(iterator_base const& it, Args&&... args)
+            iterator_base insert_hint(iterator_base const& it, value_type const& v)
            {
                // Create the node before rehashing in case it throws an
                // exception (need strong safety in such a case).
                node_constructor a(data_.allocators_);
-                a.construct(std::forward<Args>(args)...);
+                a.construct(v);

-                return emplace_hint_impl(it, a);
+                return insert_hint_impl(it, a);
            }

 #else

-#define BOOST_UNORDERED_INSERT_IMPL(z, n, _)                                        \
-            template <                                                              \
-               BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                                  \
-            >                                                                       \
-            iterator_base emplace(                                                  \
-               BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                                \
-            )                                                                       \
-            {                                                                       \
-                node_constructor a(data_.allocators_);                              \
-                a.construct(                                                        \
-                    BOOST_UNORDERED_CALL_PARAMS(z, n)                               \
-                );                                                                  \
-                return emplace_impl(a);                                             \
-            }                                                                       \
-                                                                                    \
-            template <                                                              \
-               BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                                  \
-            >                                                                       \
-            iterator_base emplace_hint(iterator_base const& it,                     \
-               BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                                \
-            )                                                                       \
-            {                                                                       \
-                node_constructor a(data_.allocators_);                              \
-                a.construct(                                                        \
-                    BOOST_UNORDERED_CALL_PARAMS(z, n)                               \
-                );                                                                  \
-                return emplace_hint_impl(it, a);                                    \
+            // Insert (equivalent key containers)
+            // (I'm using an overloaded insert for both 'insert' and 'emplace')
+
+            // if hash function throws, basic exception safety
+            // strong otherwise
+            template <class... Args>
+            iterator_base insert(Args&&... args)
+            {
+                // Create the node before rehashing in case it throws an
+                // exception (need strong safety in such a case).
+                node_constructor a(data_.allocators_);
+                a.construct(std::forward<Args>(args)...);
+
+                return insert_impl(a);
            }

-            BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
-                BOOST_UNORDERED_INSERT_IMPL, _)
+            // Insert (equivalent key containers)
+            // (I'm using an overloaded insert for both 'insert' and 'emplace')
+
+            // if hash function throws, basic exception safety
+            // strong otherwise
+            template <class... Args>
+            iterator_base insert_hint(iterator_base const& it, Args&&... args)
+            {
+                // Create the node before rehashing in case it throws an
+                // exception (need strong safety in such a case).
+                node_constructor a(data_.allocators_);
+                a.construct(std::forward<Args>(args)...);
+
+                return insert_hint_impl(it, a);
+            }

-#undef BOOST_UNORDERED_INSERT_IMPL
 #endif

-            iterator_base emplace_impl(node_constructor& a)
+            iterator_base insert_impl(node_constructor& a)
            {
                key_type const& k = extract_key(a.get()->value());
                size_type hash_value = hash_function()(k);
@@ -1769,17 +1649,17 @@ namespace boost {
                );
            }

-            iterator_base emplace_hint_impl(iterator_base const& it, node_constructor& a)
+            iterator_base insert_hint_impl(iterator_base const& it, node_constructor& a)
            {
                // equal can throw, but with no effects
                if (it == data_.end() || !equal(extract_key(a.get()->value()), *it)) {
-                    // Use the standard emplace if the iterator doesn't point
+                    // Use the standard insert if the iterator doesn't point
                    // to a matching key.
-                    return emplace_impl(a);
+                    return insert_impl(a);
                }
                else {
                    // Find the first node in the group - so that the node
-                    // will be added at the end of the group.
+                    // will be inserted at the end of the group.

                    link_ptr start(it.node_);
                    while(data_.prev_in_group(start)->next_ == start)
@@ -1808,7 +1688,7 @@ namespace boost {
            {
                size_type distance = unordered_detail::distance(i, j);
                if(distance == 1) {
-                    emplace(*i);
+                    insert(*i);
                }
                else {
                    // Only require basic exception safety here
@@ -1838,7 +1718,7 @@ namespace boost {
            {
                // If only inserting 1 element, get the required
                // safety since insert is only called once.
-                for (; i != j; ++i) emplace(*i);
+                for (; i != j; ++i) insert(*i);
            }

        public:
@@ -1874,7 +1754,7 @@ namespace boost {
                    // Create the node before rehashing in case it throws an
                    // exception (need strong safety in such a case).
                    node_constructor a(data_.allocators_);
-                    a.construct_pair(k, (mapped_type*) 0);
+                    a.construct(value_type(k, mapped_type()));

                    // reserve has basic exception safety if the hash function
                    // throws, strong otherwise.
@@ -1887,37 +1767,81 @@ namespace boost {
                }
            }

-#if defined(BOOST_UNORDERED_STD_FORWARD)
+#if !(defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL))

-            // Emplace (unique keys)
-            // (I'm using an overloaded emplace for both 'insert' and 'emplace')
+            // Insert (unique keys)
+
+            // if hash function throws, basic exception safety
+            // strong otherwise
+            std::pair<iterator_base, bool> insert(value_type const& v)
+            {
+                // No side effects in this initial code
+                key_type const& k = extract_key(v);
+                size_type hash_value = hash_function()(k);
+                bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value);
+                link_ptr pos = find_iterator(bucket, k);
+
+                if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
+                    // Found an existing key, return it (no throw).
+                    return std::pair<iterator_base, bool>(
+                        iterator_base(bucket, pos), false);
+
+                } else {
+                    // Doesn't already exist, add to bucket.
+                    // Side effects only in this block.
+
+                    // Create the node before rehashing in case it throws an
+                    // exception (need strong safety in such a case).
+                    node_constructor a(data_.allocators_);
+                    a.construct(v);
+
+                    // reserve has basic exception safety if the hash function
+                    // throws, strong otherwise.
+                    if(reserve_for_insert(size() + 1))
+                        bucket = data_.bucket_ptr_from_hash(hash_value);
+
+                    // Nothing after this point can throw.
+
+                    link_ptr n = data_.link_node_in_bucket(a, bucket);
+
+                    return std::pair<iterator_base, bool>(
+                        iterator_base(bucket, n), true);
+                }
+            }
+
+            // Insert (unique keys)
+
+            // if hash function throws, basic exception safety
+            // strong otherwise
+            iterator_base insert_hint(iterator_base const& it, value_type const& v)
+            {
+                if(it != data_.end() && equal(extract_key(v), *it))
+                    return it;
+                else
+                    return insert(v).first;
+            }
+
+#else
+
+            // Insert (unique keys)
+            // (I'm using an overloaded insert for both 'insert' and 'emplace')
+            //
+            // TODO:
+            // For sets: create a local key without creating the node?
+            // For maps: use the first argument as the key.

            // if hash function throws, basic exception safety
            // strong otherwise
            template<typename... Args>
-            std::pair<iterator_base, bool> emplace(Args&&... args)
+            std::pair<iterator_base, bool> insert(Args&&... args)
            {
-                return emplace_impl(
+                return insert_impl(
                    extract_key(std::forward<Args>(args)...),
                    std::forward<Args>(args)...);
            }

-            // Insert (unique keys)
-            // (I'm using an overloaded emplace for both 'insert' and 'emplace')
-            // I'm just ignoring hints here for now.
-
-            // if hash function throws, basic exception safety
-            // strong otherwise
            template<typename... Args>
-            iterator_base emplace_hint(iterator_base const&, Args&&... args)
-            {
-                return emplace_impl(
-                    extract_key(std::forward<Args>(args)...),
-                    std::forward<Args>(args)...).first;
-            }
-
-            template<typename... Args>
-            std::pair<iterator_base, bool> emplace_impl(key_type const& k, Args&&... args)
+            std::pair<iterator_base, bool> insert_impl(key_type const& k, Args&&... args)
            {
                // No side effects in this initial code
                size_type hash_value = hash_function()(k);
@@ -1951,110 +1875,13 @@ namespace boost {
            }

            template<typename... Args>
-            std::pair<iterator_base, bool> emplace_impl(no_key, Args&&... args)
+            std::pair<iterator_base, bool> insert_impl(no_key, Args&&... args)
            {
                // Construct the node regardless - in order to get the key.
                // It will be discarded if it isn't used
                node_constructor a(data_.allocators_);
                a.construct(std::forward<Args>(args)...);
-                return emplace_impl_with_node(a);
-            }
-#else
-            template <typename Arg0>
-            std::pair<iterator_base, bool> emplace(Arg0 const& arg0)
-            {
-                return emplace_impl(extract_key(arg0), arg0);
-            }

-            template <typename Arg0>
-            iterator_base emplace_hint(iterator_base const& it, Arg0 const& arg0)
-            {
-                return emplace_impl(extract_key(arg0), arg0).first;
-            }
-
-
-#define BOOST_UNORDERED_INSERT_IMPL(z, n, _)                                        \
-            template <                                                              \
-               BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                                  \
-            >                                                                       \
-            std::pair<iterator_base, bool> emplace(                                 \
-               BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                                \
-            )                                                                       \
-            {                                                                       \
-                return emplace_impl(                                                \
-                    extract_key(arg0, arg1),                                        \
-                    BOOST_UNORDERED_CALL_PARAMS(z, n)                               \
-                );                                                                  \
-            }                                                                       \
-                                                                                    \
-            template <                                                              \
-               BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                                  \
-            >                                                                       \
-            iterator_base emplace_hint(iterator_base const& it,                     \
-               BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                                \
-            )                                                                       \
-            {                                                                       \
-                return emplace_impl(                                                \
-                    extract_key(arg0, arg1),                                        \
-                    BOOST_UNORDERED_CALL_PARAMS(z, n)                               \
-                ).first;                                                            \
-            }                                                                       \
-            BOOST_UNORDERED_INSERT_IMPL2(z, n, _)
-
-#define BOOST_UNORDERED_INSERT_IMPL2(z, n, _)                                       \
-            template <                                                              \
-               BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                                  \
-            >                                                                       \
-            std::pair<iterator_base, bool> emplace_impl(key_type const& k,          \
-               BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                                \
-            )                                                                       \
-            {                                                                       \
-                size_type hash_value = hash_function()(k);                          \
-                bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value);         \
-                link_ptr pos = find_iterator(bucket, k);                            \
-                                                                                    \
-                if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {                            \
-                    return std::pair<iterator_base, bool>(                          \
-                        iterator_base(bucket, pos), false);                         \
-                } else {                                                            \
-                    node_constructor a(data_.allocators_);                          \
-                    a.construct(                                                    \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                           \
-                    );                                                              \
-                                                                                    \
-                    if(reserve_for_insert(size() + 1))                              \
-                        bucket = data_.bucket_ptr_from_hash(hash_value);            \
-                                                                                    \
-                    return std::pair<iterator_base, bool>(iterator_base(bucket,     \
-                        data_.link_node_in_bucket(a, bucket)), true);               \
-                }                                                                   \
-            }                                                                       \
-                                                                                    \
-            template <                                                              \
-               BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                                  \
-            >                                                                       \
-            std::pair<iterator_base, bool> emplace_impl(no_key,                     \
-               BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                                \
-            )                                                                       \
-            {                                                                       \
-                node_constructor a(data_.allocators_);                              \
-                a.construct(                                                        \
-                    BOOST_UNORDERED_CALL_PARAMS(z, n)                               \
-                );                                                                  \
-                return emplace_impl_with_node(a);                                   \
-            }
-
-            BOOST_UNORDERED_INSERT_IMPL2(1, 1, _)
-
-            BOOST_PP_REPEAT_FROM_TO(2, BOOST_UNORDERED_EMPLACE_LIMIT,
-                BOOST_UNORDERED_INSERT_IMPL, _)
-
-#undef BOOST_UNORDERED_INSERT_IMPL
-
-#endif
-
-            std::pair<iterator_base, bool> emplace_impl_with_node(node_constructor& a)
-            {
                // No side effects in this initial code
                key_type const& k = extract_key(a.get()->value());
                size_type hash_value = hash_function()(k);
@@ -2078,6 +1905,19 @@ namespace boost {
                }
            }

+            // Insert (unique keys)
+            // (I'm using an overloaded insert for both 'insert' and 'emplace')
+
+            // if hash function throws, basic exception safety
+            // strong otherwise
+            template<typename... Args>
+            iterator_base insert_hint(iterator_base const&, Args&&... args)
+            {
+                // Life is complicated - just call the normal implementation.
+                return insert(std::forward<Args>(args)...).first;
+            }
+#endif
+
            // Insert from iterators (unique keys)

            template <typename I>
@@ -2104,13 +1944,6 @@ namespace boost {
            // strong otherwise
            template <typename InputIterator>
            void insert_range(InputIterator i, InputIterator j)
-            {
-                if(i != j)
-                    return insert_range_impl(extract_key(*i), i, j);
-            }
-            
-            template <typename InputIterator>
-            void insert_range_impl(key_type const&, InputIterator i, InputIterator j)
            {
                node_constructor a(data_.allocators_);

@@ -2140,36 +1973,6 @@ namespace boost {
                    }
                }
            }
-
-            template <typename InputIterator>
-            void insert_range_impl(no_key, InputIterator i, InputIterator j)
-            {
-                node_constructor a(data_.allocators_);
-
-                for (; i != j; ++i) {
-                    // No side effects in this initial code
-                    a.construct(*i);
-                    key_type const& k = extract_key(a.get()->value());
-                    size_type hash_value = hash_function()(extract_key(k));
-                    bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value);
-                    link_ptr pos = find_iterator(bucket, k);
-
-                    if (!BOOST_UNORDERED_BORLAND_BOOL(pos)) {
-                        // Doesn't already exist, add to bucket.
-                        // Side effects only in this block.
-
-                        // reserve has basic exception safety if the hash function
-                        // throws, strong otherwise.
-                        if(size() + 1 >= max_load_) {
-                            reserve_for_insert(size() + insert_size(i, j));
-                            bucket = data_.bucket_ptr_from_hash(hash_value);
-                        }
-
-                        // Nothing after this point can throw.
-                        data_.link_node_in_bucket(a, bucket);
-                    }
-                }
-            }
 #endif
        public:

@@ -2256,9 +2059,8 @@ namespace boost {
                    key_type const& k) const
            {
                link_ptr it = data_.begin(bucket);
-                while (BOOST_UNORDERED_BORLAND_BOOL(it) && !equal(k, data::get_value(it))) {
+                while (BOOST_UNORDERED_BORLAND_BOOL(it) && !equal(k, data::get_value(it)))
                    it = data::next_group(it);
-                }

                return it;
            }
@@ -1,6 +1,6 @@

 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
-// Copyright (C) 2005-2009 Daniel James.
+// Copyright (C) 2005-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)

@@ -21,10 +21,6 @@
 #include <boost/unordered/detail/move.hpp>
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
-
 #if defined(BOOST_MSVC)
 #pragma warning(push)
 #if BOOST_MSVC >= 1400
@@ -39,9 +35,6 @@ namespace boost
    template <class Key, class T, class Hash, class Pred, class Alloc>
    class unordered_map
    {
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
-    public:
-#endif
        typedef boost::unordered_detail::hash_types_unique_keys<
            std::pair<const Key, T>, Key, Hash, Pred, Alloc
        > implementation;
@@ -105,23 +98,12 @@ namespace boost
        unordered_map(InputIterator f, InputIterator l,
                size_type n,
                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal())
-            : base(f, l, n, hf, eql, allocator_type())
-        {
-        }
-
-        template <class InputIterator>
-        unordered_map(InputIterator f, InputIterator l,
-                size_type n,
-                const hasher &hf,
-                const key_equal &eql,
-                const allocator_type &a)
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
            : base(f, l, n, hf, eql, a)
        {
        }

-        ~unordered_map() {}
-
 #if defined(BOOST_HAS_RVALUE_REFS)
        unordered_map(unordered_map&& other)
            : base(other.base, boost::unordered_detail::move_tag())
@@ -153,7 +135,7 @@ namespace boost
 #endif
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_INITIALIZER_LISTS)
        unordered_map(std::initializer_list<value_type> list,
                size_type n = boost::unordered_detail::default_initial_bucket_count,
                const hasher &hf = hasher(),
@@ -237,74 +219,30 @@ namespace boost

        // modifiers

-#if defined(BOOST_UNORDERED_STD_FORWARD)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
        template <class... Args>
        std::pair<iterator, bool> emplace(Args&&... args)
        {
            return boost::unordered_detail::pair_cast<iterator, bool>(
-                base.emplace(std::forward<Args>(args)...));
+                base.insert(std::forward<Args>(args)...));
        }

        template <class... Args>
        iterator emplace_hint(const_iterator hint, Args&&... args)
        {
-            return iterator(base.emplace_hint(get(hint), std::forward<Args>(args)...));
+            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
        }
-#else
-
-        std::pair<iterator, bool> emplace(value_type const& v = value_type())
-        {
-            return boost::unordered_detail::pair_cast<iterator, bool>(
-                base.emplace(v));
-        }
-
-        iterator emplace_hint(const_iterator hint, value_type const& v = value_type())
-        {
-            return iterator(base.emplace_hint(get(hint), v));
-        }
-
-#define BOOST_UNORDERED_EMPLACE(z, n, _)                                        \
-            template <                                                          \
-                BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                             \
-            >                                                                   \
-            std::pair<iterator, bool> emplace(                                  \
-                BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                           \
-            )                                                                   \
-            {                                                                   \
-                return boost::unordered_detail::pair_cast<iterator, bool>(      \
-                    base.emplace(                                               \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                       \
-                    ));                                                         \
-            }                                                                   \
-                                                                                \
-            template <                                                          \
-                BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                             \
-            >                                                                   \
-            iterator emplace_hint(const_iterator hint,                          \
-                BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                           \
-            )                                                                   \
-            {                                                                   \
-                return iterator(base.emplace_hint(get(hint),                    \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                       \
-                ));                                                             \
-            }
-
-        BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
-            BOOST_UNORDERED_EMPLACE, _)
-
-#undef BOOST_UNORDERED_EMPLACE
-
 #endif

        std::pair<iterator, bool> insert(const value_type& obj)
        {
            return boost::unordered_detail::pair_cast<iterator, bool>(
-                    base.emplace(obj));
+                    base.insert(obj));
        }

        iterator insert(const_iterator hint, const value_type& obj)
        {
-            return iterator(base.emplace_hint(get(hint), obj));
+            return iterator(base.insert_hint(get(hint), obj));
        }

        template <class InputIterator>
@@ -473,7 +411,7 @@ namespace boost
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
        friend bool operator==(unordered_map const&, unordered_map const&);
        friend bool operator!=(unordered_map const&, unordered_map const&);
-#elif !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
+#else
        friend bool operator==<Key, T, Hash, Pred, Alloc>(unordered_map const&, unordered_map const&);
        friend bool operator!=<Key, T, Hash, Pred, Alloc>(unordered_map const&, unordered_map const&);
 #endif
@@ -503,9 +441,6 @@ namespace boost
    template <class Key, class T, class Hash, class Pred, class Alloc>
    class unordered_multimap
    {
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
-    public:
-#endif
        typedef boost::unordered_detail::hash_types_equivalent_keys<
            std::pair<const Key, T>, Key, Hash, Pred, Alloc
        > implementation;
@@ -569,23 +504,12 @@ namespace boost
        unordered_multimap(InputIterator f, InputIterator l,
                size_type n,
                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal())
-          : base(f, l, n, hf, eql, allocator_type())
-        {
-        }
-
-        template <class InputIterator>
-        unordered_multimap(InputIterator f, InputIterator l,
-                size_type n,
-                const hasher &hf,
-                const key_equal &eql,
-                const allocator_type &a)
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
          : base(f, l, n, hf, eql, a)
        {
        }

-        ~unordered_multimap() {}
-
 #if defined(BOOST_HAS_RVALUE_REFS)
        unordered_multimap(unordered_multimap&& other)
            : base(other.base, boost::unordered_detail::move_tag())
@@ -617,7 +541,7 @@ namespace boost
 #endif
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_INITIALIZER_LISTS)
        unordered_multimap(std::initializer_list<value_type> list,
                size_type n = boost::unordered_detail::default_initial_bucket_count,
                const hasher &hf = hasher(),
@@ -702,72 +626,28 @@ namespace boost

        // modifiers

-#if defined(BOOST_UNORDERED_STD_FORWARD)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
        template <class... Args>
        iterator emplace(Args&&... args)
        {
-            return iterator(base.emplace(std::forward<Args>(args)...));
+            return iterator(base.insert(std::forward<Args>(args)...));
        }

        template <class... Args>
        iterator emplace_hint(const_iterator hint, Args&&... args)
        {
-            return iterator(base.emplace_hint(get(hint), std::forward<Args>(args)...));
+            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
        }
-#else
-
-        iterator emplace(value_type const& v = value_type())
-        {
-            return iterator(base.emplace(v));
-        }
-        
-        iterator emplace_hint(const_iterator hint, value_type const& v = value_type())
-        {
-            return iterator(base.emplace_hint(get(hint), v));
-        }
-
-
-#define BOOST_UNORDERED_EMPLACE(z, n, _)                                        \
-            template <                                                          \
-                BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                             \
-            >                                                                   \
-            iterator emplace(                                                   \
-                BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                           \
-            )                                                                   \
-            {                                                                   \
-                return iterator(                                                \
-                    base.emplace(                                               \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                       \
-                    ));                                                         \
-            }                                                                   \
-                                                                                \
-            template <                                                          \
-                BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                             \
-            >                                                                   \
-            iterator emplace_hint(const_iterator hint,                          \
-                BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                           \
-            )                                                                   \
-            {                                                                   \
-                return iterator(base.emplace_hint(get(hint),                    \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                       \
-                ));                                                             \
-            }
-
-        BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
-            BOOST_UNORDERED_EMPLACE, _)
-
-#undef BOOST_UNORDERED_EMPLACE
-
 #endif

        iterator insert(const value_type& obj)
        {
-            return iterator(base.emplace(obj));
+            return iterator(base.insert(obj));
        }

        iterator insert(const_iterator hint, const value_type& obj)
        {
-            return iterator(base.emplace_hint(get(hint), obj));
+            return iterator(base.insert_hint(get(hint), obj));
        }

        template <class InputIterator>
@@ -921,7 +801,7 @@ namespace boost
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
        friend bool operator==(unordered_multimap const&, unordered_multimap const&);
        friend bool operator!=(unordered_multimap const&, unordered_multimap const&);
-#elif !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
+#else
        friend bool operator==<Key, T, Hash, Pred, Alloc>(unordered_multimap const&, unordered_multimap const&);
        friend bool operator!=<Key, T, Hash, Pred, Alloc>(unordered_multimap const&, unordered_multimap const&);
 #endif
@@ -1,5 +1,5 @@

-// Copyright (C) 2008-2009 Daniel James.
+// Copyright (C) 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)

@@ -1,6 +1,6 @@

 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
-// Copyright (C) 2005-2009 Daniel James.
+// Copyright (C) 2005-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)

@@ -21,10 +21,6 @@
 #include <boost/unordered/detail/move.hpp>
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
-
 #if defined(BOOST_MSVC)
 #pragma warning(push)
 #if BOOST_MSVC >= 1400
@@ -39,9 +35,6 @@ namespace boost
    template <class Value, class Hash, class Pred, class Alloc>
    class unordered_set
    {
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
-    public:
-#endif
        typedef boost::unordered_detail::hash_types_unique_keys<
            Value, Value, Hash, Pred, Alloc
        > implementation;
@@ -103,21 +96,11 @@ namespace boost
        template <class InputIterator>
        unordered_set(InputIterator f, InputIterator l, size_type n,
                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal())
-            : base(f, l, n, hf, eql, allocator_type())
-        {
-        }
-        
-        template <class InputIterator>
-        unordered_set(InputIterator f, InputIterator l, size_type n,
-                const hasher &hf,
-                const key_equal &eql,
-                const allocator_type &a)
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
            : base(f, l, n, hf, eql, a)
        {
        }
-        
-        ~unordered_set() {}

 #if defined(BOOST_HAS_RVALUE_REFS)
        unordered_set(unordered_set&& other)
@@ -150,7 +133,7 @@ namespace boost
 #endif
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_INITIALIZER_LISTS)
        unordered_set(std::initializer_list<value_type> list,
                size_type n = boost::unordered_detail::default_initial_bucket_count,
                const hasher &hf = hasher(),
@@ -234,75 +217,31 @@ namespace boost

        // modifiers

-#if defined(BOOST_UNORDERED_STD_FORWARD)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
        template <class... Args>
        std::pair<iterator, bool> emplace(Args&&... args)
        {
            return boost::unordered_detail::pair_cast<iterator, bool>(
-                base.emplace(std::forward<Args>(args)...));
+                base.insert(std::forward<Args>(args)...));
        }

        template <class... Args>
        iterator emplace_hint(const_iterator hint, Args&&... args)
        {
            return iterator(
-                base.emplace_hint(get(hint), std::forward<Args>(args)...));
+                base.insert_hint(get(hint), std::forward<Args>(args)...));
        }
-#else
-
-        std::pair<iterator, bool> emplace(value_type const& v = value_type())
-        {
-            return boost::unordered_detail::pair_cast<iterator, bool>(
-                base.emplace(v));
-        }
-
-        iterator emplace_hint(const_iterator hint, value_type const& v = value_type())
-        {
-            return iterator(base.emplace_hint(get(hint), v));
-        }
-
-#define BOOST_UNORDERED_EMPLACE(z, n, _)                                        \
-            template <                                                          \
-                BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                             \
-            >                                                                   \
-            std::pair<iterator, bool> emplace(                                  \
-                BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                           \
-            )                                                                   \
-            {                                                                   \
-                return boost::unordered_detail::pair_cast<iterator, bool>(      \
-                    base.emplace(                                               \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                       \
-                    ));                                                         \
-            }                                                                   \
-                                                                                \
-            template <                                                          \
-                BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                             \
-            >                                                                   \
-            iterator emplace_hint(const_iterator hint,                          \
-                BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                           \
-            )                                                                   \
-            {                                                                   \
-                return iterator(base.emplace_hint(get(hint),                    \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                       \
-                ));                                                             \
-            }
-
-        BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
-            BOOST_UNORDERED_EMPLACE, _)
-
-#undef BOOST_UNORDERED_EMPLACE
-
 #endif

        std::pair<iterator, bool> insert(const value_type& obj)
        {
            return boost::unordered_detail::pair_cast<iterator, bool>(
-                    base.emplace(obj));
+                    base.insert(obj));
        }

        iterator insert(const_iterator hint, const value_type& obj)
        {
-            return iterator(base.emplace_hint(get(hint), obj));
+            return iterator(base.insert_hint(get(hint), obj));
        }

        template <class InputIterator>
@@ -444,7 +383,7 @@ namespace boost
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
        friend bool operator==(unordered_set const&, unordered_set const&);
        friend bool operator!=(unordered_set const&, unordered_set const&);
-#elif !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
+#else
        friend bool operator==<Value, Hash, Pred, Alloc>(unordered_set const&, unordered_set const&);
        friend bool operator!=<Value, Hash, Pred, Alloc>(unordered_set const&, unordered_set const&);
 #endif
@@ -474,9 +413,6 @@ namespace boost
    template <class Value, class Hash, class Pred, class Alloc>
    class unordered_multiset
    {
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
-    public:
-#endif
        typedef boost::unordered_detail::hash_types_equivalent_keys<
            Value, Value, Hash, Pred, Alloc
        > implementation;
@@ -538,22 +474,12 @@ namespace boost
        template <class InputIterator>
        unordered_multiset(InputIterator f, InputIterator l, size_type n,
                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal())
-          : base(f, l, n, hf, eql, allocator_type())
-        {
-        }
-
-        template <class InputIterator>
-        unordered_multiset(InputIterator f, InputIterator l, size_type n,
-                const hasher &hf,
-                const key_equal &eql,
-                const allocator_type &a)
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
          : base(f, l, n, hf, eql, a)
        {
        }

-        ~unordered_multiset() {}
-
 #if defined(BOOST_HAS_RVALUE_REFS)
        unordered_multiset(unordered_multiset&& other)
            : base(other.base, boost::unordered_detail::move_tag())
@@ -585,7 +511,7 @@ namespace boost
 #endif
 #endif

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_INITIALIZER_LISTS)
        unordered_multiset(std::initializer_list<value_type> list,
                size_type n = boost::unordered_detail::default_initial_bucket_count,
                const hasher &hf = hasher(),
@@ -669,71 +595,28 @@ namespace boost

        // modifiers

-#if defined(BOOST_UNORDERED_STD_FORWARD)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
        template <class... Args>
        iterator emplace(Args&&... args)
        {
-            return iterator(base.emplace(std::forward<Args>(args)...));
+            return iterator(base.insert(std::forward<Args>(args)...));
        }

        template <class... Args>
        iterator emplace_hint(const_iterator hint, Args&&... args)
        {
-            return iterator(base.emplace_hint(get(hint), std::forward<Args>(args)...));
+            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
        }
-#else
-
-        iterator emplace(value_type const& v = value_type())
-        {
-            return iterator(base.emplace(v));
-        }
-
-        iterator emplace_hint(const_iterator hint, value_type const& v = value_type())
-        {
-            return iterator(base.emplace_hint(get(hint), v));
-        }
-
-#define BOOST_UNORDERED_EMPLACE(z, n, _)                                        \
-            template <                                                          \
-                BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                             \
-            >                                                                   \
-            iterator emplace(                                                   \
-                BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                           \
-            )                                                                   \
-            {                                                                   \
-                return iterator(                                                \
-                    base.emplace(                                               \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                       \
-                    ));                                                         \
-            }                                                                   \
-                                                                                \
-            template <                                                          \
-                BOOST_UNORDERED_TEMPLATE_ARGS(z, n)                             \
-            >                                                                   \
-            iterator emplace_hint(const_iterator hint,                          \
-                BOOST_UNORDERED_FUNCTION_PARAMS(z, n)                           \
-            )                                                                   \
-            {                                                                   \
-                return iterator(base.emplace_hint(get(hint),                    \
-                        BOOST_UNORDERED_CALL_PARAMS(z, n)                       \
-                ));                                                             \
-            }
-
-        BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
-            BOOST_UNORDERED_EMPLACE, _)
-
-#undef BOOST_UNORDERED_EMPLACE
-
 #endif

        iterator insert(const value_type& obj)
        {
-            return iterator(base.emplace(obj));
+            return iterator(base.insert(obj));
        }

        iterator insert(const_iterator hint, const value_type& obj)
        {
-            return iterator(base.emplace_hint(get(hint), obj));
+            return iterator(base.insert_hint(get(hint), obj));
        }

        template <class InputIterator>
@@ -875,7 +758,7 @@ namespace boost
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
        friend bool operator==(unordered_multiset const&, unordered_multiset const&);
        friend bool operator!=(unordered_multiset const&, unordered_multiset const&);
-#elif !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
+#else
        friend bool operator==<Value, Hash, Pred, Alloc>(unordered_multiset const&, unordered_multiset const&);
        friend bool operator!=<Value, Hash, Pred, Alloc>(unordered_multiset const&, unordered_multiset const&);
 #endif
@@ -1,5 +1,5 @@

-// Copyright (C) 2008-2009 Daniel James.
+// Copyright (C) 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)

@@ -1,9 +1,3 @@
-#
-# Copyright Troy D. Straszheim
-#
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
 boost_additional_test_dependencies(unordered BOOST_DEPENDS test)

 # GCC Compilers
@@ -18,7 +12,64 @@ ENDIF( ${CMAKE_CXX_COMPILER} MATCHES "icpc" )

 set (swap_compile_flags "${test_compile_flags} -DBOOST_UNORDERED_SWAP_METHOD=2")

+#-------------------------------------------------------------------------------
+# Unordered Tests
+set (unordered_tests
+        fwd_set_test
+        fwd_map_test
+        compile_set
+        compile_map
+        link_test_1
+         link_test_2
+        simple_tests
+        equivalent_keys_tests
+        constructor_tests
+        copy_tests
+        move_tests.cpp 
+        assign_tests
+        insert_tests
+        insert_stable_tests
+        unnecessary_copy_tests
+        erase_tests
+        erase_equiv_tests
+        find_tests
+        at_tests
+        bucket_tests
+        load_factor_tests
+        rehash_tests
+        equality_tests
+)
+#-- Create an executable test for each source
+foreach(test ${unordered_tests})
+    boost_test_run(${test} "unordered/${test}.cpp"
+                    COMPILE_FLAGS ${test_compile_flags} 
+                    DEPENDS boost_unit_test_framework) 
+endforeach(test ${unordered_tests})

+#-- run the swap test
+boost_test_run(swap_tests 
+                COMPILE_FLAGS ${swap_compile_flags} 
+                DEPENDS boost_unit_test_framework)

-add_subdirectory(exception)
-add_subdirectory(unordered)
+#-------------------------------------------------------------------------------
+# Exception Tests
+set (exception_tests
+    constructor_exception_tests
+    copy_exception_tests
+    assign_exception_tests
+    insert_exception_tests
+    erase_exception_tests
+    rehash_exception_tests
+)
+
+#-- Create an executable test for each source
+foreach(test ${exception_tests})
+    boost_test_run(${test} "exception/${test}.cpp"
+                    COMPILE_FLAGS ${test_compile_flags} 
+                    DEPENDS boost_unit_test_framework) 
+endforeach(test ${unordered_tests})
+
+#-- run the swap test
+boost_test_run(swap_swap_exception_tests 
+                COMPILE_FLAGS ${swap_compile_flags} 
+                DEPENDS boost_unit_test_framework)
@@ -1,25 +0,0 @@
-#
-# Copyright Troy D. Straszheim
-#
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
-
-foreach(test 
-    constructor_exception_tests
-    copy_exception_tests
-    assign_exception_tests
-    insert_exception_tests
-    erase_exception_tests
-    rehash_exception_tests
-    )
-    boost_test_run(${test} 
-                    COMPILE_FLAGS ${test_compile_flags} 
-                    DEPENDS boost_unit_test_framework) 
-endforeach(test ${unordered_tests})
-
-#-- run the swap test
-boost_test_run(swap_exception_tests 
-                COMPILE_FLAGS ${swap_compile_flags} 
-                DEPENDS boost_unit_test_framework)
-
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -25,7 +25,7 @@ struct erase_test_base : public test::exception_base
    void check(T const& x) const {
        std::string scope(test::scope);

-        BOOST_TEST(scope.find("hash::") != std::string::npos ||
+        BOOST_CHECK(scope.find("hash::") != std::string::npos ||
                scope.find("equal_to::") != std::string::npos ||
                scope == "operator==(object, object)");

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -128,10 +128,10 @@ struct insert_test_rehash1 : public insert_test_base<T>
        size_type bucket_count = x.bucket_count();
        size_type initial_elements = static_cast<size_type>(
            ceil(bucket_count * (double) x.max_load_factor()) - 1);
-        BOOST_TEST(initial_elements < this->values.size());
+        BOOST_REQUIRE(initial_elements < this->values.size());
        x.insert(this->values.begin(),
                boost::next(this->values.begin(), initial_elements));
-        BOOST_TEST(bucket_count == x.bucket_count());
+        BOOST_REQUIRE(bucket_count == x.bucket_count());
        return x;
    }

@@ -150,7 +150,7 @@ struct insert_test_rehash1 : public insert_test_base<T>

        // This isn't actually a failure, but it means the test isn't doing its
        // job.
-        BOOST_TEST(x.bucket_count() != bucket_count);
+        BOOST_REQUIRE(x.bucket_count() != bucket_count);
    }
 };

@@ -173,7 +173,7 @@ struct insert_test_rehash2 : public insert_test_rehash1<T>

        // This isn't actually a failure, but it means the test isn't doing its
        // job.
-        BOOST_TEST(x.bucket_count() != bucket_count);
+        BOOST_REQUIRE(x.bucket_count() != bucket_count);
    }
 };

@@ -195,12 +195,12 @@ struct insert_test_rehash3 : public insert_test_base<T>
        rehash_bucket_count = static_cast<size_type>(
            ceil(original_bucket_count * (double) x.max_load_factor())) - 1;

-        size_type initial_elements = rehash_bucket_count > 5 ? rehash_bucket_count - 5 : 1;
+        size_type initial_elements = rehash_bucket_count - 5;

-        BOOST_TEST(initial_elements < this->values.size());
+        BOOST_REQUIRE(initial_elements < this->values.size());
        x.insert(this->values.begin(),
                boost::next(this->values.begin(), initial_elements));
-        BOOST_TEST(original_bucket_count == x.bucket_count());
+        BOOST_REQUIRE(original_bucket_count == x.bucket_count());
        return x;
    }

@@ -212,12 +212,12 @@ struct insert_test_rehash3 : public insert_test_base<T>

        // This isn't actually a failure, but it means the test isn't doing its
        // job.
-        BOOST_TEST(x.bucket_count() != bucket_count);
+        BOOST_REQUIRE(x.bucket_count() != bucket_count);
    }

    void check(T const& x) const {
        if(x.size() < rehash_bucket_count) {
-            //BOOST_TEST(x.bucket_count() == original_bucket_count);
+            //BOOST_CHECK(x.bucket_count() == original_bucket_count);
        }
        test::check_equivalent_keys(x);
    }
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -22,7 +22,7 @@ struct self_swap_base : public test::exception_base
        std::string scope(test::scope);

 #if BOOST_UNORDERED_SWAP_METHOD != 2
-        BOOST_TEST(
+        BOOST_CHECK(
                scope == "hash::operator(hash)" ||
                scope == "hash::operator=(hash)" ||
                scope == "equal_to::operator(equal_to)" ||
@@ -77,7 +77,7 @@ struct swap_base : public test::exception_base
        std::string scope(test::scope);

 #if BOOST_UNORDERED_SWAP_METHOD != 2
-        BOOST_TEST(
+        BOOST_CHECK(
                scope == "hash::operator(hash)" ||
                scope == "hash::operator=(hash)" ||
                scope == "equal_to::operator(equal_to)" ||
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-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)

@@ -1,13 +1,11 @@

-// Copyright 2008-2009 Daniel James.
+// Copyright 2008 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 <iostream>
-
 namespace test {
    struct object_count {
        int instances;
@@ -38,11 +36,6 @@ namespace test {
        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;
-        }
    };

    template <class T>
@@ -1,5 +1,5 @@

-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -8,10 +8,25 @@

 #include "./test.hpp"

+#if defined(BOOST_UNORDERED_FULL_TEST)
+#   define BOOST_TEST_MAIN
+#   include <boost/test/exception_safety.hpp>
+#   include <boost/test/unit_test.hpp>
+#endif
+
 #include <boost/preprocessor/seq/for_each_product.hpp>
 #include <boost/preprocessor/seq/elem.hpp>
 #include <boost/preprocessor/cat.hpp>

+#if defined(BOOST_UNORDERED_FULL_TEST)
+#   define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \
+        UNORDERED_AUTO_TEST(name) \
+        { \
+            test_func< type > fixture; \
+            ::test::exception_safety(fixture, BOOST_STRINGIZE(test_func<type>)); \
+        }
+#    define UNORDERED_EPOINT_IMPL BOOST_ITEST_EPOINT
+#else
 #   define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \
        UNORDERED_AUTO_TEST(name) \
        { \
@@ -19,6 +34,7 @@
            ::test::lightweight::exception_safety(fixture, BOOST_STRINGIZE(test_func<type>)); \
        }
 #    define UNORDERED_EPOINT_IMPL ::test::lightweight::epoint
+#endif

 #define UNORDERED_EXCEPTION_TEST_POSTFIX RUN_TESTS()

@@ -162,7 +178,16 @@ namespace test {
            }
        }
    };
+    
+    

+#if defined(BOOST_UNORDERED_FULL_TEST)
+    template <class Test>
+    void exception_safety(Test const& f, char const* name) {
+        test_runner<Test> runner(f);
+        ::boost::itest::exception_safety(runner, name);
+    }
+#else
    // Quick exception testing based on lightweight test

    namespace lightweight {
@@ -212,6 +237,7 @@ namespace test {
            } while(!success);
        }
    }
+#endif
 }

 #endif
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,39 +1,24 @@

-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-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)

 #if !defined(BOOST_UNORDERED_TEST_HELPERS_INPUT_ITERATOR_HEADER)
 #define BOOST_UNORDERED_TEST_HELPERS_INPUT_ITERATOR_HEADER

-#include <boost/config.hpp>
 #include <boost/iterator_adaptors.hpp>

 namespace test
 {
-    template <class Iterator>
-    struct proxy
-    {
-        typedef BOOST_DEDUCED_TYPENAME Iterator::value_type value_type;
-
-        proxy(value_type const& v) : v_(v) {}
-        proxy(proxy const& x) : v_(x.v_) {}
-        operator value_type const&() const { return v_; }
-        
-        value_type v_;
-    };
-
    template <class Iterator>
    struct input_iterator_adaptor
        : boost::iterator_adaptor<
            input_iterator_adaptor<Iterator>, Iterator,
-            boost::use_default, std::input_iterator_tag,
-            proxy<Iterator> >
+            boost::use_default, std::input_iterator_tag>
    {
        typedef boost::iterator_adaptor<
            input_iterator_adaptor<Iterator>, Iterator,
-            boost::use_default, std::input_iterator_tag,
-            proxy<Iterator> > base;
+            boost::use_default, std::input_iterator_tag> base;

        explicit input_iterator_adaptor(Iterator it = Iterator())
            : base(it) {}
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2008-2009 Daniel James.
+// Copyright 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)

@@ -81,7 +81,7 @@ namespace test
            T* operator->() const { return &ptr_->value_; }
            list_iterator& operator++() {
                ptr_ = ptr_->next_; return *this; }
-            list_iterator operator++(int) {
+            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_; }
@@ -108,7 +108,7 @@ namespace test
            T const* operator->() const { return &ptr_->value_; }
            list_const_iterator& operator++() {
                ptr_ = ptr_->next_; return *this; }
-            list_const_iterator operator++(int) {
+            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_; }
@@ -144,7 +144,6 @@ namespace test
        list& operator=(list const& other) {
            clear();
            insert(other.begin(), other.end());
-            return *this;
        }

        iterator begin() { return iterator(data_.first_); }
@@ -243,28 +242,14 @@ namespace test
        node** merge_adjacent_ranges(node** first, node** second,
                node** third, Less less)
        {
-            while(true) {
-                while(true) {
-                    if(first == second) return third;
-                    if(less((*second)->value_, (*first)->value_)) break;
-                    first = &(*first)->next_;
+            while(first != second) {
+                if(less((*second)->value_, (*first)->value_)) {
+                    swap_adjacent_ranges(first, second, third);
+                    std::swap(second, third);
                }
-
-                swap_adjacent_ranges(first, second, third);
-                first = &(*first)->next_;
-                
-                // Since the two ranges we just swapped, the order is now:
-                // first...third...second
-                
-                while(true) {
-                    if(first == third) return second;
-                    if(!less((*first)->value_, (*third)->value_)) break;
-                    first = &(*first)->next_;
-                }
-
-                swap_adjacent_ranges(first, third, second);
                first = &(*first)->next_;
            }
+            return third;
        }
        
        void swap_adjacent_ranges(node** first, node** second, node** third)
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -18,6 +18,11 @@ namespace test
 {
    namespace detail
    {
+        // This annoymous namespace won't cause ODR violations as I won't
+        // be linking multiple translation units together. I'll probably
+        // move this into a cpp file before a full release, but for now it's
+        // the most convenient way.
+
        struct memory_area {
            void const* start;
            void const* end;
@@ -98,7 +103,7 @@ namespace test

            void allocator_unref()
            {
-                BOOST_TEST(count_allocators > 0);
+                BOOST_CHECK(count_allocators > 0);
                if(count_allocators > 0) {
                    --count_allocators;
                    if(count_allocators == 0) {
@@ -111,9 +116,9 @@ namespace test
                        count_constructions = 0;
                        allocated_memory.clear();

-                        BOOST_TEST(no_allocations_left);
-                        BOOST_TEST(no_constructions_left);
-                        BOOST_TEST(allocated_memory_empty);
+                        BOOST_CHECK(no_allocations_left);
+                        BOOST_CHECK(no_constructions_left);
+                        BOOST_CHECK(allocated_memory_empty);
                    }
                }
            }
@@ -139,12 +144,12 @@ namespace test
                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);
-                    BOOST_TEST(pos->second.tag_ == tag);
+                    BOOST_CHECK(pos->first.start == ptr);
+                    BOOST_CHECK(pos->first.end == (char*) ptr + n * size);
+                    BOOST_CHECK(pos->second.tag_ == tag);
                    allocated_memory.erase(pos);
                }
-                BOOST_TEST(count_allocations > 0);
+                BOOST_CHECK(count_allocations > 0);
                if(count_allocations > 0) --count_allocations;
            }

@@ -155,7 +160,7 @@ namespace test

            void track_destroy(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
            {
-                BOOST_TEST(count_constructions > 0);
+                BOOST_CHECK(count_constructions > 0);
                if(count_constructions > 0) --count_constructions;
            }
        };
@@ -1,5 +1,5 @@

-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-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)

@@ -1,5 +1,5 @@

-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-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)

@@ -1,5 +1,5 @@

-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-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)

@@ -1,12 +1,20 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

 #if !defined(BOOST_UNORDERED_TEST_TEST_HEADER)
 #define BOOST_UNORDERED_TEST_TEST_HEADER

-#include <boost/detail/lightweight_test.hpp>
+#if defined(BOOST_UNORDERED_FULL_TEST)
+
+#include <boost/test/test_tools.hpp>
+#define UNORDERED_AUTO_TEST(x) BOOST_AUTO_TEST_CASE(x)
+#define RUN_TESTS()
+
+#else
+
+#include <boost/test/minimal.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/stringize.hpp>
 #include <iostream>
@@ -22,8 +30,7 @@
    }; \
    BOOST_PP_CAT(x, _type) x; \
    void BOOST_PP_CAT(x, _type)::run()
-#define RUN_TESTS() int main(int, char**) \
-    { ::test::test_list::run_tests(); return boost::report_errors(); }
+#define RUN_TESTS() int test_main(int, char**) { ::test::test_list::run_tests(); return 0; }

 namespace test {
    struct registered_test_base {
@@ -67,6 +74,8 @@ namespace test {
    }
 }

+#endif
+
 #include <boost/preprocessor/seq/for_each_product.hpp>
 #include <boost/preprocessor/seq/fold_left.hpp>
 #include <boost/preprocessor/seq/to_tuple.hpp>
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -49,7 +49,7 @@ namespace test
        value_list values2(x2.begin(), x2.end());
        values1.sort();
        values2.sort();
-        BOOST_TEST(values1.size() == values2.size() &&
+        BOOST_CHECK(values1.size() == values2.size() &&
                std::equal(values1.begin(), values1.end(), values2.begin(),
                    test::equivalent));
    }
@@ -61,7 +61,7 @@ namespace test
        test::list<T> values2(x2.first, x2.second);
        values1.sort();
        values2.sort();
-        BOOST_TEST(values1.size() == values2.size() &&
+        BOOST_CHECK(values1.size() == values2.size() &&
                std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent));
    }

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -347,7 +347,7 @@ namespace exception
            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
        }

-#if defined(BOOST_UNORDERED_STD_FORWARD)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
        template<class... Args> void construct(pointer p, Args&&... args) {
            UNORDERED_SCOPE(allocator::construct(pointer, Args&&...)) {
                UNORDERED_EPOINT("Mock allocator construct function.");
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -229,7 +229,7 @@ namespace minimal

        void construct(pointer p, T const& t) { new((void*)p.ptr_) T(t); }

-#if defined(BOOST_UNORDERED_STD_FORWARD)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
        template<class... Args> void construct(pointer p, Args&&... args) {
            new((void*)p.ptr_) T(std::forward<Args>(args)...);
        }
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -218,7 +218,7 @@ namespace test
            new(p) T(t);
        }

-#if defined(BOOST_UNORDERED_STD_FORWARD)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
        template<class... Args> void construct(pointer p, Args&&... args) {
            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
            new(p) T(std::forward<Args>(args)...);
@@ -1,43 +0,0 @@
-#
-# Copyright Troy D. Straszheim
-#
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
-#-------------------------------------------------------------------------------
-# Unordered Tests
-foreach(test
-    fwd_set_test
-    fwd_map_test
-    compile_set
-    compile_map
-    simple_tests
-    equivalent_keys_tests
-    constructor_tests
-    copy_tests
-    move_tests
-    assign_tests
-    insert_tests
-    insert_stable_tests
-    unnecessary_copy_tests
-    erase_tests
-    erase_equiv_tests
-    find_tests
-    at_tests
-    bucket_tests
-    load_factor_tests
-    rehash_tests
-    equality_tests
-    )
-  boost_test_run(${test} 
-    COMPILE_FLAGS ${test_compile_flags} 
-    DEPENDS boost_unit_test_framework) 
-endforeach()
-
-boost_test_run(link_test link_test_1.cpp link_test_2.cpp)
-
-#-- run the swap test
-boost_test_run(swap_tests 
-                COMPILE_FLAGS ${swap_compile_flags} 
-                DEPENDS boost_unit_test_framework)
-
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -27,9 +27,9 @@ void assign_tests1(T*, test::random_generator generator = test::default_generato
    {
        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_CHECK(x.empty());
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
    }

    std::cerr<<"assign_tests1.2\n";
@@ -47,7 +47,7 @@ void assign_tests1(T*, test::random_generator generator = test::default_generato
        y.max_load_factor(x.max_load_factor() / 20);
        y = x;
        tracker.compare(y);
-        BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+        BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
    }
 }

@@ -67,8 +67,8 @@ void assign_tests2(T*, test::random_generator generator = test::default_generato
        T x1(v.begin(), v.end(), 0, hf1, eq1);
        T x2(0, hf2, eq2);
        x2 = x1;
-        BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+        BOOST_CHECK(test::equivalent(x2.hash_function(), hf1));
+        BOOST_CHECK(test::equivalent(x2.key_eq(), eq1));
        test::check_container(x2, v);
    }

@@ -78,9 +78,9 @@ void assign_tests2(T*, test::random_generator generator = test::default_generato
        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));
-        BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
+        BOOST_CHECK(test::equivalent(x2.hash_function(), hf1));
+        BOOST_CHECK(test::equivalent(x2.key_eq(), eq1));
+        BOOST_CHECK(test::equivalent(x2.get_allocator(), al2));
        test::check_container(x2, v1);
    }
 }
@@ -103,21 +103,6 @@ UNORDERED_TEST(assign_tests2,
    ((default_generator)(generate_collisions))
 )

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
-
-UNORDERED_AUTO_TEST(assign_default_initializer_list) {
-    std::cerr<<"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_INITIALIZER_LISTS)

 UNORDERED_AUTO_TEST(assign_initializer_list)
@@ -128,8 +113,8 @@ UNORDERED_AUTO_TEST(assign_initializer_list)
    x.insert(10);
    x.insert(20);
    x = { 1, 2, -10 };
-    BOOST_TEST(x.find(10) == x.end());
-    BOOST_TEST(x.find(-10) != x.end());
+    BOOST_CHECK(x.find(10) == x.end());
+    BOOST_CHECK(x.find(-10) != x.end());
 }

 #endif
@@ -1,5 +1,5 @@

-// Copyright 2007-2009 Daniel James.
+// Copyright 2007-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)

@@ -16,8 +16,8 @@ UNORDERED_AUTO_TEST(at_tests) {
    x["one"] = 1;
    x["two"] = 2;

-    BOOST_TEST(x.at("one") == 1);
-    BOOST_TEST(x.at("two") == 2);
+    BOOST_CHECK(x.at("one") == 1);
+    BOOST_CHECK(x.at("two") == 2);

    try {
        x.at("three");
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -24,7 +24,7 @@ void tests(X* = 0, test::random_generator generator = test::default_generator)

    X x(v.begin(), v.end());

-    BOOST_TEST(x.bucket_count() < x.max_bucket_count());
+    BOOST_CHECK(x.bucket_count() < x.max_bucket_count());
    std::cerr<<x.bucket_count()<<"<"<<x.max_bucket_count()<<"\n";

    for(BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
@@ -32,21 +32,21 @@ void tests(X* = 0, test::random_generator generator = test::default_generator)
    {
        size_type bucket = x.bucket(test::get_key<X>(*it));

-        BOOST_TEST(bucket < x.bucket_count());
+        BOOST_CHECK(bucket < x.bucket_count());
        if(bucket < x.max_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);
+            BOOST_CHECK(lit != lend);
        }
    }

    for(size_type i = 0; i < x.bucket_count(); ++i) {
-        BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x.begin(i), x.end(i)));
-        BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x.cbegin(i), x.cend(i)));
+        BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x.begin(i), x.end(i)));
+        BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x.cbegin(i), x.cend(i)));
        X const& x_ref = x;
-        BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x_ref.begin(i), x_ref.end(i)));
-        BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x_ref.cbegin(i), x_ref.cend(i)));
+        BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x_ref.begin(i), x_ref.end(i)));
+        BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x_ref.cbegin(i), x_ref.cend(i)));
    }
 }

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-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)

@@ -87,10 +87,10 @@ void container_test(X& r, T const&)
    // I'm not sure about either of these tests...
    size_type max_diff((std::numeric_limits<difference_type>::max)());
    difference_type converted_diff(max_diff);
-    BOOST_TEST((std::numeric_limits<difference_type>::max)()
+    BOOST_CHECK((std::numeric_limits<difference_type>::max)()
            == converted_diff);

-    BOOST_TEST(
+    BOOST_CHECK(
        static_cast<comparison_type>(
            (std::numeric_limits<size_type>::max)()) >
        static_cast<comparison_type>(
@@ -98,8 +98,8 @@ void container_test(X& r, T const&)

    // I don't test the runtime post-conditions here.
    X u;
-    BOOST_TEST(u.size() == 0);
-    BOOST_TEST(X().size() == 0);
+    BOOST_CHECK(u.size() == 0);
+    BOOST_CHECK(X().size() == 0);

    X a,b;

@@ -151,12 +151,14 @@ void unordered_map_test(X& r, Key const& k, T const& v)

    r.insert(std::pair<Key const, T>(k, v));

+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
    Key k_lvalue(k);
    T v_lvalue(v);

    r.emplace(k, v);
    r.emplace(k_lvalue, v_lvalue);
    r.emplace(rvalue(k), rvalue(v));
+#endif
 }

 template <class X>
@@ -173,7 +175,9 @@ void unordered_unique_test(X& r, T const& t)
 {
    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
    test::check_return_type<std::pair<iterator, bool> >::equals(r.insert(t));
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
    test::check_return_type<std::pair<iterator, bool> >::equals(r.emplace(t));
+#endif
 }

 template <class X, class T>
@@ -181,7 +185,9 @@ void unordered_equivalent_test(X& r, T const& t)
 {
    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
    test::check_return_type<iterator>::equals(r.insert(t));
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
    test::check_return_type<iterator>::equals(r.emplace(t));
+#endif
 }

 template <class X, class Key, class T>
@@ -283,12 +289,14 @@ void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)

    const_iterator q = a.cbegin();
    test::check_return_type<iterator>::equals(a.insert(q, t));
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
    test::check_return_type<iterator>::equals(a.emplace_hint(q, t));
+#endif

    a.insert(i, j);
    test::check_return_type<size_type>::equals(a.erase(k));

-    BOOST_TEST(a.empty());
+    BOOST_CHECK(a.empty());
    if(a.empty()) {
        a.insert(t);
        q = a.cbegin();
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -29,42 +29,42 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
    std::cerr<<"Construct 1\n";
    {
        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));
+        BOOST_CHECK(x.empty());
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_equivalent_keys(x);
    }

    std::cerr<<"Construct 2\n";
    {
        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));
+        BOOST_CHECK(x.empty());
+        BOOST_CHECK(x.bucket_count() >= 100);
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_equivalent_keys(x);
    }

    std::cerr<<"Construct 3\n";
    {
        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));
+        BOOST_CHECK(x.empty());
+        BOOST_CHECK(x.bucket_count() >= 2000);
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_equivalent_keys(x);
    }

    std::cerr<<"Construct 4\n";
    {
        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));
+        BOOST_CHECK(x.empty());
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_equivalent_keys(x);
    }

@@ -72,10 +72,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
    {
        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));
+        BOOST_CHECK(x.bucket_count() >= 10000);
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_container(x, v);
        test::check_equivalent_keys(x);
    }
@@ -84,10 +84,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
    {
        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));
+        BOOST_CHECK(x.bucket_count() >= 10000);
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_container(x, v);
        test::check_equivalent_keys(x);
    }
@@ -96,10 +96,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
    {
        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));
+        BOOST_CHECK(x.bucket_count() >= 100);
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_container(x, v);
        test::check_equivalent_keys(x);
    }
@@ -108,9 +108,9 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
    {
        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));
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_container(x, v);
        test::check_equivalent_keys(x);
    }
@@ -118,10 +118,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
    std::cerr<<"Construct 9\n";
    {
        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));
+        BOOST_CHECK(x.empty());
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_equivalent_keys(x);
    }

@@ -129,10 +129,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
    {
        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));
+        BOOST_CHECK(x.bucket_count() >= 10000);
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_container(x, v);
        test::check_equivalent_keys(x);
    }
@@ -141,10 +141,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
    {
        test::random_values<T> v(1000, generator);
        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));
+        BOOST_CHECK(x.empty());
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_equivalent_keys(x);
    }
 }
@@ -165,21 +165,21 @@ void constructor_tests2(T*, test::random_generator const& generator = test::defa
    std::cerr<<"Construct 1\n";
    {
        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));
+        BOOST_CHECK(x.bucket_count() >= 10000);
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq1));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_equivalent_keys(x);
    }

    std::cerr<<"Construct 2\n";
    {
        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));
+        BOOST_CHECK(x.empty());
+        BOOST_CHECK(x.bucket_count() >= 100);
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_equivalent_keys(x);
    }

@@ -187,9 +187,9 @@ void constructor_tests2(T*, test::random_generator const& generator = test::defa
    {
        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));
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq1));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_container(x, v);
        test::check_equivalent_keys(x);
    }
@@ -198,10 +198,10 @@ void constructor_tests2(T*, test::random_generator const& generator = test::defa
    {
        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));
+        BOOST_CHECK(x.bucket_count() >= 1000);
+        BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
+        BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(x.get_allocator(), al));
        test::check_container(x, v);
        test::check_equivalent_keys(x);
    }
@@ -288,24 +288,13 @@ UNORDERED_TEST(map_constructor_test,
    ((test_map)(test_multimap))
 )

-#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
-
-UNORDERED_AUTO_TEST(test_default_initializer_list) {
-    std::cerr<<"Initializer List Tests\n";
-    std::initializer_list<int> init;
-    boost::unordered_set<int> x1 = init;
-    BOOST_TEST(x1.empty());
-}
-
-#endif
-
 #if !defined(BOOST_NO_INITIALIZER_LISTS)

 UNORDERED_AUTO_TEST(test_initializer_list) {
    std::cerr<<"Initializer List Tests\n";
    boost::unordered_set<int> x1 = { 2, 10, 45, -5 };
-    BOOST_TEST(x1.find(10) != x1.end());
-    BOOST_TEST(x1.find(46) == x1.end());
+    BOOST_CHECK(x1.find(10) != x1.end());
+    BOOST_CHECK(x1.find(46) == x1.end());
 }

 #endif
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -27,11 +27,11 @@ void copy_construct_tests1(T*, test::random_generator const& generator = test::d
    {
        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_CHECK(y.empty());
+        BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(y.get_allocator(), al));
+        BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
        test::check_equivalent_keys(y);
    }

@@ -57,7 +57,7 @@ void copy_construct_tests1(T*, test::random_generator const& generator = test::d
        test::unordered_equivalence_tester<T> equivalent(x);
        equivalent(y);
        // This isn't guaranteed:
-        BOOST_TEST(y.load_factor() < y.max_load_factor());
+        BOOST_CHECK(y.load_factor() < y.max_load_factor());
        test::check_equivalent_keys(y);
    }
 }
@@ -75,22 +75,22 @@ void copy_construct_tests2(T* ptr, test::random_generator const& generator = tes
    {
        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_CHECK(y.empty());
+        BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(y.get_allocator(), al));
+        BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
        test::check_equivalent_keys(y);
    }

    {
        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_CHECK(y.empty());
+        BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+        BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+        BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
+        BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
        test::check_equivalent_keys(y);
    }

@@ -102,7 +102,7 @@ void copy_construct_tests2(T* ptr, test::random_generator const& generator = tes
        test::unordered_equivalence_tester<T> equivalent(x);
        equivalent(y);
        test::check_equivalent_keys(y);
-        BOOST_TEST(test::equivalent(y.get_allocator(), al));
+        BOOST_CHECK(test::equivalent(y.get_allocator(), al));
    }

    {
@@ -113,7 +113,7 @@ void copy_construct_tests2(T* ptr, test::random_generator const& generator = tes
        test::unordered_equivalence_tester<T> equivalent(x);
        equivalent(y);
        test::check_equivalent_keys(y);
-        BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+        BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
    }
 }

@@ -1,5 +1,5 @@

-// Copyright 2008-2009 Daniel James.
+// Copyright 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)

@@ -33,7 +33,7 @@ namespace equality_tests
        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); \
+        BOOST_CHECK(set1 op set2); \
    } while(false)

 #define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2) \
@@ -41,7 +41,7 @@ namespace equality_tests
        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); \
+        BOOST_CHECK(set1 op set2); \
    } while(false)

 #define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2) \
@@ -49,7 +49,7 @@ namespace equality_tests
        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); \
+        BOOST_CHECK(map1 op map2); \
    } while(false)

 #define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2) \
@@ -57,7 +57,7 @@ namespace equality_tests
        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); \
+        BOOST_CHECK(map1 op map2); \
    } while(false)

 #define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
@@ -67,24 +67,24 @@ namespace equality_tests
    UNORDERED_AUTO_TEST(equality_size_tests)
    {
        boost::unordered_set<int> x1, x2;
-        BOOST_TEST(x1 == x2);
-        BOOST_TEST(!(x1 != x2));
+        BOOST_CHECK(x1 == x2);
+        BOOST_CHECK(!(x1 != x2));

        x1.insert(1);
-        BOOST_TEST(x1 != x2);
-        BOOST_TEST(!(x1 == x2));
-        BOOST_TEST(x2 != x1);
-        BOOST_TEST(!(x2 == x1));
+        BOOST_CHECK(x1 != x2);
+        BOOST_CHECK(!(x1 == x2));
+        BOOST_CHECK(x2 != x1);
+        BOOST_CHECK(!(x2 == x1));
        
        x2.insert(1);
-        BOOST_TEST(x1 == x2);
-        BOOST_TEST(!(x1 != x2));
+        BOOST_CHECK(x1 == x2);
+        BOOST_CHECK(!(x1 != x2));
        
        x2.insert(2);
-        BOOST_TEST(x1 != x2);
-        BOOST_TEST(!(x1 == x2));
-        BOOST_TEST(x2 != x1);
-        BOOST_TEST(!(x2 == x1));
+        BOOST_CHECK(x1 != x2);
+        BOOST_CHECK(!(x1 == x2));
+        BOOST_CHECK(x2 != x1);
+        BOOST_CHECK(!(x2 == x1));
    }
    
    UNORDERED_AUTO_TEST(equality_key_value_tests)
@@ -150,15 +150,15 @@ namespace equality_tests
        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);
+        BOOST_CHECK(set1 == set2);
        set1.insert(1); set2.insert(2);
-        BOOST_TEST(set1 != set2);
+        BOOST_CHECK(set1 != set2);
        set1.insert(2); set2.insert(1);
-        BOOST_TEST(set1 == set2);
+        BOOST_CHECK(set1 == set2);
        set1.insert(10); set2.insert(20);
-        BOOST_TEST(set1 != set2);
+        BOOST_CHECK(set1 != set2);
        set1.insert(20); set2.insert(10);
-        BOOST_TEST(set1 == set2);
+        BOOST_CHECK(set1 == set2);
    }

 }
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -67,11 +67,11 @@ UNORDERED_AUTO_TEST(single_item_tests)

    collide_map x(init.begin(), init.end());
    x.erase(x.begin(), x.begin());
-    BOOST_TEST(x.count(1) == 1 && x.size() == 1);
+    BOOST_CHECK(x.count(1) == 1 && x.size() == 1);
    x.erase(x.end(), x.end());
-    BOOST_TEST(x.count(1) == 1 && x.size() == 1);
+    BOOST_CHECK(x.count(1) == 1 && x.size() == 1);
    x.erase(x.begin(), x.end());
-    BOOST_TEST(x.count(1) == 0 && x.size() == 0);
+    BOOST_CHECK(x.count(1) == 0 && x.size() == 0);
 }

 UNORDERED_AUTO_TEST(two_equivalent_item_tests)
@@ -83,14 +83,14 @@ UNORDERED_AUTO_TEST(two_equivalent_item_tests)
    {
        collide_map x(init.begin(), init.end());
        x.erase(x.begin(), x.end());
-        BOOST_TEST(x.count(1) == 0 && x.size() == 0);
+        BOOST_CHECK(x.count(1) == 0 && x.size() == 0);
    }

    {
        collide_map x(init.begin(), init.end());
        int value = boost::next(x.begin())->second;
        x.erase(x.begin(), boost::next(x.begin()));
-        BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
+        BOOST_CHECK(x.count(1) == 1 && x.size() == 1 &&
            x.begin()->first == 1 && x.begin()->second == value);
    }

@@ -98,7 +98,7 @@ UNORDERED_AUTO_TEST(two_equivalent_item_tests)
        collide_map x(init.begin(), init.end());
        int value = x.begin()->second;
        x.erase(boost::next(x.begin()), x.end());
-        BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
+        BOOST_CHECK(x.count(1) == 1 && x.size() == 1 &&
                x.begin()->first == 1 && x.begin()->second == value);
    }
 }
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -32,10 +32,10 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
        {
            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());
+            BOOST_CHECK(count == x.erase(test::get_key<Container>(*it)));
+            BOOST_CHECK(x.size() == old_size - count);
+            BOOST_CHECK(x.count(test::get_key<Container>(*it)) == 0);
+            BOOST_CHECK(x.find(test::get_key<Container>(*it)) == x.end());
        }
    }

@@ -50,11 +50,11 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
            std::size_t count = x.count(key);
            BOOST_DEDUCED_TYPENAME Container::iterator pos = x.erase(x.begin());
            --size;
-            BOOST_TEST(pos == x.begin());
-            BOOST_TEST(x.count(key) == count - 1);
-            BOOST_TEST(x.size() == size);
+            BOOST_CHECK(pos == x.begin());
+            BOOST_CHECK(x.count(key) == count - 1);
+            BOOST_CHECK(x.size() == size);
        }
-        BOOST_TEST(x.empty());
+        BOOST_CHECK(x.empty());
    }

    std::cerr<<"erase(random position).\n";
@@ -77,15 +77,15 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
            next = boost::next(pos);
            BOOST_DEDUCED_TYPENAME Container::key_type key = test::get_key<Container>(*pos);
            std::size_t count = x.count(key);
-            BOOST_TEST(next == x.erase(pos));
+            BOOST_CHECK(next == x.erase(pos));
            --size;
            if(size > 0)
-                BOOST_TEST(index == 0 ? next == x.begin() :
+                BOOST_CHECK(index == 0 ? next == x.begin() :
                        next == boost::next(prev));
-            BOOST_TEST(x.count(key) == count - 1);
-            BOOST_TEST(x.size() == size);
+            BOOST_CHECK(x.count(key) == count - 1);
+            BOOST_CHECK(x.size() == size);
        }
-        BOOST_TEST(x.empty());
+        BOOST_CHECK(x.empty());
    }

    std::cerr<<"erase(ranges).\n";
@@ -99,15 +99,15 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
        // 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);
+        BOOST_CHECK(x.erase(x.end(), x.end()) == x.end());
+        BOOST_CHECK(x.erase(x.begin(), x.begin()) == x.begin());
+        BOOST_CHECK(x.size() == size);

-        BOOST_TEST(x.erase(x.begin(), x.end()) == x.end());
-        BOOST_TEST(x.empty());
-        BOOST_TEST(x.begin() == x.end());
+        BOOST_CHECK(x.erase(x.begin(), x.end()) == x.end());
+        BOOST_CHECK(x.empty());
+        BOOST_CHECK(x.begin() == x.end());

-        BOOST_TEST(x.erase(x.begin(), x.end()) == x.begin());
+        BOOST_CHECK(x.erase(x.begin(), x.end()) == x.begin());
    }

    std::cerr<<"clear().\n";
@@ -115,8 +115,8 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
        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_CHECK(x.empty());
+        BOOST_CHECK(x.begin() == x.end());
    }

    std::cerr<<"\n";
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -34,12 +34,12 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
            BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it1);
            iterator pos = x.find(key);
            BOOST_DEDUCED_TYPENAME X::const_iterator const_pos = x_const.find(key);
-            BOOST_TEST(pos != x.end() &&
+            BOOST_CHECK(pos != x.end() &&
                    x.key_eq()(key, test::get_key<X>(*pos)));
-            BOOST_TEST(const_pos != x_const.end() &&
+            BOOST_CHECK(const_pos != x_const.end() &&
                    x_const.key_eq()(key, test::get_key<X>(*const_pos)));

-            BOOST_TEST(x.count(key) == tracker.count(key));
+            BOOST_CHECK(x.count(key) == tracker.count(key));

            test::compare_pairs(x.equal_range(key),
                    tracker.equal_range(key),
@@ -56,11 +56,11 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
            BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it2);
            if(tracker.find(test::get_key<X>(key)) == tracker.end())
            {
-                BOOST_TEST(x.find(key) == x.end());
-                BOOST_TEST(x_const.find(key) == x_const.end());
-                BOOST_TEST(x.count(key) == 0);
+                BOOST_CHECK(x.find(key) == x.end());
+                BOOST_CHECK(x_const.find(key) == x_const.end());
+                BOOST_CHECK(x.count(key) == 0);
                std::pair<iterator, iterator> range = x.equal_range(key);
-                BOOST_TEST(range.first == range.second);
+                BOOST_CHECK(range.first == range.second);
            }
        }
    }
@@ -73,10 +73,10 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
                v2.begin(); it3 != v2.end(); ++it3)
        {
            BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it3);
-            BOOST_TEST(x.find(key) == x.end());
-            BOOST_TEST(x.count(key) == 0);
+            BOOST_CHECK(x.find(key) == x.end());
+            BOOST_CHECK(x.count(key) == 0);
            std::pair<iterator, iterator> range = x.equal_range(key);
-            BOOST_TEST(range.first == range.second);
+            BOOST_CHECK(range.first == range.second);
        }
    }
 }
@@ -1,5 +1,5 @@

-// Copyright 2008-2009 Daniel James.
+// Copyright 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)

@@ -42,21 +42,21 @@ UNORDERED_AUTO_TEST(use_map_fwd_declared_function) {
    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_CHECK(y.find(1) != y.end() && y.find(1)->second == 2);
+    BOOST_CHECK(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_CHECK(x.find(1) == x.end());
+    BOOST_CHECK(x.find(2) != x.end() && x.find(2)->second == 1);

-    BOOST_TEST(!call_equals(x, y));
-    BOOST_TEST(call_not_equals(x, y));
+    BOOST_CHECK(!call_equals(x, y));
+    BOOST_CHECK(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));
+    BOOST_CHECK(call_equals(x, y));
+    BOOST_CHECK(!call_not_equals(x, y));
 }

 RUN_TESTS()
@@ -1,5 +1,5 @@

-// Copyright 2008-2009 Daniel James.
+// Copyright 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)

@@ -45,17 +45,17 @@ bool call_not_equals(int_multiset& x, int_multiset& y) {
 #include "../helpers/test.hpp"

 UNORDERED_AUTO_TEST(use_fwd_declared_trait_without_definition) {
-    BOOST_TEST(sizeof(is_unordered_set_impl((int_set*) 0)) == sizeof(true_type));
+    BOOST_CHECK(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_CHECK(sizeof(is_unordered_set_impl(&x)) == sizeof(true_type));

    int dummy;
-    BOOST_TEST(sizeof(is_unordered_set_impl(&dummy)) == sizeof(false_type));
+    BOOST_CHECK(sizeof(is_unordered_set_impl(&dummy)) == sizeof(false_type));
 }

 UNORDERED_AUTO_TEST(use_set_fwd_declared_function) {
@@ -64,21 +64,21 @@ UNORDERED_AUTO_TEST(use_set_fwd_declared_function) {
    y.insert(2);
    call_swap(x, y);

-    BOOST_TEST(y.find(1) != y.end());
-    BOOST_TEST(y.find(2) == y.end());
+    BOOST_CHECK(y.find(1) != y.end());
+    BOOST_CHECK(y.find(2) == y.end());

-    BOOST_TEST(x.find(1) == x.end());
-    BOOST_TEST(x.find(2) != x.end());
+    BOOST_CHECK(x.find(1) == x.end());
+    BOOST_CHECK(x.find(2) != x.end());

-    BOOST_TEST(!call_equals(x, y));
-    BOOST_TEST(call_not_equals(x, y));
+    BOOST_CHECK(!call_equals(x, y));
+    BOOST_CHECK(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));
+    BOOST_CHECK(call_equals(x, y));
+    BOOST_CHECK(!call_not_equals(x, y));
 }

 RUN_TESTS()
@@ -1,5 +1,5 @@

-// Copyright 2007-2009 Daniel James.
+// Copyright 2007-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)

@@ -47,13 +47,13 @@ UNORDERED_AUTO_TEST(stable_insert_test1) {
    x.insert(insert_stable::member(1,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);
+    BOOST_CHECK(it != end);
+    if(it != end) { BOOST_CHECK(it->tag2_ == 1); ++it; }
+    BOOST_CHECK(it != end);
+    if(it != end) { BOOST_CHECK(it->tag2_ == 2); ++it; }
+    BOOST_CHECK(it != end);
+    if(it != end) { BOOST_CHECK(it->tag2_ == 3); ++it; }
+    BOOST_CHECK(it == end);
 }

 UNORDERED_AUTO_TEST(stable_insert_test2) {
@@ -66,13 +66,13 @@ UNORDERED_AUTO_TEST(stable_insert_test2) {

    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);
+    BOOST_CHECK(it != end);
+    if(it != end) { BOOST_CHECK(it->first.tag2_ == 1 && it->second == 1); ++it; }
+    BOOST_CHECK(it != end);
+    if(it != end) { BOOST_CHECK(it->first.tag2_ == 2 && it->second == 2); ++it; }
+    BOOST_CHECK(it != end);
+    if(it != end) { BOOST_CHECK(it->first.tag2_ == 3 && it->second == 3); ++it; }
+    BOOST_CHECK(it == end);
 }

 RUN_TESTS()
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -43,13 +43,13 @@ void unique_insert_tests1(X*, test::random_generator generator = test::default_g
        std::pair<iterator, bool> r1 = x.insert(*it);
        std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool> r2 = tracker.insert(*it);

-        BOOST_TEST(r1.second == r2.second);
-        BOOST_TEST(*r1.first == *r2.first);
+        BOOST_CHECK(r1.second == r2.second);
+        BOOST_CHECK(*r1.first == *r2.first);

        tracker.compare_key(x, *it);

        if(x.size() < b * old_bucket_count)
-            BOOST_TEST(x.bucket_count() == old_bucket_count);
+            BOOST_CHECK(x.bucket_count() == old_bucket_count);
    }

    test::check_equivalent_keys(x);
@@ -73,12 +73,12 @@ void equivalent_insert_tests1(X*, test::random_generator generator = test::defau
        BOOST_DEDUCED_TYPENAME X::iterator r1 = x.insert(*it);
        BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2 = tracker.insert(*it);

-        BOOST_TEST(*r1 == *r2);
+        BOOST_CHECK(*r1 == *r2);

        tracker.compare_key(x, *it);

        if(x.size() < b * old_bucket_count)
-            BOOST_TEST(x.bucket_count() == old_bucket_count);
+            BOOST_CHECK(x.bucket_count() == old_bucket_count);
    }

    test::check_equivalent_keys(x);
@@ -107,11 +107,11 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato

            iterator r1 = x.insert(x.begin(), *it);
            tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
-            BOOST_TEST(*r1 == *r2);
+            BOOST_CHECK(*r1 == *r2);
            tracker.compare_key(x, *it);

            if(x.size() < b * old_bucket_count)
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
+                BOOST_CHECK(x.bucket_count() == old_bucket_count);
        }

        test::check_equivalent_keys(x);
@@ -133,11 +133,11 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato

            const_iterator r1 = x.insert(x_const.end(), *it);
            tracker_iterator r2 = tracker.insert(tracker.end(), *it);
-            BOOST_TEST(*r1 == *r2);
+            BOOST_CHECK(*r1 == *r2);
            tracker.compare_key(x, *it);

            if(x.size() < b * old_bucket_count)
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
+                BOOST_CHECK(x.bucket_count() == old_bucket_count);
        }

        test::check_equivalent_keys(x);
@@ -159,11 +159,11 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato

            pos = x.insert(pos, *it);
            tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
-            BOOST_TEST(*pos == *r2);
+            BOOST_CHECK(*pos == *r2);
            tracker.compare_key(x, *it);

            if(x.size() < b * old_bucket_count)
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
+                BOOST_CHECK(x.bucket_count() == old_bucket_count);
        }

        test::check_equivalent_keys(x);
@@ -187,7 +187,7 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato
            tracker.compare_key(x, *it);

            if(x.size() < b * old_bucket_count)
-                BOOST_TEST(x.bucket_count() == old_bucket_count);
+                BOOST_CHECK(x.bucket_count() == old_bucket_count);
        }

        test::check_equivalent_keys(x);
@@ -243,13 +243,13 @@ void unique_emplace_tests1(X*, test::random_generator generator = test::default_
        std::pair<iterator, bool> r1 = x.emplace(*it);
        std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool> r2 = tracker.insert(*it);

-        BOOST_TEST(r1.second == r2.second);
-        BOOST_TEST(*r1.first == *r2.first);
+        BOOST_CHECK(r1.second == r2.second);
+        BOOST_CHECK(*r1.first == *r2.first);

        tracker.compare_key(x, *it);

        if(x.size() < b * old_bucket_count)
-            BOOST_TEST(x.bucket_count() == old_bucket_count);
+            BOOST_CHECK(x.bucket_count() == old_bucket_count);
    }

    test::check_equivalent_keys(x);
@@ -273,12 +273,12 @@ void equivalent_emplace_tests1(X*, test::random_generator generator = test::defa
        BOOST_DEDUCED_TYPENAME X::iterator r1 = x.emplace(*it);
        BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2 = tracker.insert(*it);

-        BOOST_TEST(*r1 == *r2);
+        BOOST_CHECK(*r1 == *r2);

        tracker.compare_key(x, *it);

        if(x.size() < b * old_bucket_count)
-            BOOST_TEST(x.bucket_count() == old_bucket_count);
+            BOOST_CHECK(x.bucket_count() == old_bucket_count);
    }

    test::check_equivalent_keys(x);
@@ -307,7 +307,7 @@ void map_tests(X*, test::random_generator generator = test::default_generator)
        tracker.compare_key(x, *it);

        if(x.size() < b * old_bucket_count)
-            BOOST_TEST(x.bucket_count() == old_bucket_count);
+            BOOST_CHECK(x.bucket_count() == old_bucket_count);
    }

    test::check_equivalent_keys(x);   
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -24,13 +24,13 @@ void set_load_factor_tests(X* = 0)
 {
    X x;

-    BOOST_TEST(x.max_load_factor() == 1.0);
-    BOOST_TEST(x.load_factor() == 0);
+    BOOST_CHECK(x.max_load_factor() == 1.0);
+    BOOST_CHECK(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);
+    x.max_load_factor(2.0); BOOST_CHECK(x.max_load_factor() == 2.0);
+    x.max_load_factor(0.5); BOOST_CHECK(x.max_load_factor() == 0.5);
 }

 template <class X>
@@ -49,7 +49,7 @@ void insert_test(X*, float mlf, test::random_generator generator = test::default
                 old_bucket_count = x.bucket_count();
        x.insert(*it);
        if(old_size + 1 < b * old_bucket_count)
-            BOOST_TEST(x.bucket_count() == old_bucket_count);
+            BOOST_CHECK(x.bucket_count() == old_bucket_count);
    }
 }

@@ -1,5 +1,5 @@

-// Copyright 2008-2009 Daniel James.
+// Copyright 2008 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)

@@ -52,11 +52,11 @@ namespace move_tests

        {
            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);
+            BOOST_CHECK(y.empty());
+            BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+            BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+            BOOST_CHECK(test::equivalent(y.get_allocator(), al));
+            BOOST_CHECK(y.max_load_factor() == 1.0);
            test::check_equivalent_keys(y);
        }

@@ -64,7 +64,7 @@ namespace move_tests
            test::random_values<T> v(1000, generator);
            test::object_count count;
            T y(create(v, count));
-            BOOST_TEST(count == test::global_object_count);
+            BOOST_CHECK(count == test::global_object_count);
            test::check_container(y, v);
            test::check_equivalent_keys(y);
        }
@@ -78,7 +78,7 @@ namespace move_tests
            test::object_count count;
            T y;
            y = create(v, count);
-            BOOST_TEST(count == test::global_object_count);
+            BOOST_CHECK(count == test::global_object_count);
            test::check_container(y, v);
            test::check_equivalent_keys(y);
        }
@@ -98,12 +98,12 @@ namespace move_tests
        {
            test::random_values<T> v(500, generator);
            T y(create(v, count, hf, eq, al, 0.5));
-            BOOST_TEST(count == test::global_object_count);
+            BOOST_CHECK(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(), al));
-            BOOST_TEST(y.max_load_factor() == 0.5); // Not necessarily required.
+            BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+            BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+            BOOST_CHECK(test::equivalent(y.get_allocator(), al));
+            BOOST_CHECK(y.max_load_factor() == 0.5); // Not necessarily required.
            test::check_equivalent_keys(y);
        }

@@ -111,12 +111,12 @@ namespace move_tests
            // 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);
+            BOOST_CHECK(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.
+            BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+            BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+            BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
+            BOOST_CHECK(y.max_load_factor() == 2.0); // Not necessarily required.
            test::check_equivalent_keys(y);
        }

@@ -124,17 +124,17 @@ namespace move_tests
            test::random_values<T> v(25, generator);
            T y(create(v, count, hf, eq, al, 1.0), al);
 #if defined(BOOST_HAS_RVALUE_REFS)
-            BOOST_TEST(count == test::global_object_count);
+            BOOST_CHECK(count == test::global_object_count);
 #else
-            BOOST_TEST(test::global_object_count.constructions - count.constructions <=
+            BOOST_CHECK(test::global_object_count.constructions - count.constructions <=
                (test::is_map<T>::value ? 50 : 25));
-            BOOST_TEST(count.instances == test::global_object_count.instances);
+            BOOST_CHECK(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.
+            BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+            BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+            BOOST_CHECK(test::equivalent(y.get_allocator(), al));
+            BOOST_CHECK(y.max_load_factor() == 1.0); // Not necessarily required.
            test::check_equivalent_keys(y);
        }
    }
@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -26,10 +26,10 @@ void rehash_empty_test1(X* = 0)
    X x;

    x.rehash(10000);
-    BOOST_TEST(postcondition(x, 10000));
+    BOOST_CHECK(postcondition(x, 10000));

    x.rehash(0);
-    BOOST_TEST(postcondition(x, 0));
+    BOOST_CHECK(postcondition(x, 0));
 }

 template <class X>
@@ -40,18 +40,18 @@ void rehash_test1(X* = 0, test::random_generator generator = test::default_gener
    tracker.insert_range(v.begin(), v.end());
    X x(v.begin(), v.end());

-    x.rehash(0); BOOST_TEST(postcondition(x, 0));
+    x.rehash(0); BOOST_CHECK(postcondition(x, 0));
    tracker.compare(x);

    x.max_load_factor(0.25);
-    x.rehash(0); BOOST_TEST(postcondition(x, 0));
+    x.rehash(0); BOOST_CHECK(postcondition(x, 0));
    tracker.compare(x);

    x.max_load_factor(50.0);
-    x.rehash(0); BOOST_TEST(postcondition(x, 0));
+    x.rehash(0); BOOST_CHECK(postcondition(x, 0));
    tracker.compare(x);

-    x.rehash(1000); BOOST_TEST(postcondition(x, 1000));
+    x.rehash(1000); BOOST_CHECK(postcondition(x, 1000));
    tracker.compare(x);
 }

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -19,67 +19,67 @@ void simple_test(X const& a)

    {
        X u;
-        BOOST_TEST(u.size() == 0);
-        BOOST_TEST(X().size() == 0);
+        BOOST_CHECK(u.size() == 0);
+        BOOST_CHECK(X().size() == 0);
    }

    {
-        BOOST_TEST(equivalent(X(a)));
+        BOOST_CHECK(equivalent(X(a)));
    }

    {
        X u(a);
-        BOOST_TEST(equivalent(u));
+        BOOST_CHECK(equivalent(u));
    }

    {
        X u = a;
-        BOOST_TEST(equivalent(u));
+        BOOST_CHECK(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());
+        BOOST_CHECK(b.begin() == const_cast<X const&>(b).cbegin());
+        BOOST_CHECK(b.end() == const_cast<X const&>(b).cend());
    }

    {
        X b(a);
        X c;
-        BOOST_TEST(equivalent(b));
-        BOOST_TEST(c.empty());
+        BOOST_CHECK(equivalent(b));
+        BOOST_CHECK(c.empty());
        b.swap(c);
-        BOOST_TEST(b.empty());
-        BOOST_TEST(equivalent(c));
+        BOOST_CHECK(b.empty());
+        BOOST_CHECK(equivalent(c));
        b.swap(c);
-        BOOST_TEST(c.empty());
-        BOOST_TEST(equivalent(b));
+        BOOST_CHECK(c.empty());
+        BOOST_CHECK(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_CHECK(&(r = r) == &r);
+        BOOST_CHECK(r.empty());
+        BOOST_CHECK(&(r = a) == &r);
+        BOOST_CHECK(equivalent(r));
+        BOOST_CHECK(&(r = r) == &r);
+        BOOST_CHECK(equivalent(r));
    }

    {
-        BOOST_TEST(a.size() ==
+        BOOST_CHECK(a.size() ==
                (BOOST_DEDUCED_TYPENAME X::size_type) std::distance(a.begin(), a.end()));
    }

    {
-        BOOST_TEST(a.empty() == (a.size() == 0));
+        BOOST_CHECK(a.empty() == (a.size() == 0));
    }

    {
-        BOOST_TEST(a.empty() == (a.begin() == a.end()));
+        BOOST_CHECK(a.empty() == (a.begin() == a.end()));
        X u;
-        BOOST_TEST(u.begin() == u.end());
+        BOOST_CHECK(u.begin() == u.end());
    }
 }

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -1,5 +1,5 @@

-// Copyright 2006-2009 Daniel James.
+// 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)

@@ -68,22 +68,12 @@ namespace unnecessary_copy_tests
 #define COPY_COUNT(n) \
    if(count_copies::copies != n) { \
        BOOST_ERROR("Wrong number of copies."); \
-        std::cerr<<"Number of copies: "<<count_copies::copies<<" expecting: "<<n<<std::endl; \
+        std::cerr<<"Number of copies: "<<count_copies::copies<<std::endl; \
    }
 #define MOVE_COUNT(n) \
    if(count_copies::moves != n) { \
        BOOST_ERROR("Wrong number of moves."); \
-        std::cerr<<"Number of moves: "<<count_copies::moves<<" expecting: "<<n<<std::endl; \
-    }
-#define COPY_COUNT_RANGE(a, b) \
-    if(count_copies::copies < a || count_copies::copies > b) { \
-        BOOST_ERROR("Wrong number of copies."); \
-        std::cerr<<"Number of copies: "<<count_copies::copies<<" expecting: ["<<a<<", "<<b<<"]"<<std::endl; \
-    }
-#define MOVE_COUNT_RANGE(a, b) \
-    if(count_copies::moves < a || count_copies::moves > b) { \
-        BOOST_ERROR("Wrong number of moves."); \
-        std::cerr<<"Number of moves: "<<count_copies::copies<<" expecting: ["<<a<<", "<<b<<"]"<<std::endl; \
+        std::cerr<<"Number of moves: "<<count_copies::moves<<std::endl; \
    }

 namespace unnecessary_copy_tests
@@ -109,6 +99,7 @@ namespace unnecessary_copy_tests
    UNORDERED_TEST(unnecessary_copy_insert_test,
            ((set)(multiset)(map)(multimap)))

+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
    template <class T>
    void unnecessary_copy_emplace_test(T*)
    {
@@ -126,19 +117,9 @@ namespace unnecessary_copy_tests
        reset();
        T x;
        x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
        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_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
    template <class T>
    void unnecessary_copy_emplace_move_test(T*)
    {
@@ -150,11 +131,13 @@ namespace unnecessary_copy_tests
        COPY_COUNT(1); MOVE_COUNT(1);
    }

+    UNORDERED_TEST(unnecessary_copy_emplace_test,
+            ((set)(multiset)(map)(multimap)))
+    UNORDERED_TEST(unnecessary_copy_emplace_rvalue_test,
+            ((set)(multiset)(map)(multimap)))
    UNORDERED_TEST(unnecessary_copy_emplace_move_test,
            ((set)(multiset)(map)(multimap)))

-#endif
-
    UNORDERED_AUTO_TEST(unnecessary_copy_emplace_set_test)
    {
        reset();
@@ -189,12 +172,10 @@ namespace unnecessary_copy_tests
        x.emplace(source<count_copies>());
        COPY_COUNT(1); MOVE_COUNT(0);

-#if defined(BOOST_HAS_RVALUE_REFS)
        // No move should take place.
        reset();
        x.emplace(std::move(a));
        COPY_COUNT(0); MOVE_COUNT(0);
-#endif

        // Just in case a did get moved...
        count_copies b;
@@ -211,12 +192,8 @@ namespace unnecessary_copy_tests

        // 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);
    }
@@ -253,22 +230,24 @@ namespace unnecessary_copy_tests
        x.emplace(source<std::pair<count_copies, count_copies> >());
        COPY_COUNT(2); MOVE_COUNT(0);

-        // TODO: This doesn't work on older versions of gcc.
-        //count_copies part;
-        std::pair<count_copies const, count_copies> b;
-        //reset();
-        //std::pair<count_copies const&, count_copies const&> a_ref(part, part);
-        //x.emplace(a_ref);
-        //COPY_COUNT(0); MOVE_COUNT(0);
+        count_copies part;
+        reset();
+        std::pair<count_copies const&, count_copies const&> a_ref(part, part);
+        x.emplace(a_ref);
+        COPY_COUNT(0); MOVE_COUNT(0);

-#if defined(BOOST_HAS_RVALUE_REFS)
        // No move should take place.
-        // (since a is already in the container)
        reset();
        x.emplace(std::move(a));
        COPY_COUNT(0); MOVE_COUNT(0);
-#endif

+        // Just in case a did get moved
+        std::pair<count_copies const, count_copies> b;
+
+        // This test requires a C++0x std::pair. Which gcc hasn't got yet.
+        //reset();
+        //x.emplace(b.first.tag_);
+        //COPY_COUNT(2); MOVE_COUNT(0);

        //
        // 2 arguments
@@ -288,9 +267,10 @@ namespace unnecessary_copy_tests
        COPY_COUNT(1); MOVE_COUNT(0);

        reset();
-        x.emplace(count_copies(b.first.tag_), count_copies(b.second.tag_));
-        COPY_COUNT(2); MOVE_COUNT(0);        
+        x.emplace(b.first.tag_, b.second.tag_);
+        COPY_COUNT(2); MOVE_COUNT(0);
    }
+#endif
 }

 RUN_TESTS()