Release 1.47.0

[SVN r73007]

.gitignore

@@ -1 +0,0 @@
-/doc/html/

.travis.yml

@@ -1,60 +0,0 @@
-# Copyright (C) 2016 Daniel James.
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-# Use Trusty to get a reasonably recent version of Boost.
-sudo: required
-dist: trusty
-
-language: c++
-
-addons:
-    apt:
-        packages:
-            - libboost-tools-dev
-            - libxml2-utils
-            - g++-multilib
-
-matrix:
-    include:
-      - compiler: gcc
-        env: BJAM_TOOLSET=gcc
-      - compiler: gcc
-        env: BJAM_TOOLSET=gcc-std11
-      #- compiler: gcc
-      #  env: BJAM_TOOLSET=gcc-m32
-      - compiler: gcc
-        env: BJAM_TOOLSET=gcc-std11m32
-      #- compiler: clang
-      #  env: BJAM_TOOLSET=clang
-      - compiler: clang
-        env: BJAM_TOOLSET=clang-std11
-      - compiler: clang
-        env: BJAM_TOOLSET=clang-m32
-      #- compiler: clang
-      #  env: BJAM_TOOLSET=clang-std11m32
-
-before_script:
-    - cd ${TRAVIS_BUILD_DIR}
-    - touch Jamroot.jam
-    - cd $HOME
-    - |
-        echo "using gcc : : g++-4.8 -Werror --std=c++03 -fsanitize=address ;" > ~/user-config.jam
-        echo "using gcc : std11 : g++-4.8 -Werror --std=c++11 -fsanitize=address ;" >> ~/user-config.jam
-        echo "using gcc : m32 : g++-4.8 -m32 -Werror -fsanitize=address ;" >> ~/user-config.jam
-        echo "using gcc : std11m32 : g++-4.8 -m32 -Werror --std=c++11 -fsanitize=address ;" >> ~/user-config.jam
-        echo "using clang : : clang++ -Werror --std=c++03 -fsanitize=address ;" >> ~/user-config.jam
-        echo "using clang : std11 : clang++ -Werror --std=c++11 -fsanitize=address ;" >> ~/user-config.jam
-        # sanitized=address not available for 32-bit clang on travis.
-        echo "using clang : m32 : clang++ -m32 -Werror --std=c++03 ;" >> ~/user-config.jam
-        echo "using clang : std11m32 : clang++ -m32 -Werror --std=c++11 ;" >> ~/user-config.jam
-    - cat ~/user-config.jam
-    - wget -O boost.tar.bz2 https://sourceforge.net/projects/boost/files/boost/snapshots/master/boost_1_62_0.tar.bz2/download
-    - tar -xjf boost.tar.bz2
-    - mv boost_1_62_0 boost
-    - rm -r boost/boost/unordered
-
-script:
-    - cd ${TRAVIS_BUILD_DIR}/test
-    - bjam ${BJAM_TOOLSET} include=${HOME}/boost include=${TRAVIS_BUILD_DIR}/include
-    - xmllint --noout ${TRAVIS_BUILD_DIR}/doc/ref.xml

doc/Jamfile.v2

@@ -57,12 +57,3 @@ boostbook standalone : unordered :
     <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/unordered/doc/html
     ;
 
-###############################################################################
-alias boostdoc
-    : unordered
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;

doc/buckets.qbk

@@ -112,7 +112,7 @@ load factor is /required/ to be less than the maximum is following a call to
 below the max load factor, and set the maximum load factor to be the same as
 or close to the hint - unless your hint is unreasonably small or large.
 
-[table:bucket_size Methods for Controlling Bucket Size
+[table Methods for Controlling Bucket Size
     [[Method] [Description]]
 
     [

doc/changes.qbk

@@ -3,9 +3,6 @@
  / 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) ]
 
-[template ticket[number]'''<ulink
-    url="https://svn.boost.org/trac/boost/ticket/'''[number]'''">'''#[number]'''</ulink>''']
-
 [section:changes Change Log]
 
 [h2 Review Version]
@@ -47,7 +44,7 @@ First official release.
 
 [h2 Boost 1.38.0]
 
-* Use [@boost:/libs/core/swap.html `boost::swap`].
+* Use [@boost:/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
@@ -137,170 +134,4 @@ First official release.
 * Fix a bug when inserting into an `unordered_map` or `unordered_set` using
   iterators which returns `value_type` by copy.
 
-[h2 Boost 1.48.0 - Major update]
-
-This is major change which has been converted to use Boost.Move's move
-emulation, and be more compliant with the C++11 standard. See the
-[link unordered.compliance compliance section] for details.
-
-The container now meets C++11's complexity requirements, but to do so
-uses a little more memory. This means that `quick_erase` and
-`erase_return_void` are no longer required, they'll be removed in a
-future version.
-
-C++11 support has resulted in some breaking changes:
-
-* Equality comparison has been changed to the C++11 specification.
-  In a container with equivalent keys, elements in a group with equal
-  keys used to have to be in the same order to be considered equal,
-  now they can be a permutation of each other. To use the old
-  behavior define the macro `BOOST_UNORDERED_DEPRECATED_EQUALITY`.
-
-* The behaviour of swap is different when the two containers to be
-  swapped has unequal allocators. It used to allocate new nodes using
-  the appropriate allocators, it now swaps the allocators if
-  the allocator has a member structure `propagate_on_container_swap`,
-  such that `propagate_on_container_swap::value` is true.
-
-* Allocator's `construct` and `destroy` functions are called with raw
-  pointers, rather than the allocator's `pointer` type.
-
-* `emplace` used to emulate the variadic pair constructors that
-  appeared in early C++0x drafts. Since they were removed it no
-  longer does so. It does emulate the new `piecewise_construct`
-  pair constructors - only you need to use
-  `boost::piecewise_construct`. To use the old emulation of
-  the variadic consturctors define
-  `BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT`.
-
-[h2 Boost 1.49.0]
-
-* Fix warning due to accidental odd assignment.
-* Slightly better error messages.
-
-[h2 Boost 1.50.0]
-
-* Fix equality for `unordered_multiset` and `unordered_multimap`.
-* [@https://svn.boost.org/trac/boost/ticket/6857 Ticket 6857]:
-  Implement `reserve`.
-* [@https://svn.boost.org/trac/boost/ticket/6771 Ticket 6771]:
-  Avoid gcc's `-Wfloat-equal` warning.
-* [@https://svn.boost.org/trac/boost/ticket/6784 Ticket 6784]:
-  Fix some Sun specific code.
-* [@https://svn.boost.org/trac/boost/ticket/6190 Ticket 6190]:
-  Avoid gcc's `-Wshadow` warning.
-* [@https://svn.boost.org/trac/boost/ticket/6905 Ticket 6905]:
-  Make namespaces in macros compatible with `bcp` custom namespaces.
-  Fixed by Luke Elliott.
-* Remove some of the smaller prime number of buckets, as they may make
-  collisions quite probable (e.g. multiples of 5 are very common because
-  we used base 10).
-* On old versions of Visual C++, use the container library's implementation
-  of `allocator_traits`, as it's more likely to work.
-* On machines with 64 bit std::size_t, use power of 2 buckets, with Thomas
-  Wang's hash function to pick which one to use. As modulus is very slow
-  for 64 bit values.
-* Some internal changes.
-
-[h2 Boost 1.51.0]
-
-* Fix construction/destruction issue when using a C++11 compiler with a
-  C++03 allocator ([ticket 7100]).
-* Remove a `try..catch` to support compiling without exceptions.
-* Adjust SFINAE use to try to supprt g++ 3.4 ([ticket 7175]).
-* Updated to use the new config macros.
-
-[h2 Boost 1.52.0]
-
-* Faster assign, which assigns to existing nodes where possible, rather than
-  creating entirely new nodes and copy constructing.
-* Fixed bug in `erase_range` ([ticket 7471]).
-* Reverted some of the internal changes to how nodes are created, especially
-  for C++11 compilers. 'construct' and 'destroy' should work a little better
-  for C++11 allocators.
-* Simplified the implementation a bit. Hopefully more robust.
-
-[h2 Boost 1.53.0]
-
-* Remove support for the old pre-standard variadic pair constructors, and
-  equality implementation. Both have been deprecated since Boost 1.48.
-* Remove use of deprecated config macros.
-* More internal implementation changes, including a much simpler
-  implementation of `erase`.
-
-[h2 Boost 1.54.0]
-
-* Mark methods specified in standard as `noexpect`. More to come in the next
-  release.
-* If the hash function and equality predicate are known to both have nothrow
-  move assignment or construction then use them.
-
-[h2 Boost 1.55.0]
-
-* Avoid some warnings ([ticket 8851], [ticket 8874]).
-* Avoid exposing some detail functions via. ADL on the iterators.
-* Follow the standard by only using the allocators' construct and destroy
-  methods to construct and destroy stored elements. Don't use them for internal
-  data like pointers.
-
-[h2 Boost 1.56.0]
-
-* Fix some shadowed variable warnings ([ticket 9377]).
-* Fix allocator use in documentation ([ticket 9719]).
-* Always use prime number of buckets for integers. Fixes performance
-  regression when inserting consecutive integers, although makes other
-  uses slower ([ticket 9282]).
-* Only construct elements using allocators, as specified in C++11 standard.
-
-[h2 Boost 1.57.0]
-
-* Fix the `pointer` typedef in iterators ([ticket 10672]).
-* Fix Coverity warning
-  ([@https://github.com/boostorg/unordered/pull/2 GitHub #2]).
-
-[h2 Boost 1.58.0]
-
-* Remove unnecessary template parameter from const iterators.
-* Rename private `iterator` typedef in some iterator classes, as it
-  confuses some traits classes.
-* Fix move assignment with stateful, propagate_on_container_move_assign
-  allocators ([ticket 10777]).
-* Fix rare exception safety issue in move assignment.
-* Fix potential overflow when calculating number of buckets to allocate
-  ([@https://github.com/boostorg/unordered/pull/4 GitHub #4]).
-
-[h2 Boost 1.62.0]
-
-* Remove use of deprecated `boost::iterator`.
-* Remove `BOOST_NO_STD_DISTANCE` workaround.
-* Remove `BOOST_UNORDERED_DEPRECATED_EQUALITY` warning.
-* Simpler implementation of assignment, fixes an exception safety issue
-  for `unordered_multiset` and `unordered_multimap`. Might be a little slower.
-* Stop using return value SFINAE which some older compilers have issues
-  with.
-
-[h2 Boost 1.63.0]
-
-* Check hint iterator in `insert`/`emplace_hint`.
-* Fix some warnings, mostly in the tests.
-* Manually write out `emplace_args` for small numbers of arguments -
-  should make template error messages a little more bearable.
-* Remove superfluous use of `boost::forward` in emplace arguments,
-  which fixes emplacing string literals in old versions of Visual C++.
-* Fix an exception safety issue in assignment. If bucket allocation
-  throws an exception, it can overwrite the hash and equality functions while
-  leaving the existing elements in place. This would mean that the function
-  objects wouldn't match the container elements, so elements might be in the
-  wrong bucket and equivalent elements would be incorrectly handled.
-* Various reference documentation improvements.
-* Better allocator support ([ticket 12459]).
-* Make the no argument constructors implicit.
-* Implement missing allocator aware constructors.
-* Fix assigning the hash/key equality functions for empty containers.
-* Remove unary/binary_function from the examples in the documentation.
-  They are removed in C++17.
-* Support 10 constructor arguments in emplace. It was meant to support up to 10
-  arguments, but an off by one error in the preprocessor code meant it only
-  supports up to 10.
-
 [endsect]

doc/comparison.qbk

@@ -1,10 +1,10 @@
-[/ Copyright 2006-2011 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) ]
 
 [section:comparison Comparison with Associative Containers]
 
-[table:interface_differences Interface differences.
+[table Interface differences.
     [[Associative Containers] [Unordered Associative Containers]]
 
     [
@@ -66,12 +66,15 @@
     [
         [No equivalent]
         [Local iterators can be used to iterate through individual buckets.
-            (The order of local iterators and iterators aren't
+            (I don't think that the order of local iterators and iterators are
             required to have any correspondence.)]
     ]
     [
         [Can be compared using the `==`, `!=`, `<`, `<=`, `>`, `>=` operators.]
-        [Can be compared using the `==` and `!=` operators.]
+        [No comparison operators are defined in the standard, although
+            [link unordered.rationale.equality_operators
+            implementations might extend the containers to support `==` and
+            `!=`].]
     ]
     [
         []
@@ -85,7 +88,7 @@
     ]
 ]
 
-[table:complexity_guarantees Complexity Guarantees
+[table Complexity Guarantees
     [[Operation] [Associative Containers] [Unordered Associative Containers]]
     [
         [Construction of empty container]

doc/compliance.qbk

@@ -1,112 +0,0 @@
-[/ Copyright 2011 Daniel James.
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) ]
-
-[section:compliance C++11 Compliance]
-
-[section:move Move emulation]
-
-Support for move semantics is implemented using Boost.Move. If rvalue
-references are available it will use them, but if not it uses a close,
-but imperfect emulation. On such compilers:
-
-* Non-copyable objects can be stored in the containers.
-  They can be constructed in place using `emplace`, or if they support
-  Boost.Move, moved into place.
-* The containers themselves are not movable.
-* Argument forwarding is not perfect.
-
-[endsect]
-
-[section:allocator_compliance Use of allocators]
-
-C++11 introduced a new allocator system. It's backwards compatible due to
-the lax requirements for allocators in the old standard, but might need
-some changes for allocators which worked with the old versions of the
-unordered containers.
-It uses a traits class, `allocator_traits` to handle the allocator
-adding extra functionality, and making some methods and types optional.
-During development a stable release of
-`allocator_traits` wasn't available so an internal partial implementation
-is always used in this version. Hopefully a future version will use the
-standard implementation where available.
-
-The member functions `construct`, `destroy` and `max_size` are now
-optional, if they're not available a fallback is used.
-A full implementation of `allocator_traits` requires sophisticated
-member function detection so that the fallback is used whenever the
-member function call is not well formed.
-This requires support for SFINAE expressions, which are available on
-GCC from version 4.4 and Clang.
-
-On other compilers, there's just a test to see if the allocator has
-a member, but no check that it can be called. So rather than using a
-fallback there will just be a compile error.
-
-`propagate_on_container_copy_assignment`,
-`propagate_on_container_move_assignment`,
-`propagate_on_container_swap` and
-`select_on_container_copy_construction` are also supported.
-Due to imperfect move emulation, some assignments might check
-`propagate_on_container_copy_assignment` on some compilers and
-`propagate_on_container_move_assignment` on others.
-
-The use of the allocator's construct and destruct methods might be a bit
-surprising.
-Nodes are constructed and destructed using the allocator, but the elements
-are stored in aligned space within the node and constructed and destructed
-by calling the constructor and destructor directly.
-
-In C++11 the allocator's construct function has the signature:
-
-    template <class U, class... Args>
-    void construct(U* p, Args&&... args);
-
-which supports calling `construct` for the contained object, but
-most existing allocators don't support this. If member function detection
-was good enough then with old allocators it would fall back to calling
-the element's constructor directly but in general, detection isn't good
-enough to do this which is why Boost.Unordered just calls the constructor
-directly every time. In most cases this will work okay.
-
-`pointer_traits` aren't used. Instead, pointer types are obtained from
-rebound allocators, this can cause problems if the allocator can't be
-used with incomplete types. If `const_pointer` is not defined in the
-allocator, `boost::pointer_to_other<pointer, const value_type>::type`
-is used to obtain a const pointer.
-
-[endsect]
-
-[section:pairs Pairs]
-
-Since the containers use `std::pair` they're limited to the version
-from the current standard library. But since C++11 `std::pair`'s
-`piecewise_construct` based constructor is very useful, `emplace`
-emulates it with a `piecewise_construct` in the `boost::unordered`
-namespace. So for example, the following will work:
-
-    boost::unordered_multimap<std::string, std::complex> x;
-
-    x.emplace(
-        boost::unordered::piecewise_construct,
-        boost::make_tuple("key"), boost::make_tuple(1, 2));
-
-Older drafts of the standard also supported variadic constructors
-for `std::pair`, where the first argument would be used for the
-first part of the pair, and the remaining for the second part.
-
-[endsect]
-
-[section:misc Miscellaneous]
-
-When swapping, `Pred` and `Hash` are not currently swapped by calling
-`swap`, their copy constructors are used. As a consequence when swapping
-an exception may be throw from their  copy constructor.
-
-Variadic constructor arguments for `emplace` are only used when both
-rvalue references and variadic template parameters are available.
-Otherwise `emplace` can only take up to 10 constructors arguments.
-
-[endsect]
-
-[endsect]

doc/hash_equality.qbk

@@ -67,10 +67,9 @@ so that the hash function doesn't need to be explicitly given:
 
 See the [link hash.custom Boost.Hash documentation] for more detail on how to
 do this.  Remember that it relies on extensions to the draft standard - so it
-won't work for other implementations of the unordered associative containers,
-you'll need to explicitly use Boost.Hash.
+won't work on other implementations of the unordered associative containers.
 
-[table:access_methods Methods for accessing the hash and equality functions.
+[table Methods for accessing the hash and equality functions.
     [[Method] [Description]]
 
     [

doc/intro.qbk

@@ -2,6 +2,15 @@
  / 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) ]
 
+[def __tr1__ 
+    [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf
+    C++ Standard Library Technical Report]]
+[def __boost-tr1__
+    [@http://www.boost.org/doc/html/boost_tr1.html
+    Boost.TR1]]
+[def __draft__
+    [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2960.pdf
+    Working Draft of the C++ Standard]]
 [def __hash-table__ [@http://en.wikipedia.org/wiki/Hash_table
     hash table]]
 [def __hash-function__ [@http://en.wikipedia.org/wiki/Hash_function
@@ -22,10 +31,12 @@ to order their elements. For some data types this is impossible to implement
 or isn't practical. In contrast, a hash table only needs an equality function
 and a hash function for the key.
 
-With this in mind, unordered associative containers were added to the C++
-standard. This is an implementation of the containers described in C++11,
-with some [link unordered.compliance deviations from the standard] in
-order to work with non-C++11 compilers and libraries.
+With this in mind, the __tr1__ introduced the unordered associative containers,
+which are implemented using hash tables, and they have now been added to the
+__draft__.
+
+This library supplies an almost complete implementation of the specification in
+the __draft__.
 
 `unordered_set` and `unordered_multiset` are defined in the header
 <[headerref boost/unordered_set.hpp]>
@@ -54,14 +65,14 @@ order to work with non-C++11 compilers and libraries.
             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]``;
 
         template<
             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_multimap unordered_multimap]``;
     }
 

doc/rationale.qbk

@@ -3,7 +3,7 @@
  / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) ]
 
 [def __wang__
-    [@http://web.archive.org/web/20121102023700/http://www.concentric.net/~Ttwang/tech/inthash.htm
+    [@http://www.concentric.net/~Ttwang/tech/inthash.htm
     Thomas Wang's article on integer hash functions]]
 
 [section:rationale Implementation Rationale]
@@ -44,8 +44,6 @@ bucket but there are a some serious problems with this:
 
 So chained addressing is used.
 
-[/ (Removing for now as this is out of date)
-
 For containers with unique keys I store the buckets in a single-linked list.
 There are other possible data structures (such as a double-linked list)
 that allow for some operations to be faster (such as erasing and iteration)
@@ -65,17 +63,6 @@ nodes in reverse order. This allows quick navigation to the end of a group (sinc
 the first element points to the last) and can be quickly updated when elements
 are inserted or erased. The main disadvantage of this approach is some hairy code
 for erasing elements.
-]
-
-[/ (Starting to write up new structure, might not be ready in time)
-The node used to be stored in a linked list for each bucket but that
-didn't meet the complexity requirements for C++11, so now the nodes
-are stored in one long single linked list. But there needs a way to get
-the bucket from the node, to do that a copy of the key's hash value is
-stored in the node. Another possibility would be to store a pointer to
-the bucket, or the bucket's index, but storing the hash value allows
-some operations to be faster.
-]
 
 [h2 Number of Buckets]
 
@@ -85,8 +72,7 @@ of 2.
 
 Using a prime number of buckets, and choosing a bucket by using the modulus
 of the hash function's result will usually give a good result. The downside
-is that the required modulus operation is fairly expensive. This is what the
-containers do in most cases.
+is that the required modulus operation is fairly expensive.
 
 Using a power of 2 allows for much quicker selection of the bucket
 to use, but at the expense of loosing the upper bits of the hash value.
@@ -96,16 +82,60 @@ functions this can't be relied on.
 
 To avoid this a transformation could be applied to the hash function, for an
 example see __wang__.  Unfortunately, a transformation like Wang's requires
-knowledge of the number of bits in the hash value, so it isn't portable enough
-to use as a default. It can applicable in certain cases so the containers
-have a policy based implementation that can use this alternative technique.
+knowledge of the number of bits in the hash value, so it isn't portable enough.
+This leaves more expensive methods, such as Knuth's Multiplicative Method
+(mentioned in Wang's article). These don't tend to work as well as taking the
+modulus of a prime, and the extra computation required might negate
+efficiency advantage of power of 2 hash tables.
 
-Currently this is only done on 64 bit architecures, where prime number
-modulus can be expensive. Although this varies depending on the architecture,
-so I probably should revisit it.
+So, this implementation uses a prime number for the hash table size.
 
-I'm also thinking of introducing a mechanism whereby a hash function can
-indicate that it's safe to be used directly with power of 2 buckets, in
-which case a faster plain power of 2 implementation can be used.
+[h2 Equality operators]
+
+`operator==` and `operator!=` are not included in the standard, but I've
+added them as I think they could be useful and can be implemented
+fairly efficiently. They are specified differently to the other standard
+containers, comparing keys using the equality predicate rather than
+`operator==`.
+
+It's also different to the proposal
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2944.pdf n2944].
+which uses the equality operators for the whole of `value_type`. This
+implementation just uses the key equality function for the key,
+and `mapped_type`'s equality operator in `unordered_map` and
+`unordered_multimap` for the mapped part of the element.
+
+Also, in `unordered_multimap`, the mapped values for a group of elements with
+equivalent keys are only considered equal if they are in the same order,
+in n2944 they just need to be a permutation of each other. Since the
+order of elements with equal keys is now defined to be stable, it seems to me
+that their order can be considered part of the container's value.
+
+[h2 Active Issues and Proposals]
+
+[h3 C++0x allocators]
+
+Recent drafts have included an overhaul of the allocators, but this was
+dependent on concepts which are no longer in the standard.
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2946.pdf n2946]
+attempts to respecify them without concepts. I'll try to implement this (or
+an appropriate later version) in a future version of boost, possibly changed
+a little to accomodate non-C++0x compilers.
+
+[h3 Swapping containers with unequal allocators]
+
+It isn't clear how to swap containers when their allocators aren't equal.
+This is 
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#431
+Issue 431: Swapping containers with unequal allocators]. This has been resolved
+with the new allocator specification, so this should be fixed when
+support is added.
+
+[h3 Are insert and erase stable for unordered_multiset and unordered_multimap?]
+
+It wan't specified if `unordered_multiset` and `unordered_multimap` preserve the order
+of elements with equivalent keys (i.e. if they're stable under `insert` and `erase`).
+Since [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf
+n2691] it's been specified that they do and this implementation follows that.
 
 [endsect]

doc/src_code/dictionary.cpp

@@ -10,6 +10,7 @@
 
 //[case_insensitive_functions
     struct iequal_to
+        : std::binary_function<std::string, std::string, bool>
     {
         bool operator()(std::string const& x,
             std::string const& y) const
@@ -19,6 +20,7 @@
     };
 
     struct ihash
+        : std::unary_function<std::string, std::size_t>
     {
         std::size_t operator()(std::string const& x) const
         {

doc/src_code/point1.cpp

@@ -18,6 +18,7 @@
     }
 
     struct point_hash
+        : std::unary_function<point, std::size_t>
     {
         std::size_t operator()(point const& p) const
         {

doc/unordered.qbk

@@ -3,7 +3,7 @@
  / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) ]
 
 [library Boost.Unordered
-    [quickbook 1.5]
+    [quickbook 1.4]
     [authors [James, Daniel]]
     [copyright 2003 2004 Jeremy B. Maitin-Shepard]
     [copyright 2005 2006 2007 2008 Daniel James]
@@ -31,7 +31,6 @@
 [include:unordered buckets.qbk]
 [include:unordered hash_equality.qbk]
 [include:unordered comparison.qbk]
-[include:unordered compliance.qbk]
 [include:unordered rationale.qbk]
 [include:unordered changes.qbk]
 [xinclude ref.xml]

examples/case_insensitive.hpp

@@ -19,6 +19,7 @@
 namespace hash_examples
 {
     struct iequal_to
+        : std::binary_function<std::string, std::string, bool>
     {
         iequal_to() {}
         explicit iequal_to(std::locale const& l) : locale_(l) {}
@@ -33,6 +34,7 @@ namespace hash_examples
     };
 
     struct ihash
+        : std::unary_function<std::string, std::size_t>
     {
         ihash() {}
         explicit ihash(std::locale const& l) : locale_(l) {}

include/boost/unordered/detail/allocator_helpers.hpp

@@ -0,0 +1,111 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// A couple of templates to make using allocators easier.
+
+#ifndef BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#if (defined(BOOST_NO_STD_ALLOCATOR) || defined(BOOST_DINKUMWARE_STDLIB)) \
+    && !defined(__BORLANDC__)
+#  define BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES
+#endif
+
+#if defined(BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES)
+#  include <boost/detail/allocator_utilities.hpp>
+#endif
+
+namespace boost { namespace unordered_detail {
+
+    // rebind_wrap
+    //
+    // Rebind allocators. For some problematic libraries, use rebind_to
+    // from <boost/detail/allocator_utilities.hpp>.
+
+#if defined(BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES)
+    template <class Alloc, class T>
+    struct rebind_wrap : ::boost::detail::allocator::rebind_to<Alloc, T> {};
+#else
+    template <class Alloc, class T>
+    struct rebind_wrap
+    {
+        typedef BOOST_DEDUCED_TYPENAME
+            Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other
+            type;
+    };
+#endif
+
+    // allocator_array_constructor
+    //
+    // Allocate and construct an array in an exception safe manner, and
+    // clean up if an exception is thrown before the container takes charge
+    // of it.
+
+    template <class Allocator>
+    struct allocator_array_constructor
+    {
+        typedef BOOST_DEDUCED_TYPENAME Allocator::pointer pointer;
+
+        Allocator& alloc_;
+        pointer ptr_;
+        pointer constructed_;
+        std::size_t length_;
+
+        allocator_array_constructor(Allocator& a)
+            : alloc_(a), ptr_(), constructed_(), length_(0)
+        {
+            constructed_ = pointer();
+            ptr_ = pointer();
+        }
+
+        ~allocator_array_constructor() {
+            if (ptr_) {
+                for(pointer p = ptr_; p != constructed_; ++p)
+                    alloc_.destroy(p);
+
+                alloc_.deallocate(ptr_, length_);
+            }
+        }
+
+        template <class V>
+        void construct(V const& v, std::size_t l)
+        {
+            BOOST_ASSERT(!ptr_);
+            length_ = l;
+            ptr_ = alloc_.allocate(length_);
+            pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
+            for(constructed_ = ptr_; constructed_ != end; ++constructed_)
+                alloc_.construct(constructed_, v);
+        }
+
+        pointer get() const
+        {
+            return ptr_;
+        }
+
+        pointer release()
+        {
+            pointer p(ptr_);
+            ptr_ = pointer();
+            return p;
+        }
+    private:
+        allocator_array_constructor(allocator_array_constructor const&);
+        allocator_array_constructor& operator=(
+            allocator_array_constructor const&);
+    };
+}}
+
+#if defined(BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES)
+#  undef BOOST_UNORDERED_USE_ALLOCATOR_UTILITIES
+#endif
+
+#endif

include/boost/unordered/detail/buckets.hpp

@@ -1,6 +1,6 @@
 
 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
-// Copyright (C) 2005-2011 Daniel James
+// Copyright (C) 2005-2009 Daniel James
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -8,767 +8,176 @@
 #define BOOST_UNORDERED_DETAIL_MANAGER_HPP_INCLUDED
 
 #include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
+#include <boost/assert.hpp>
+#include <boost/unordered/detail/node.hpp>
 #include <boost/unordered/detail/util.hpp>
-#include <boost/unordered/detail/allocate.hpp>
 
-namespace boost { namespace unordered { namespace detail {
+namespace boost { namespace unordered_detail {
+    
+    ////////////////////////////////////////////////////////////////////////////
+    // Buckets
+    
+    template <class A, class G>
+    inline std::size_t hash_buckets<A, G>::max_bucket_count() const {
+        // -1 to account for the sentinel.
+        return prev_prime(this->bucket_alloc().max_size() - 1);
+    }
 
-    template <typename Types> struct table;
-    template <typename NodePointer> struct bucket;
-    struct ptr_bucket;
-    template <typename Types> struct table_impl;
-    template <typename Types> struct grouped_table_impl;
+    template <class A, class G>
+    inline BOOST_DEDUCED_TYPENAME hash_buckets<A, G>::bucket_ptr
+        hash_buckets<A, G>::get_bucket(std::size_t num) const
+    {
+        return buckets_ + static_cast<std::ptrdiff_t>(num);
+    }
 
-}}}
+    template <class A, class G>
+    inline BOOST_DEDUCED_TYPENAME hash_buckets<A, G>::bucket_ptr
+        hash_buckets<A, G>::bucket_ptr_from_hash(std::size_t hashed) const
+    {
+        return get_bucket(hashed % bucket_count_);
+    }
+    
+    template <class A, class G>
+    std::size_t hash_buckets<A, G>::bucket_size(std::size_t index) const
+    {
+        if(!buckets_) return 0;
+        bucket_ptr ptr = get_bucket(index)->next_;
+        std::size_t count = 0;
+        while(ptr) {
+            ++count;
+            ptr = ptr->next_;
+        }
+        return count;
+    }
 
-// The 'iterator_detail' namespace was a misguided attempt at avoiding ADL
-// in the detail namespace. It didn't work because the template parameters
-// were in detail. I'm not changing it at the moment to be safe. I might
-// do in the future if I change the iterator types.
-namespace boost { namespace unordered { namespace iterator_detail {
+    template <class A, class G>
+    inline BOOST_DEDUCED_TYPENAME hash_buckets<A, G>::node_ptr
+        hash_buckets<A, G>::bucket_begin(std::size_t num) const
+    {
+        return buckets_ ? get_bucket(num)->next_ : node_ptr();
+    }
 
     ////////////////////////////////////////////////////////////////////////////
-    // Iterators
-    //
-    // all no throw
+    // Delete
 
-    template <typename Node> struct iterator;
-    template <typename Node> struct c_iterator;
-    template <typename Node, typename Policy> struct l_iterator;
-    template <typename Node, typename Policy>
-        struct cl_iterator;
-
-    // Local Iterators
-    //
-    // all no throw
-
-    template <typename Node, typename Policy>
-    struct l_iterator
-        : public std::iterator<
-            std::forward_iterator_tag,
-            typename Node::value_type,
-            std::ptrdiff_t,
-            typename Node::value_type*,
-            typename Node::value_type&>
+    template <class A, class G>
+    inline void hash_buckets<A, G>::delete_node(node_ptr b)
     {
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename Node2, typename Policy2>
-        friend struct boost::unordered::iterator_detail::cl_iterator;
-    private:
-#endif
-        typedef typename Node::node_pointer node_pointer;
-        node_pointer ptr_;
-        std::size_t bucket_;
-        std::size_t bucket_count_;
+        node* raw_ptr = static_cast<node*>(&*b);
+        boost::unordered_detail::destroy(raw_ptr->value_ptr());
+        real_node_ptr n(node_alloc().address(*raw_ptr));
+        node_alloc().destroy(n);
+        node_alloc().deallocate(n, 1);
+    }
 
-    public:
-
-        typedef typename Node::value_type value_type;
-
-        l_iterator() BOOST_NOEXCEPT : ptr_() {}
-
-        l_iterator(node_pointer n, std::size_t b, std::size_t c) BOOST_NOEXCEPT
-            : ptr_(n), bucket_(b), bucket_count_(c) {}
-
-        value_type& operator*() const {
-            return ptr_->value();
-        }
-
-        value_type* operator->() const {
-            return ptr_->value_ptr();
-        }
-
-        l_iterator& operator++() {
-            ptr_ = static_cast<node_pointer>(ptr_->next_);
-            if (ptr_ && Policy::to_bucket(bucket_count_, ptr_->hash_)
-                    != bucket_)
-                ptr_ = node_pointer();
-            return *this;
-        }
-
-        l_iterator operator++(int) {
-            l_iterator tmp(*this);
-            ++(*this);
-            return tmp;
-        }
-
-        bool operator==(l_iterator x) const BOOST_NOEXCEPT {
-            return ptr_ == x.ptr_;
-        }
-
-        bool operator!=(l_iterator x) const BOOST_NOEXCEPT {
-            return ptr_ != x.ptr_;
-        }
-    };
-
-    template <typename Node, typename Policy>
-    struct cl_iterator
-        : public std::iterator<
-            std::forward_iterator_tag,
-            typename Node::value_type,
-            std::ptrdiff_t,
-            typename Node::value_type const*,
-            typename Node::value_type const&>
+    template <class A, class G>
+    inline void hash_buckets<A, G>::clear_bucket(bucket_ptr b)
     {
-        friend struct boost::unordered::iterator_detail::l_iterator
-            <Node, Policy>;
-    private:
+        node_ptr node_it = b->next_;
+        b->next_ = node_ptr();
 
-        typedef typename Node::node_pointer node_pointer;
-        node_pointer ptr_;
-        std::size_t bucket_;
-        std::size_t bucket_count_;
-
-    public:
-
-        typedef typename Node::value_type value_type;
-
-        cl_iterator() BOOST_NOEXCEPT : ptr_() {}
-
-        cl_iterator(node_pointer n, std::size_t b, std::size_t c) BOOST_NOEXCEPT :
-            ptr_(n), bucket_(b), bucket_count_(c) {}
-
-        cl_iterator(boost::unordered::iterator_detail::l_iterator<
-                Node, Policy> const& x) BOOST_NOEXCEPT :
-            ptr_(x.ptr_), bucket_(x.bucket_), bucket_count_(x.bucket_count_)
-        {}
-
-        value_type const& operator*() const {
-            return ptr_->value();
-        }
-
-        value_type const* operator->() const {
-            return ptr_->value_ptr();
-        }
-
-        cl_iterator& operator++() {
-            ptr_ = static_cast<node_pointer>(ptr_->next_);
-            if (ptr_ && Policy::to_bucket(bucket_count_, ptr_->hash_)
-                    != bucket_)
-                ptr_ = node_pointer();
-            return *this;
-        }
-
-        cl_iterator operator++(int) {
-            cl_iterator tmp(*this);
-            ++(*this);
-            return tmp;
-        }
-
-        friend bool operator==(cl_iterator const& x, cl_iterator const& y)
-            BOOST_NOEXCEPT
-        {
-            return x.ptr_ == y.ptr_;
-        }
-
-        friend bool operator!=(cl_iterator const& x, cl_iterator const& y)
-            BOOST_NOEXCEPT
-        {
-            return x.ptr_ != y.ptr_;
-        }
-    };
-
-    template <typename Node>
-    struct iterator
-        : public std::iterator<
-            std::forward_iterator_tag,
-            typename Node::value_type,
-            std::ptrdiff_t,
-            typename Node::value_type*,
-            typename Node::value_type&>
-    {
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename>
-        friend struct boost::unordered::iterator_detail::c_iterator;
-        template <typename>
-        friend struct boost::unordered::detail::table;
-        template <typename>
-        friend struct boost::unordered::detail::table_impl;
-        template <typename>
-        friend struct boost::unordered::detail::grouped_table_impl;
-    private:
-#endif
-        typedef typename Node::node_pointer node_pointer;
-        node_pointer node_;
-
-    public:
-
-        typedef typename Node::value_type value_type;
-
-        iterator() BOOST_NOEXCEPT : node_() {}
-
-        explicit iterator(typename Node::link_pointer x) BOOST_NOEXCEPT :
-            node_(static_cast<node_pointer>(x)) {}
-
-        value_type& operator*() const {
-            return node_->value();
-        }
-
-        value_type* operator->() const {
-            return node_->value_ptr();
-        }
-
-        iterator& operator++() {
-            node_ = static_cast<node_pointer>(node_->next_);
-            return *this;
-        }
-
-        iterator operator++(int) {
-            iterator tmp(node_);
-            node_ = static_cast<node_pointer>(node_->next_);
-            return tmp;
-        }
-
-        bool operator==(iterator const& x) const BOOST_NOEXCEPT {
-            return node_ == x.node_;
-        }
-
-        bool operator!=(iterator const& x) const BOOST_NOEXCEPT {
-            return node_ != x.node_;
-        }
-    };
-
-    template <typename Node>
-    struct c_iterator
-        : public std::iterator<
-            std::forward_iterator_tag,
-            typename Node::value_type,
-            std::ptrdiff_t,
-            typename Node::value_type const*,
-            typename Node::value_type const&>
-    {
-        friend struct boost::unordered::iterator_detail::iterator<Node>;
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename>
-        friend struct boost::unordered::detail::table;
-        template <typename>
-        friend struct boost::unordered::detail::table_impl;
-        template <typename>
-        friend struct boost::unordered::detail::grouped_table_impl;
-
-    private:
-#endif
-        typedef typename Node::node_pointer node_pointer;
-        typedef boost::unordered::iterator_detail::iterator<Node> n_iterator;
-        node_pointer node_;
-
-    public:
-
-        typedef typename Node::value_type value_type;
-
-        c_iterator() BOOST_NOEXCEPT : node_() {}
-
-        explicit c_iterator(typename Node::link_pointer x) BOOST_NOEXCEPT :
-            node_(static_cast<node_pointer>(x)) {}
-
-        c_iterator(n_iterator const& x) BOOST_NOEXCEPT : node_(x.node_) {}
-
-        value_type const& operator*() const {
-            return node_->value();
-        }
-
-        value_type const* operator->() const {
-            return node_->value_ptr();
-        }
-
-        c_iterator& operator++() {
-            node_ = static_cast<node_pointer>(node_->next_);
-            return *this;
-        }
-
-        c_iterator operator++(int) {
-            c_iterator tmp(node_);
-            node_ = static_cast<node_pointer>(node_->next_);
-            return tmp;
-        }
-
-        friend bool operator==(c_iterator const& x, c_iterator const& y)
-            BOOST_NOEXCEPT
-        {
-            return x.node_ == y.node_;
-        }
-
-        friend bool operator!=(c_iterator const& x, c_iterator const& y)
-            BOOST_NOEXCEPT
-        {
-            return x.node_ != y.node_;
-        }
-    };
-}}}
-
-namespace boost { namespace unordered { namespace detail {
-
-    ///////////////////////////////////////////////////////////////////
-    //
-    // Node Holder
-    //
-    // Temporary store for nodes. Deletes any that aren't used.
-
-    template <typename NodeAlloc>
-    struct node_holder
-    {
-    private:
-        typedef NodeAlloc node_allocator;
-        typedef boost::unordered::detail::allocator_traits<NodeAlloc>
-            node_allocator_traits;
-        typedef typename node_allocator_traits::value_type node;
-        typedef typename node_allocator_traits::pointer node_pointer;
-        typedef typename node::value_type value_type;
-        typedef typename node::link_pointer link_pointer;
-        typedef boost::unordered::iterator_detail::iterator<node> iterator;
-
-        node_constructor<NodeAlloc> constructor_;
-        node_pointer nodes_;
-
-    public:
-
-        template <typename Table>
-        explicit node_holder(Table& b) :
-            constructor_(b.node_alloc()),
-            nodes_()
-        {
-            if (b.size_) {
-                typename Table::link_pointer prev = b.get_previous_start();
-                nodes_ = static_cast<node_pointer>(prev->next_);
-                prev->next_ = link_pointer();
-                b.size_ = 0;
-            }
-        }
-
-        ~node_holder();
-
-        node_pointer pop_node()
-        {
-            node_pointer n = nodes_;
-            nodes_ = static_cast<node_pointer>(nodes_->next_);
-            n->init(n);
-            n->next_ = link_pointer();
-            return n;
-        }
-
-        template <typename T>
-        inline node_pointer copy_of(T const& v) {
-            if (nodes_) {
-                constructor_.reclaim(pop_node());
-            }
-            else {
-                constructor_.create_node();
-            }
-            boost::unordered::detail::func::call_construct(
-                constructor_.alloc_, constructor_.node_->value_ptr(), v);
-            return constructor_.release();
-        }
-
-        template <typename T>
-        inline node_pointer move_copy_of(T& v) {
-            if (nodes_) {
-                constructor_.reclaim(pop_node());
-            }
-            else {
-                constructor_.create_node();
-            }
-            boost::unordered::detail::func::call_construct(
-                constructor_.alloc_, constructor_.node_->value_ptr(),
-                boost::move(v));
-            return constructor_.release();
-        }
-
-        iterator begin() const
-        {
-            return iterator(nodes_);
-        }
-    };
-
-    template <typename Alloc>
-    node_holder<Alloc>::~node_holder()
-    {
-        while (nodes_) {
-            node_pointer p = nodes_;
-            nodes_ = static_cast<node_pointer>(p->next_);
-
-            boost::unordered::detail::func::call_destroy(constructor_.alloc_,
-                p->value_ptr());
-            boost::unordered::detail::func::destroy(boost::addressof(*p));
-            node_allocator_traits::deallocate(constructor_.alloc_, p, 1);
+        while(node_it) {
+            node_ptr node_to_delete = node_it;
+            node_it = node_it->next_;
+            delete_node(node_to_delete);
         }
     }
 
-    ///////////////////////////////////////////////////////////////////
-    //
-    // Bucket
+    template <class A, class G>
+    inline void hash_buckets<A, G>::delete_buckets()
+    {      
+        bucket_ptr end = this->get_bucket(this->bucket_count_);
 
-    template <typename NodePointer>
-    struct bucket
+        for(bucket_ptr begin = this->buckets_; begin != end; ++begin) {
+            clear_bucket(begin);
+        }
+
+        // Destroy the buckets (including the sentinel bucket).
+        ++end;
+        for(bucket_ptr begin = this->buckets_; begin != end; ++begin) {
+            bucket_alloc().destroy(begin);
+        }
+
+        bucket_alloc().deallocate(this->buckets_, this->bucket_count_ + 1);
+
+        this->buckets_ = bucket_ptr();
+    }
+
+    template <class A, class G>
+    inline std::size_t hash_buckets<A, G>::delete_nodes(
+        node_ptr begin, node_ptr end)
     {
-        typedef NodePointer link_pointer;
-        link_pointer next_;
-
-        bucket() : next_() {}
-
-        link_pointer first_from_start()
-        {
-            return next_;
+        std::size_t count = 0;
+        while(begin != end) {
+            node_ptr n = begin;
+            begin = begin->next_;
+            delete_node(n);
+            ++count;
         }
-
-        enum { extra_node = true };
-    };
-
-    struct ptr_bucket
-    {
-        typedef ptr_bucket* link_pointer;
-        link_pointer next_;
-
-        ptr_bucket() : next_(0) {}
-
-        link_pointer first_from_start()
-        {
-            return this;
-        }
-
-        enum { extra_node = false };
-    };
-
-    ///////////////////////////////////////////////////////////////////
-    //
-    // Hash Policy
-
-    template <typename SizeT>
-    struct prime_policy
-    {
-        template <typename Hash, typename T>
-        static inline SizeT apply_hash(Hash const& hf, T const& x) {
-            return hf(x);
-        }
-
-        static inline SizeT to_bucket(SizeT bucket_count, SizeT hash) {
-            return hash % bucket_count;
-        }
-
-        static inline SizeT new_bucket_count(SizeT min) {
-            return boost::unordered::detail::next_prime(min);
-        }
-
-        static inline SizeT prev_bucket_count(SizeT max) {
-            return boost::unordered::detail::prev_prime(max);
-        }
-    };
-
-    template <typename SizeT>
-    struct mix64_policy
-    {
-        template <typename Hash, typename T>
-        static inline SizeT apply_hash(Hash const& hf, T const& x) {
-            SizeT key = hf(x);
-            key = (~key) + (key << 21); // key = (key << 21) - key - 1;
-            key = key ^ (key >> 24);
-            key = (key + (key << 3)) + (key << 8); // key * 265
-            key = key ^ (key >> 14);
-            key = (key + (key << 2)) + (key << 4); // key * 21
-            key = key ^ (key >> 28);
-            key = key + (key << 31);
-            return key;
-        }
-
-        static inline SizeT to_bucket(SizeT bucket_count, SizeT hash) {
-            return hash & (bucket_count - 1);
-        }
-
-        static inline SizeT new_bucket_count(SizeT min) {
-            if (min <= 4) return 4;
-            --min;
-            min |= min >> 1;
-            min |= min >> 2;
-            min |= min >> 4;
-            min |= min >> 8;
-            min |= min >> 16;
-            min |= min >> 32;
-            return min + 1;
-        }
-
-        static inline SizeT prev_bucket_count(SizeT max) {
-            max |= max >> 1;
-            max |= max >> 2;
-            max |= max >> 4;
-            max |= max >> 8;
-            max |= max >> 16;
-            max |= max >> 32;
-            return (max >> 1) + 1;
-        }
-    };
-
-    template <int digits, int radix>
-    struct pick_policy_impl {
-        typedef prime_policy<std::size_t> type;
-    };
-
-    template <>
-    struct pick_policy_impl<64, 2> {
-        typedef mix64_policy<std::size_t> type;
-    };
-
-    template <typename T>
-    struct pick_policy :
-        pick_policy_impl<
-            std::numeric_limits<std::size_t>::digits,
-            std::numeric_limits<std::size_t>::radix> {};
-
-    // While the mix policy is generally faster, the prime policy is a lot
-    // faster when a large number consecutive integers are used, because
-    // there are no collisions. Since that is probably quite common, use
-    // prime policy for integeral types. But not the smaller ones, as they
-    // don't have enough unique values for this to be an issue.
-
-    template <>
-    struct pick_policy<int> {
-        typedef prime_policy<std::size_t> type;
-    };
-
-    template <>
-    struct pick_policy<unsigned int> {
-        typedef prime_policy<std::size_t> type;
-    };
-
-    template <>
-    struct pick_policy<long> {
-        typedef prime_policy<std::size_t> type;
-    };
-
-    template <>
-    struct pick_policy<unsigned long> {
-        typedef prime_policy<std::size_t> type;
-    };
-
-    // TODO: Maybe not if std::size_t is smaller than long long.
-#if !defined(BOOST_NO_LONG_LONG)
-    template <>
-    struct pick_policy<boost::long_long_type> {
-        typedef prime_policy<std::size_t> type;
-    };
-
-    template <>
-    struct pick_policy<boost::ulong_long_type> {
-        typedef prime_policy<std::size_t> type;
-    };
-#endif
+        return count;
+    }
 
     ////////////////////////////////////////////////////////////////////////////
-    // Functions
+    // Constructors and Destructors
 
-    // Assigning and swapping the equality and hash function objects
-    // needs strong exception safety. To implement that normally we'd
-    // require one of them to be known to not throw and the other to
-    // guarantee strong exception safety. Unfortunately they both only
-    // have basic exception safety. So to acheive strong exception
-    // safety we have storage space for two copies, and assign the new
-    // copies to the unused space. Then switch to using that to use
-    // them. This is implemented in 'set_hash_functions' which
-    // atomically assigns the new function objects in a strongly
-    // exception safe manner.
-
-    template <class H, class P, bool NoThrowMoveAssign>
-    class set_hash_functions;
-
-    template <class H, class P>
-    class functions
+    template <class A, class G>
+    inline hash_buckets<A, G>::hash_buckets(
+        node_allocator const& a, std::size_t bucket_count)
+      : buckets_(),
+        bucket_count_(bucket_count),
+        allocators_(a,a)
     {
-    public:
-        static const bool nothrow_move_assignable =
-                boost::is_nothrow_move_assignable<H>::value &&
-                boost::is_nothrow_move_assignable<P>::value;
-        static const bool nothrow_move_constructible =
-                boost::is_nothrow_move_constructible<H>::value &&
-                boost::is_nothrow_move_constructible<P>::value;
+    }
 
-    private:
-        friend class boost::unordered::detail::set_hash_functions<H, P,
-               nothrow_move_assignable>;
-        functions& operator=(functions const&);
-
-        typedef compressed<H, P> function_pair;
-
-        typedef typename boost::aligned_storage<
-            sizeof(function_pair),
-            boost::alignment_of<function_pair>::value>::type aligned_function;
-
-        bool current_; // The currently active functions.
-        aligned_function funcs_[2];
-
-        function_pair const& current() const {
-            return *static_cast<function_pair const*>(
-                static_cast<void const*>(&funcs_[current_]));
-        }
-
-        function_pair& current() {
-            return *static_cast<function_pair*>(
-                static_cast<void*>(&funcs_[current_]));
-        }
-
-        void construct(bool which, H const& hf, P const& eq)
-        {
-            new((void*) &funcs_[which]) function_pair(hf, eq);
-        }
-
-        void construct(bool which, function_pair const& f,
-                boost::unordered::detail::false_type =
-                    boost::unordered::detail::false_type())
-        {
-            new((void*) &funcs_[which]) function_pair(f);
-        }
-        
-        void construct(bool which, function_pair& f,
-                boost::unordered::detail::true_type)
-        {
-            new((void*) &funcs_[which]) function_pair(f,
-                boost::unordered::detail::move_tag());
-        }
-
-        void destroy(bool which)
-        {
-            boost::unordered::detail::func::destroy((function_pair*)(&funcs_[which]));
-        }
-        
-    public:
-
-        typedef boost::unordered::detail::set_hash_functions<H, P,
-                nothrow_move_assignable> set_hash_functions;
-
-        functions(H const& hf, P const& eq)
-            : current_(false)
-        {
-            construct(current_, hf, eq);
-        }
-
-        functions(functions const& bf)
-            : current_(false)
-        {
-            construct(current_, bf.current());
-        }
-
-        functions(functions& bf, boost::unordered::detail::move_tag)
-            : current_(false)
-        {
-            construct(current_, bf.current(),
-                boost::unordered::detail::integral_constant<bool,
-                    nothrow_move_constructible>());
-        }
-
-        ~functions() {
-            this->destroy(current_);
-        }
-
-        H const& hash_function() const {
-            return current().first();
-        }
-
-        P const& key_eq() const {
-            return current().second();
-        }
-    };
-
-    template <class H, class P>
-    class set_hash_functions<H, P, false>
+    template <class A, class G>
+    inline hash_buckets<A, G>::~hash_buckets()
     {
-        set_hash_functions(set_hash_functions const&);
-        set_hash_functions& operator=(set_hash_functions const&);
-
-        typedef functions<H, P> functions_type;
+        if(this->buckets_) { this->delete_buckets(); }
+    }
     
-        functions_type& functions_;
-        bool tmp_functions_;
-
-    public:
-
-        set_hash_functions(functions_type& f, H const& h, P const& p)
-          : functions_(f),
-            tmp_functions_(!f.current_)
-        {
-            f.construct(tmp_functions_, h, p);
-        }
-
-        set_hash_functions(functions_type& f, functions_type const& other)
-          : functions_(f),
-            tmp_functions_(!f.current_)
-        {
-            f.construct(tmp_functions_, other.current());
-        }
-
-        ~set_hash_functions()
-        {
-            functions_.destroy(tmp_functions_);
-        }
-
-        void commit()
-        {
-            functions_.current_ = tmp_functions_;
-            tmp_functions_ = !tmp_functions_;
-        }
-    };
-
-    template <class H, class P>
-    class set_hash_functions<H, P, true>
+    template <class A, class G>
+    inline void hash_buckets<A, G>::create_buckets()
     {
-        set_hash_functions(set_hash_functions const&);
-        set_hash_functions& operator=(set_hash_functions const&);
+        // The array constructor will clean up in the event of an
+        // exception.
+        allocator_array_constructor<bucket_allocator>
+            constructor(bucket_alloc());
 
-        typedef functions<H, P> functions_type;
+        // Creates an extra bucket to act as a sentinel.
+        constructor.construct(bucket(), this->bucket_count_ + 1);
 
-        functions_type& functions_;
-        H hash_;
-        P pred_;
-    
-    public:
+        // Set up the sentinel (node_ptr cast)
+        bucket_ptr sentinel = constructor.get() +
+            static_cast<std::ptrdiff_t>(this->bucket_count_);
+        sentinel->next_ = sentinel;
 
-        set_hash_functions(functions_type& f, H const& h, P const& p) :
-            functions_(f),
-            hash_(h),
-            pred_(p) {}
+        // Only release the buckets once everything is successfully
+        // done.
+        this->buckets_ = constructor.release();
+    }
 
-        set_hash_functions(functions_type& f, functions_type const& other) :
-            functions_(f),
-            hash_(other.hash_function()),
-            pred_(other.key_eq()) {}
-
-        void commit()
-        {
-            functions_.current().first() = boost::move(hash_);
-            functions_.current().second() = boost::move(pred_);
-        }
-    };
-    
     ////////////////////////////////////////////////////////////////////////////
-    // rvalue parameters when type can't be a BOOST_RV_REF(T) parameter
-    // e.g. for int
+    // Constructors and Destructors
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#   define BOOST_UNORDERED_RV_REF(T) BOOST_RV_REF(T)
-#else
-    struct please_ignore_this_overload {
-        typedef please_ignore_this_overload type;
-    };
+    // no throw
+    template <class A, class G>
+    inline void hash_buckets<A, G>::move(hash_buckets& other)
+    {
+        BOOST_ASSERT(node_alloc() == other.node_alloc());
+        if(this->buckets_) { this->delete_buckets(); }
+        this->buckets_ = other.buckets_;
+        this->bucket_count_ = other.bucket_count_;
+        other.buckets_ = bucket_ptr();
+        other.bucket_count_ = 0;
+    }
 
-    template <typename T>
-    struct rv_ref_impl {
-        typedef BOOST_RV_REF(T) type;
-    };
-
-    template <typename T>
-    struct rv_ref :
-        boost::detail::if_true<
-            boost::is_class<T>::value
-        >::BOOST_NESTED_TEMPLATE then <
-            boost::unordered::detail::rv_ref_impl<T>,
-            please_ignore_this_overload
-        >::type
-    {};
-
-#   define BOOST_UNORDERED_RV_REF(T) \
-        typename boost::unordered::detail::rv_ref<T>::type
-#endif
-}}}
+    template <class A, class G>
+    inline void hash_buckets<A, G>::swap(hash_buckets<A, G>& other)
+    {
+        BOOST_ASSERT(node_alloc() == other.node_alloc());
+        std::swap(buckets_, other.buckets_);
+        std::swap(bucket_count_, other.bucket_count_);
+    }
+}}
 
 #endif

include/boost/unordered/detail/extract_key.hpp

@@ -1,5 +1,5 @@
 
-// Copyright (C) 2005-2011 Daniel James
+// Copyright (C) 2005-2009 Daniel James
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -7,15 +7,11 @@
 #define BOOST_UNORDERED_DETAIL_EXTRACT_KEY_HPP_INCLUDED
 
 #include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
-#include <boost/unordered/detail/table.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/unordered/detail/fwd.hpp>
 
 namespace boost {
-namespace unordered {
-namespace detail {
+namespace unordered_detail {
 
     // key extractors
     //
@@ -32,26 +28,13 @@ namespace detail {
         template <class T> no_key(T const&) {}
     };
 
-    template <typename Key, typename T>
-    struct is_key {
-        template <typename T2>
-        static choice1::type test(T2 const&);
-        static choice2::type test(Key const&);
-        
-        enum { value = sizeof(test(boost::unordered::detail::make<T>())) ==
-            sizeof(choice2::type) };
-        
-        typedef typename boost::detail::if_true<value>::
-            BOOST_NESTED_TEMPLATE then<Key const&, no_key>::type type;
-    };
-
     template <class ValueType>
     struct set_extractor
     {
         typedef ValueType value_type;
         typedef ValueType key_type;
 
-        static key_type const& extract(value_type const& v)
+        static key_type const& extract(key_type const& v)
         {
             return v;
         }
@@ -61,38 +44,49 @@ namespace detail {
             return no_key();
         }
         
+#if defined(BOOST_UNORDERED_STD_FORWARD)
+        template <class... Args>
+        static no_key extract(Args const&...)
+        {
+            return no_key();
+        }
+
+#else
         template <class Arg>
         static no_key extract(Arg const&)
         {
             return no_key();
         }
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template <class Arg1, class Arg2, class... Args>
-        static no_key extract(Arg1 const&, Arg2 const&, Args const&...)
-        {
-            return no_key();
-        }
-#else
-        template <class Arg1, class Arg2>
-        static no_key extract(Arg1 const&, Arg2 const&)
+        template <class Arg>
+        static no_key extract(Arg const&, Arg const&)
         {
             return no_key();
         }
 #endif
+
+        static bool compare_mapped(value_type const&, value_type const&)
+        {
+            return true;
+        }
     };
 
     template <class Key, class ValueType>
     struct map_extractor
     {
         typedef ValueType value_type;
-        typedef typename boost::remove_const<Key>::type key_type;
+        typedef BOOST_DEDUCED_TYPENAME boost::remove_const<Key>::type key_type;
 
         static key_type const& extract(value_type const& v)
         {
             return v.first;
         }
             
+        static key_type const& extract(key_type const& v)
+        {
+            return v;
+        }
+
         template <class Second>
         static key_type const& extract(std::pair<key_type, Second> const& v)
         {
@@ -106,6 +100,20 @@ namespace detail {
             return v.first;
         }
 
+#if defined(BOOST_UNORDERED_STD_FORWARD)
+        template <class Arg1, class... Args>
+        static key_type const& extract(key_type const& k,
+            Arg1 const&, Args const&...)
+        {
+            return k;
+        }
+
+        template <class... Args>
+        static no_key extract(Args const&...)
+        {
+            return no_key();
+        }
+#else
         template <class Arg1>
         static key_type const& extract(key_type const& k, Arg1 const&)
         {
@@ -123,66 +131,18 @@ namespace detail {
             return no_key();
         }
 
-        template <class Arg1, class Arg2>
-        static no_key extract(Arg1 const&, Arg2 const&)
-        {
-            return no_key();
-        }
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template <class Arg1, class Arg2, class Arg3, class... Args>
-        static no_key extract(Arg1 const&, Arg2 const&, Arg3 const&,
-                Args const&...)
+        template <class Arg, class Arg1>
+        static no_key extract(Arg const&, Arg1 const&)
         {
             return no_key();
         }
 #endif
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                          \
-        template <typename T2>                                              \
-        static no_key extract(boost::unordered::piecewise_construct_t,      \
-                namespace_ tuple<> const&, T2 const&)                       \
-        {                                                                   \
-            return no_key();                                                \
-        }                                                                   \
-                                                                            \
-        template <typename T, typename T2>                                  \
-        static typename is_key<key_type, T>::type                           \
-            extract(boost::unordered::piecewise_construct_t,                \
-                namespace_ tuple<T> const& k, T2 const&)                    \
-        {                                                                   \
-            return typename is_key<key_type, T>::type(                      \
-                namespace_ get<0>(k));                                      \
+        static bool compare_mapped(value_type const& x, value_type const& y)
+        {
+            return x.second == y.second;
         }
-
-#else
-
-#define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_)                          \
-        static no_key extract(boost::unordered::piecewise_construct_t,      \
-                namespace_ tuple<> const&)                                  \
-        {                                                                   \
-            return no_key();                                                \
-        }                                                                   \
-                                                                            \
-        template <typename T>                                               \
-        static typename is_key<key_type, T>::type                           \
-            extract(boost::unordered::piecewise_construct_t,                \
-                namespace_ tuple<T> const& k)                               \
-        {                                                                   \
-            return typename is_key<key_type, T>::type(                      \
-                namespace_ get<0>(k));                                      \
-        }
-
-#endif
-
-BOOST_UNORDERED_KEY_FROM_TUPLE(boost::)
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
-BOOST_UNORDERED_KEY_FROM_TUPLE(std::)
-#endif
     };
-}}}
+}}
 
 #endif

include/boost/unordered/detail/fwd.hpp

@@ -1,57 +1,932 @@
 
-// Copyright (C) 2008-2016 Daniel James.
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2009 Daniel James
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_UNORDERED_FWD_HPP_INCLUDED
-#define BOOST_UNORDERED_FWD_HPP_INCLUDED
+// This contains the basic data structure, apart from the actual values. There's
+// no construction or deconstruction here. So this only depends on the pointer
+// type.
+
+#ifndef BOOST_UNORDERED_DETAIL_FWD_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_FWD_HPP_INCLUDED
 
 #include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
+#include <boost/iterator.hpp>
+#include <boost/compressed_pair.hpp>
+#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/unordered/detail/allocator_helpers.hpp>
+#include <algorithm>
 
-#if defined(BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT)
-// Already defined.
-#elif defined(BOOST_LIBSTDCXX11)
-// https://github.com/gcc-mirror/gcc/blob/gcc-4_6-branch/libstdc++-v3/include/bits/stl_pair.h#L70
-#   if BOOST_LIBSTDCXX_VERSION > 40600
-#       define BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT 1
-#   endif
-#elif defined(_LIBCPP_VERSION)
-// https://github.com/llvm-mirror/libcxx/blob/release_30/include/utility#L206
-#   if LIBCPP_VERSION >= 3000
-#       define BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT 1
-#   endif
-#elif defined(BOOST_MSVC)
-// Apparently C++11 standard supported in Visual Studio 2012
-// https://msdn.microsoft.com/en-us/library/hh567368.aspx#stl
-// 2012 = VC+11 = BOOST_MSVC 1700 Hopefully!
-#   if BOOST_MSVC >= 1700
-#       define BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT 1
+// This header defines most of the classes used to implement the unordered
+// containers. It doesn't include the insert methods as they require a lot
+// of preprocessor metaprogramming - they are in unique.hpp and equivalent.hpp.
+
+// Template parameters:
+//
+// H = Hash Function
+// P = Predicate
+// A = Value Allocator
+// G = Bucket group policy, 'grouped' or 'ungrouped'
+// E = Key Extractor
+
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#   if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+        // STLport doesn't have std::forward.
+#   else
+#       define BOOST_UNORDERED_STD_FORWARD
 #   endif
 #endif
 
-#if !defined(BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT)
-#define BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT 0
+#if !defined(BOOST_UNORDERED_EMPLACE_LIMIT)
+#define BOOST_UNORDERED_EMPLACE_LIMIT 10
 #endif
 
-#if BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
-#include <utility>
-#endif
+#if !defined(BOOST_UNORDERED_STD_FORWARD)
 
-namespace boost
-{
-namespace unordered
-{
-#if BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
-    using std::piecewise_construct_t;
-    using std::piecewise_construct;
-#else
-    struct piecewise_construct_t {};
-    const piecewise_construct_t piecewise_construct = piecewise_construct_t();
+#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, num_params) \
+    BOOST_PP_ENUM_PARAMS_Z(z, num_params, class Arg)
+#define BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params) \
+    BOOST_PP_ENUM_BINARY_PARAMS_Z(z, num_params, Arg, const& arg)
+#define BOOST_UNORDERED_CALL_PARAMS(z, num_params) \
+    BOOST_PP_ENUM_PARAMS_Z(z, num_params, arg)
+
 #endif
-}
-}
+
+namespace boost { namespace unordered_detail {
+
+    static const float minimum_max_load_factor = 1e-3f;
+    static const std::size_t default_bucket_count = 11;
+    struct move_tag {};
+
+    template <class T> class hash_unique_table;
+    template <class T> class hash_equivalent_table;
+    template <class Alloc, class Grouped>
+    class hash_node_constructor;
+    template <class ValueType>
+    struct set_extractor;
+    template <class Key, class ValueType>
+    struct map_extractor;
+    struct no_key;
+
+    // Explicitly call a destructor
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4100) // unreferenced formal parameter
+#endif
+
+    template <class T>
+    inline void destroy(T* x) {
+        x->~T();
+    }
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+    ////////////////////////////////////////////////////////////////////////////
+    //
+    // This section implements buckets and nodes. Here's a rough
+    // inheritance diagram, to show how they pull together.
+    //
+    // For unordered_set/unordered_map:
+    //
+    // hash_bucket<A>
+    //     |
+    // ungrouped_node_base<A>     value_base<A::value_type>
+    //     |                            |
+    //     +--------------+-------------+
+    //                    |
+    //         hash_node<A, ungrouped>
+    //
+    // For unordered_multiset/unordered_multimap:
+    //
+    // hash_bucket<A>
+    //     |
+    // grouped_node_base<A>       value_base<A::value_type>
+    //     |                            |
+    //     +--------------+-------------+
+    //                    |
+    //         hash_node<A, grouped>
+
+    // hash_bucket
+    //
+    // hash_bucket is used for both the buckets and as a base class for
+    // nodes. By using 'bucket_ptr' for 'node_ptr', 'next_' can point
+    // to either a bucket or a node. This is used later to implement a
+    // sentinel at the end of the bucket array.
+    
+    template <class A>
+    class hash_bucket
+    {
+        hash_bucket& operator=(hash_bucket const&);
+    public:
+        typedef hash_bucket<A> bucket;
+        typedef BOOST_DEDUCED_TYPENAME
+            boost::unordered_detail::rebind_wrap<A, bucket>::type
+            bucket_allocator;
+        typedef BOOST_DEDUCED_TYPENAME bucket_allocator::pointer bucket_ptr;
+        typedef bucket_ptr node_ptr;
+    
+        node_ptr next_;
+
+        hash_bucket() : next_() {}
+    };
+
+    // In containers with equivalent keys (unordered_multimap and
+    // unordered_multiset) equivalent nodes are grouped together, in
+    // containers with unique keys (unordered_map and unordered_set)
+    // individual nodes are treated as groups of one. The following two
+    // classes implement the data structure.
+
+    // This is used for containers with unique keys. There are no groups
+    // so it doesn't add any extra members, and just treats individual
+    // nodes as groups of one.
+
+    template <class A>
+    struct ungrouped_node_base : hash_bucket<A> {
+        typedef hash_bucket<A> bucket;
+        typedef BOOST_DEDUCED_TYPENAME bucket::bucket_ptr bucket_ptr;
+        typedef BOOST_DEDUCED_TYPENAME bucket::node_ptr node_ptr;
+
+        ungrouped_node_base() : bucket() {}
+        static inline node_ptr& next_group(node_ptr ptr);
+        static inline std::size_t group_count(node_ptr ptr);
+        static inline void add_to_bucket(node_ptr n, bucket& b);
+        static inline void add_after_node(node_ptr n, node_ptr position);
+        static void unlink_node(bucket& b, node_ptr n);
+        static void unlink_nodes(bucket& b, node_ptr begin, node_ptr end);
+        static void unlink_nodes(bucket& b, node_ptr end);
+    };
+
+    // This is used for containers with equivalent keys. It implements a
+    // circular list running in the opposite direction to the linked
+    // list through the nodes.
+
+    template <class A>
+    struct grouped_node_base : hash_bucket<A>
+    {
+        typedef hash_bucket<A> bucket;
+        typedef BOOST_DEDUCED_TYPENAME bucket::bucket_ptr bucket_ptr;
+        typedef BOOST_DEDUCED_TYPENAME bucket::node_ptr node_ptr;
+
+        node_ptr group_prev_;
+
+        grouped_node_base() : bucket(), group_prev_() {}
+        static inline node_ptr& next_group(node_ptr ptr);
+        static inline node_ptr first_in_group(node_ptr n);
+        static inline std::size_t group_count(node_ptr ptr);
+        static inline void add_to_bucket(node_ptr n, bucket& b);
+        static inline void add_after_node(node_ptr n, node_ptr position);
+        static void unlink_node(bucket& b, node_ptr n);
+        static void unlink_nodes(bucket& b, node_ptr begin, node_ptr end);
+        static void unlink_nodes(bucket& b, node_ptr end);
+
+    private:
+        static inline node_ptr split_group(node_ptr split);
+        static inline grouped_node_base& get(node_ptr ptr) {
+            return static_cast<grouped_node_base&>(*ptr);
+        }
+    };
+
+    // These two classes implement an easy way to pass around the node
+    // group policy classes without the messy template parameters.
+    // Whenever you see the template parameter 'G' it's one of these.
+
+    struct ungrouped
+    {
+        template <class A>
+        struct base {
+            typedef ungrouped_node_base<A> type;
+        };
+    };
+
+    struct grouped
+    {
+        template <class A>
+        struct base {
+            typedef grouped_node_base<A> type;
+        };
+    };
+
+    // The space used to store values in a node.
+
+    template <class ValueType>
+    struct value_base
+    {
+        typedef ValueType value_type;
+        BOOST_DEDUCED_TYPENAME boost::aligned_storage<
+            sizeof(value_type),
+            ::boost::alignment_of<value_type>::value>::type data_;
+
+        void* address() {
+            return this;
+        }
+        value_type& value() {
+            return *(ValueType*) this;
+        }
+        value_type* value_ptr() {
+            return (ValueType*) this;
+        }
+    private:
+        value_base& operator=(value_base const&);
+    };
+
+    // Node
+    
+    template <class A, class G>
+    class hash_node :
+        public G::BOOST_NESTED_TEMPLATE base<A>::type,
+        public value_base<BOOST_DEDUCED_TYPENAME A::value_type>
+    {
+    public:
+        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
+        typedef BOOST_DEDUCED_TYPENAME hash_bucket<A>::node_ptr node_ptr;
+
+        static value_type& get_value(node_ptr p) {
+            return static_cast<hash_node&>(*p).value();
+        }
+        static value_type* get_value_ptr(node_ptr p) {
+            return static_cast<hash_node&>(*p).value_ptr();
+        }
+    private:
+        hash_node& operator=(hash_node const&);
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    //
+    // Iterator Base
+    //
+    // This is the iterator used internally, the external iterators are
+    // provided by lightweight wrappers (hash_iterator and
+    // hast_const_iterator) which provide the full iterator interface.
+
+    template <class A, class G>
+    class hash_iterator_base
+    {
+    public:
+        typedef A value_allocator;
+        typedef hash_bucket<A> bucket;
+        typedef hash_node<A, G> node;
+        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
+        typedef BOOST_DEDUCED_TYPENAME bucket::bucket_ptr bucket_ptr;
+        typedef BOOST_DEDUCED_TYPENAME bucket::node_ptr node_ptr;
+
+        bucket_ptr bucket_;
+        node_ptr node_;
+
+        hash_iterator_base() : bucket_(), node_() {}
+        explicit hash_iterator_base(bucket_ptr b)
+          : bucket_(b),
+            node_(b ? b->next_ : node_ptr()) {}
+        hash_iterator_base(bucket_ptr b, node_ptr n)
+          : bucket_(b),
+            node_(n) {}
+        
+        bool operator==(hash_iterator_base const& x) const {
+            return node_ == x.node_; }
+        bool operator!=(hash_iterator_base const& x) const {
+            return node_ != x.node_; }
+        value_type& operator*() const {
+            return node::get_value(node_);
+        }
+    
+        void increment_bucket(node_ptr n) {
+            while(!n) {
+                ++bucket_;
+                n = bucket_->next_;
+            }
+            node_ = bucket_ == n ? node_ptr() : n;
+        }
+
+        void increment() {
+            increment_bucket(node_->next_);
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    //
+    // Now the main data structure:
+    //
+    // hash_buckets<A, G>     hash_buffered_functions<H, P>
+    //       |                            |
+    //       +-------------+--------------+
+    //                     |
+    //                hash_table<T>
+    //
+    // T is a class which contains typedefs for all the types we need.
+    
+    // hash_buckets
+    //
+    // This is responsible for allocating and deallocating buckets and nodes.
+    //
+    // Notes:
+    // 1. For the sake exception safety the consturctors don't allocate
+    //    anything.
+    // 2. It's the callers responsibility to allocate the buckets before calling
+    //    any of the methods (other than getters and setters).
+
+    template <class A, class G>
+    class hash_buckets
+    {
+        hash_buckets(hash_buckets const&);
+        hash_buckets& operator=(hash_buckets const&);
+    public:
+        // Types
+
+        typedef A value_allocator;
+        typedef hash_bucket<A> bucket;
+        typedef hash_iterator_base<A, G> iterator_base;
+        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
+        typedef BOOST_DEDUCED_TYPENAME iterator_base::node node;
+
+        typedef BOOST_DEDUCED_TYPENAME bucket::bucket_allocator
+            bucket_allocator;
+        typedef BOOST_DEDUCED_TYPENAME bucket::bucket_ptr bucket_ptr;
+        typedef BOOST_DEDUCED_TYPENAME bucket::node_ptr node_ptr;
+
+        typedef BOOST_DEDUCED_TYPENAME rebind_wrap<value_allocator, node>::type
+            node_allocator;
+        typedef BOOST_DEDUCED_TYPENAME node_allocator::pointer real_node_ptr;
+
+        // Members
+
+        bucket_ptr buckets_;
+        std::size_t bucket_count_;
+        boost::compressed_pair<bucket_allocator, node_allocator> allocators_;
+        
+        // Data access
+
+        bucket_allocator const& bucket_alloc() const {
+            return allocators_.first(); }
+        node_allocator const& node_alloc() const {
+            return allocators_.second(); }
+        bucket_allocator& bucket_alloc() {
+            return allocators_.first(); }
+        node_allocator& node_alloc() {
+            return allocators_.second(); }
+        std::size_t max_bucket_count() const;
+
+        // Constructors
+
+        hash_buckets(node_allocator const& a, std::size_t n);
+        void create_buckets();
+        ~hash_buckets();
+        
+        // no throw
+        void swap(hash_buckets& other);
+        void move(hash_buckets& other);
+
+        // For the remaining functions, buckets_ must not be null.
+        
+        bucket_ptr get_bucket(std::size_t n) const;
+        bucket_ptr bucket_ptr_from_hash(std::size_t hashed) const;
+        std::size_t bucket_size(std::size_t index) const;
+        node_ptr bucket_begin(std::size_t n) const;
+
+        // Alloc/Dealloc
+        
+        void delete_node(node_ptr);
+
+        // 
+        void delete_buckets();
+        void clear_bucket(bucket_ptr);
+        std::size_t delete_nodes(node_ptr begin, node_ptr end);
+        std::size_t delete_to_bucket_end(node_ptr begin);
+    };
+
+    // Assigning and swapping the equality and hash function objects
+    // needs strong exception safety. To implement that normally we'd
+    // require one of them to be known to not throw and the other to
+    // guarantee strong exception safety. Unfortunately they both only
+    // have basic exception safety. So to acheive strong exception
+    // safety we have storage space for two copies, and assign the new
+    // copies to the unused space. Then switch to using that to use
+    // them. This is implemented in 'set_hash_functions' which
+    // atomically assigns the new function objects in a strongly
+    // exception safe manner.
+
+    template <class H, class P> class set_hash_functions;
+
+    template <class H, class P>
+    class hash_buffered_functions
+    {
+        friend class set_hash_functions<H, P>;
+        hash_buffered_functions& operator=(hash_buffered_functions const&);
+
+        typedef boost::compressed_pair<H, P> function_pair;
+        typedef BOOST_DEDUCED_TYPENAME boost::aligned_storage<
+            sizeof(function_pair),
+            ::boost::alignment_of<function_pair>::value>::type aligned_function;
+
+        bool current_; // The currently active functions.
+        aligned_function funcs_[2];
+
+        function_pair const& current() const {
+            return *static_cast<function_pair const*>(
+                static_cast<void const*>(&funcs_[current_]));
+        }
+
+        void construct(bool which, H const& hf, P const& eq)
+        {
+            new((void*) &funcs_[which]) function_pair(hf, eq);
+        }
+
+        void construct(bool which, function_pair const& f)
+        {
+            new((void*) &funcs_[which]) function_pair(f);
+        }
+        
+        void destroy(bool which)
+        {
+            boost::unordered_detail::destroy((function_pair*)(&funcs_[which]));
+        }
+        
+    public:
+
+        hash_buffered_functions(H const& hf, P const& eq)
+            : current_(false)
+        {
+            construct(current_, hf, eq);
+        }
+
+        hash_buffered_functions(hash_buffered_functions const& bf)
+            : current_(false)
+        {
+            construct(current_, bf.current());
+        }
+
+        ~hash_buffered_functions() {
+            destroy(current_);
+        }
+
+        H const& hash_function() const {
+            return current().first();
+        }
+
+        P const& key_eq() const {
+            return current().second();
+        }
+    };
+    
+    template <class H, class P>
+    class set_hash_functions
+    {
+        set_hash_functions(set_hash_functions const&);
+        set_hash_functions& operator=(set_hash_functions const&);
+    
+        typedef hash_buffered_functions<H, P> buffered_functions;
+        buffered_functions& buffered_functions_;
+        bool tmp_functions_;
+
+    public:
+
+        set_hash_functions(buffered_functions& f, H const& h, P const& p)
+          : buffered_functions_(f),
+            tmp_functions_(!f.current_)
+        {
+            f.construct(tmp_functions_, h, p);
+        }
+
+        set_hash_functions(buffered_functions& f,
+            buffered_functions const& other)
+          : buffered_functions_(f),
+            tmp_functions_(!f.current_)
+        {
+            f.construct(tmp_functions_, other.current());
+        }
+
+        ~set_hash_functions()
+        {
+            buffered_functions_.destroy(tmp_functions_);
+        }
+
+        void commit()
+        {
+            buffered_functions_.current_ = tmp_functions_;
+            tmp_functions_ = !tmp_functions_;
+        }
+    };
+
+    // This implements almost all of the required functionality, apart
+    // from some things that are specific to containers with unique and
+    // equivalent keys which is implemented in hash_unique_table and
+    // hash_equivalent_table. See unique.hpp and equivalent.hpp for
+    // their declaration and implementation.
+
+    template <class T>
+    class hash_table : public T::buckets, public T::buffered_functions
+    {
+        hash_table(hash_table const&);
+    public:
+        typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
+        typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
+        typedef BOOST_DEDUCED_TYPENAME T::value_allocator value_allocator;
+        typedef BOOST_DEDUCED_TYPENAME T::key_type key_type;
+        typedef BOOST_DEDUCED_TYPENAME T::value_type value_type;
+        typedef BOOST_DEDUCED_TYPENAME T::buffered_functions base;
+        typedef BOOST_DEDUCED_TYPENAME T::buckets buckets;
+        typedef BOOST_DEDUCED_TYPENAME T::extractor extractor;
+        typedef BOOST_DEDUCED_TYPENAME T::node_constructor node_constructor;
+
+        typedef BOOST_DEDUCED_TYPENAME T::node node;
+        typedef BOOST_DEDUCED_TYPENAME T::bucket bucket;
+        typedef BOOST_DEDUCED_TYPENAME T::node_ptr node_ptr;
+        typedef BOOST_DEDUCED_TYPENAME T::bucket_ptr bucket_ptr;
+        typedef BOOST_DEDUCED_TYPENAME T::iterator_base iterator_base;
+        typedef BOOST_DEDUCED_TYPENAME T::node_allocator node_allocator;
+        typedef BOOST_DEDUCED_TYPENAME T::iterator_pair iterator_pair;
+
+        // Members
+        
+        std::size_t size_;
+        float mlf_;
+        // Cached data - invalid if !this->buckets_
+        bucket_ptr cached_begin_bucket_;
+        std::size_t max_load_;
+
+        // Helper methods
+
+        key_type const& get_key(value_type const& v) const {
+            return extractor::extract(v);
+        }
+        key_type const& get_key_from_ptr(node_ptr n) const {
+            return extractor::extract(node::get_value(n));
+        }
+        bool equal(key_type const& k, value_type const& v) const;
+        template <class Key, class Pred>
+        node_ptr find_iterator(bucket_ptr bucket, Key const& k,
+            Pred const&) const;
+        node_ptr find_iterator(bucket_ptr bucket, key_type const& k) const;
+        node_ptr find_iterator(key_type const& k) const;
+        node_ptr* find_for_erase(bucket_ptr bucket, key_type const& k) const;
+        
+        // Load methods
+
+        std::size_t max_size() const;
+        std::size_t bucket_index(key_type const& k) const;
+        void max_load_factor(float z);
+        std::size_t min_buckets_for_size(std::size_t n) const;
+        std::size_t calculate_max_load();
+
+        // Constructors
+
+        hash_table(std::size_t n, hasher const& hf, key_equal const& eq,
+            node_allocator const& a);
+        hash_table(hash_table const& x, node_allocator const& a);
+        hash_table(hash_table& x, move_tag m);
+        hash_table(hash_table& x, node_allocator const& a, move_tag m);
+        ~hash_table() {}
+        hash_table& operator=(hash_table const&);
+
+        // Iterators
+
+        iterator_base begin() const {
+            return this->size_ ?
+                iterator_base(this->cached_begin_bucket_) :
+                iterator_base();
+        }
+        iterator_base end() const {
+            return iterator_base();
+        }
+
+        // Swap & Move
+
+        void swap(hash_table& x);
+        void fast_swap(hash_table& other);
+        void slow_swap(hash_table& other);
+        void partial_swap(hash_table& other);
+        void move(hash_table& x);
+
+        // Reserve and rehash
+
+        void create_for_insert(std::size_t n);
+        bool reserve_for_insert(std::size_t n);
+        void rehash(std::size_t n);
+        void rehash_impl(std::size_t n);
+
+        // Move/copy buckets
+
+        void move_buckets_to(buckets& dst);
+        void copy_buckets_to(buckets& dst) const;
+
+        // Misc. key methods
+
+        std::size_t count(key_type const& k) const;
+        iterator_base find(key_type const& k) const;
+        template <class Key, class Hash, class Pred>
+        iterator_base find(Key const& k, Hash const& h, Pred const& eq) const;
+        value_type& at(key_type const& k) const;
+        iterator_pair equal_range(key_type const& k) const;
+
+        // Erase
+        //
+        // no throw
+
+        void clear();
+        std::size_t erase_key(key_type const& k);
+        iterator_base erase_return_iterator(iterator_base r);
+        void erase(iterator_base r);
+        std::size_t erase_group(node_ptr* it, bucket_ptr bucket);
+        iterator_base erase_range(iterator_base r1, iterator_base r2);
+
+        // recompute_begin_bucket
+
+        void init_buckets();
+
+        // After an erase cached_begin_bucket_ might be left pointing to
+        // an empty bucket, so this is called to update it
+        //
+        // no throw
+
+        void recompute_begin_bucket(bucket_ptr b);
+
+        // This is called when a range has been erased
+        //
+        // no throw
+
+        void recompute_begin_bucket(bucket_ptr b1, bucket_ptr b2);
+        
+        // no throw
+        float load_factor() const;
+        
+        iterator_base emplace_empty_impl_with_node(
+            node_constructor&, std::size_t);
+    };
+
+    ///////////////////////////////////////////////////////////////////
+    //
+    // Iterators
+
+    // iterator_access is used to access the internal iterator without
+    // making it publicly available.
+
+    class iterator_access
+    {
+    public:
+        template <class Iterator>
+        static BOOST_DEDUCED_TYPENAME Iterator::base const&
+            get(Iterator const& it)
+        {
+            return it.base_;
+        }
+    };
+
+    template <class A, class G> class hash_iterator;
+    template <class A, class G> class hash_const_iterator;
+    template <class A, class G> class hash_local_iterator;
+    template <class A, class G> class hash_const_local_iterator;
+
+    // Local Iterators
+    //
+    // all no throw
+
+    template <class A, class G>
+    class hash_local_iterator
+        : public boost::iterator <
+            std::forward_iterator_tag,
+            BOOST_DEDUCED_TYPENAME A::value_type,
+            std::ptrdiff_t,
+            BOOST_DEDUCED_TYPENAME A::pointer,
+            BOOST_DEDUCED_TYPENAME A::reference>
+    {
+    public:
+        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
+
+    private:
+        typedef hash_buckets<A, G> buckets;
+        typedef BOOST_DEDUCED_TYPENAME buckets::node_ptr node_ptr;
+        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
+        typedef hash_const_local_iterator<A, G> const_local_iterator;
+
+        friend class hash_const_local_iterator<A, G>;
+        node_ptr ptr_;
+
+    public:
+        hash_local_iterator() : ptr_() {}
+        explicit hash_local_iterator(node_ptr x) : ptr_(x) {}
+        BOOST_DEDUCED_TYPENAME A::reference operator*() const {
+            return node::get_value(ptr_);
+        }
+        value_type* operator->() const {
+            return node::get_value_ptr(ptr_);
+        }
+        hash_local_iterator& operator++() {
+            ptr_ = ptr_->next_; return *this;
+        }
+        hash_local_iterator operator++(int) {
+            hash_local_iterator tmp(ptr_); ptr_ = ptr_->next_; return tmp; }
+        bool operator==(hash_local_iterator x) const {
+            return ptr_ == x.ptr_;
+        }
+        bool operator==(const_local_iterator x) const {
+            return ptr_ == x.ptr_;
+        }
+        bool operator!=(hash_local_iterator x) const {
+            return ptr_ != x.ptr_;
+        }
+        bool operator!=(const_local_iterator x) const {
+            return ptr_ != x.ptr_;
+        }
+    };
+
+    template <class A, class G>
+    class hash_const_local_iterator
+        : public boost::iterator <
+            std::forward_iterator_tag,
+            BOOST_DEDUCED_TYPENAME A::value_type,
+            std::ptrdiff_t,
+            BOOST_DEDUCED_TYPENAME A::const_pointer,
+            BOOST_DEDUCED_TYPENAME A::const_reference >
+    {
+    public:
+        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
+
+    private:
+        typedef hash_buckets<A, G> buckets;
+        typedef BOOST_DEDUCED_TYPENAME buckets::node_ptr ptr;
+        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
+        typedef hash_local_iterator<A, G> local_iterator;
+        friend class hash_local_iterator<A, G>;
+        ptr ptr_;
+
+    public:
+        hash_const_local_iterator() : ptr_() {}
+        explicit hash_const_local_iterator(ptr x) : ptr_(x) {}
+        hash_const_local_iterator(local_iterator x) : ptr_(x.ptr_) {}
+        BOOST_DEDUCED_TYPENAME A::const_reference
+            operator*() const {
+            return node::get_value(ptr_);
+        }
+        value_type const* operator->() const {
+            return node::get_value_ptr(ptr_);
+        }
+        hash_const_local_iterator& operator++() {
+            ptr_ = ptr_->next_; return *this;
+        }
+        hash_const_local_iterator operator++(int) {
+            hash_const_local_iterator tmp(ptr_); ptr_ = ptr_->next_; return tmp;
+        }
+        bool operator==(local_iterator x) const {
+            return ptr_ == x.ptr_;
+        }
+        bool operator==(hash_const_local_iterator x) const {
+            return ptr_ == x.ptr_;
+        }
+        bool operator!=(local_iterator x) const {
+            return ptr_ != x.ptr_;
+        }
+        bool operator!=(hash_const_local_iterator x) const {
+            return ptr_ != x.ptr_;
+        }
+    };
+
+    // Iterators
+    //
+    // all no throw
+
+
+    template <class A, class G>
+    class hash_iterator
+        : public boost::iterator <
+            std::forward_iterator_tag,
+            BOOST_DEDUCED_TYPENAME A::value_type,
+            std::ptrdiff_t,
+            BOOST_DEDUCED_TYPENAME A::pointer,
+            BOOST_DEDUCED_TYPENAME A::reference >
+    {
+    public:
+        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
+
+    private:
+        typedef hash_buckets<A, G> buckets;
+        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
+        typedef BOOST_DEDUCED_TYPENAME buckets::iterator_base base;
+        typedef hash_const_iterator<A, G> const_iterator;
+        friend class hash_const_iterator<A, G>;
+        base base_;
+
+    public:
+
+        hash_iterator() : base_() {}
+        explicit hash_iterator(base const& x) : base_(x) {}
+        BOOST_DEDUCED_TYPENAME A::reference operator*() const {
+            return *base_;
+        }
+        value_type* operator->() const {
+            return &*base_;
+        }
+        hash_iterator& operator++() {
+            base_.increment(); return *this;
+        }
+        hash_iterator operator++(int) {
+            hash_iterator tmp(base_); base_.increment(); return tmp;
+        }
+        bool operator==(hash_iterator const& x) const {
+            return base_ == x.base_;
+        }
+        bool operator==(const_iterator const& x) const {
+            return base_ == x.base_;
+        }
+        bool operator!=(hash_iterator const& x) const {
+            return base_ != x.base_;
+        }
+        bool operator!=(const_iterator const& x) const {
+            return base_ != x.base_;
+        }
+    };
+
+    template <class A, class G>
+    class hash_const_iterator
+        : public boost::iterator <
+            std::forward_iterator_tag,
+            BOOST_DEDUCED_TYPENAME A::value_type,
+            std::ptrdiff_t,
+            BOOST_DEDUCED_TYPENAME A::const_pointer,
+            BOOST_DEDUCED_TYPENAME A::const_reference >
+    {
+    public:
+        typedef BOOST_DEDUCED_TYPENAME A::value_type value_type;
+
+    private:
+        typedef hash_buckets<A, G> buckets;
+        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
+        typedef BOOST_DEDUCED_TYPENAME buckets::iterator_base base;
+        typedef hash_iterator<A, G> iterator;
+        friend class hash_iterator<A, G>;
+        friend class iterator_access;
+        base base_;
+
+    public:
+
+        hash_const_iterator() : base_() {}
+        explicit hash_const_iterator(base const& x) : base_(x) {}
+        hash_const_iterator(iterator const& x) : base_(x.base_) {}
+        BOOST_DEDUCED_TYPENAME A::const_reference operator*() const {
+            return *base_;
+        }
+        value_type const* operator->() const {
+            return &*base_;
+        }
+        hash_const_iterator& operator++() {
+            base_.increment(); return *this;
+        }
+        hash_const_iterator operator++(int) {
+            hash_const_iterator tmp(base_); base_.increment(); return tmp;
+        }
+        bool operator==(iterator const& x) const {
+            return base_ == x.base_;
+        }
+        bool operator==(hash_const_iterator const& x) const {
+            return base_ == x.base_;
+        }
+        bool operator!=(iterator const& x) const {
+            return base_ != x.base_;
+        }
+        bool operator!=(hash_const_iterator const& x) const {
+            return base_ != x.base_;
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    //
+    // types
+    //
+    // This is used to convieniently pass around a container's typedefs
+    // without having 7 template parameters.
+
+    template <class K, class V, class H, class P, class A, class E, class G>
+    struct types
+    {
+    public:
+        typedef K key_type;
+        typedef V value_type;
+        typedef H hasher;
+        typedef P key_equal;
+        typedef A value_allocator;
+        typedef E extractor;
+        typedef G group_type;
+        
+        typedef hash_node_constructor<value_allocator, group_type>
+            node_constructor;
+        typedef hash_buckets<value_allocator, group_type> buckets;
+        typedef hash_buffered_functions<hasher, key_equal> buffered_functions;
+
+        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
+        typedef BOOST_DEDUCED_TYPENAME buckets::bucket bucket;
+        typedef BOOST_DEDUCED_TYPENAME buckets::node_ptr node_ptr;
+        typedef BOOST_DEDUCED_TYPENAME buckets::bucket_ptr bucket_ptr;
+        typedef BOOST_DEDUCED_TYPENAME buckets::iterator_base iterator_base;
+        typedef BOOST_DEDUCED_TYPENAME buckets::node_allocator node_allocator;
+
+        typedef std::pair<iterator_base, iterator_base> iterator_pair;
+    };
+}}
 
 #endif

include/boost/unordered/detail/map.hpp

@@ -1,79 +0,0 @@
-
-// Copyright (C) 2005-2016 Daniel James
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/unordered/unordered_map_fwd.hpp>
-#include <boost/unordered/detail/equivalent.hpp>
-#include <boost/unordered/detail/unique.hpp>
-
-namespace boost { namespace unordered { namespace detail {
-    template <typename A, typename K, typename M, typename H, typename P>
-    struct map
-    {
-        typedef boost::unordered::detail::map<A, K, M, H, P> types;
-
-        typedef A allocator;
-        typedef std::pair<K const, M> value_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef K key_type;
-
-        typedef boost::unordered::detail::allocator_traits<allocator>
-            traits;
-        typedef boost::unordered::detail::pick_node<allocator, value_type> pick;
-        typedef typename pick::node node;
-        typedef typename pick::bucket bucket;
-        typedef typename pick::link_pointer link_pointer;
-
-        typedef boost::unordered::detail::table_impl<types> table;
-        typedef boost::unordered::detail::map_extractor<key_type, value_type>
-            extractor;
-
-        typedef typename boost::unordered::detail::pick_policy<K>::type policy;
-
-        typedef boost::unordered::iterator_detail::
-            iterator<node> iterator;
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> c_iterator;
-        typedef boost::unordered::iterator_detail::
-            l_iterator<node, policy> l_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> cl_iterator;
-    };
-
-    template <typename A, typename K, typename M, typename H, typename P>
-    struct multimap
-    {
-        typedef boost::unordered::detail::multimap<A, K, M, H, P> types;
-
-        typedef A allocator;
-        typedef std::pair<K const, M> value_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef K key_type;
-
-        typedef boost::unordered::detail::allocator_traits<allocator> traits;
-        typedef boost::unordered::detail::pick_grouped_node<allocator,
-                value_type> pick;
-        typedef typename pick::node node;
-        typedef typename pick::bucket bucket;
-        typedef typename pick::link_pointer link_pointer;
-
-        typedef boost::unordered::detail::grouped_table_impl<types> table;
-        typedef boost::unordered::detail::map_extractor<key_type, value_type>
-            extractor;
-
-        typedef typename boost::unordered::detail::pick_policy<K>::type policy;
-
-        typedef boost::unordered::iterator_detail::
-            iterator<node> iterator;
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> c_iterator;
-        typedef boost::unordered::iterator_detail::
-            l_iterator<node, policy> l_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> cl_iterator;
-    };
-
-}}}

include/boost/unordered/detail/move.hpp

@@ -0,0 +1,243 @@
+/*
+    Copyright 2005-2007 Adobe Systems Incorporated
+   
+    Use, modification and distribution are subject to 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).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_UNORDERED_DETAIL_MOVE_HEADER
+#define BOOST_UNORDERED_DETAIL_MOVE_HEADER
+
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/detail/workaround.hpp>
+
+/*************************************************************************************************/
+
+#if defined(BOOST_NO_SFINAE)
+#  define BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
+#elif defined(__GNUC__) && \
+    (__GNUC__ < 3 || __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+#  define BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
+#elif BOOST_WORKAROUND(BOOST_INTEL, < 900) || \
+    BOOST_WORKAROUND(__EDG_VERSION__, < 304) || \
+    BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0593))
+#  define BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
+#endif
+
+/*************************************************************************************************/
+
+namespace boost {
+namespace unordered_detail {
+
+/*************************************************************************************************/
+
+namespace move_detail {
+
+/*************************************************************************************************/
+
+#if !defined(BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN)
+
+/*************************************************************************************************/
+
+template <typename T>  
+struct class_has_move_assign {  
+    class type {
+        typedef T& (T::*E)(T t);  
+        typedef char (&no_type)[1];  
+        typedef char (&yes_type)[2];  
+        template <E e> struct sfinae { typedef yes_type type; };  
+        template <class U>  
+        static typename sfinae<&U::operator=>::type test(int);  
+        template <class U>  
+        static no_type test(...);  
+    public:  
+        enum {value = sizeof(test<T>(1)) == sizeof(yes_type)};  
+    };
+ };  
+
+/*************************************************************************************************/
+
+template<typename T>
+struct has_move_assign : boost::mpl::and_<boost::is_class<T>, class_has_move_assign<T> > {};
+
+/*************************************************************************************************/
+
+class test_can_convert_anything { };
+
+/*************************************************************************************************/
+
+#endif // BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
+
+/*************************************************************************************************/
+
+/*
+    REVISIT (sparent@adobe.com): This is a work around for Boost 1.34.1 and VC++ 2008 where
+    boost::is_convertible<T, T> fails to compile.
+*/
+
+template <typename T, typename U>
+struct is_convertible : boost::mpl::or_<
+    boost::is_same<T, U>,
+    boost::is_convertible<T, U>
+> { };
+
+/*************************************************************************************************/
+
+} //namespace move_detail
+
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief move_from is used for move_ctors.
+*/
+
+template <typename T>
+struct move_from
+{
+    explicit move_from(T& x) : source(x) { }
+    T& source;
+private:
+    move_from& operator=(move_from const&);
+};
+
+/*************************************************************************************************/
+
+#if !defined(BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN)
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief The is_movable trait can be used to identify movable types.
+*/
+template <typename T>
+struct is_movable : boost::mpl::and_<
+                        boost::is_convertible<move_from<T>, T>,
+                        move_detail::has_move_assign<T>,
+                        boost::mpl::not_<boost::is_convertible<move_detail::test_can_convert_anything, T> >
+                    > { };
+
+/*************************************************************************************************/
+
+#else // BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
+
+// On compilers which don't have adequate SFINAE support, treat most types as unmovable,
+// unless the trait is specialized.
+
+template <typename T>
+struct is_movable : boost::mpl::false_ { };
+
+#endif
+
+/*************************************************************************************************/
+
+#if !defined(BOOST_NO_SFINAE)
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief copy_sink and move_sink are used to select between overloaded operations according to
+ whether type T is movable and convertible to type U.
+\sa move
+*/
+
+template <typename T,
+          typename U = T,
+          typename R = void*>
+struct copy_sink : boost::enable_if<
+                        boost::mpl::and_<
+                            boost::unordered_detail::move_detail::is_convertible<T, U>,                           
+                            boost::mpl::not_<is_movable<T> >
+                        >,
+                        R
+                    >
+{ };
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief move_sink and copy_sink are used to select between overloaded operations according to
+ whether type T is movable and convertible to type U.
+ \sa move
+*/
+
+template <typename T,
+          typename U = T,
+          typename R = void*>
+struct move_sink : boost::enable_if<
+                        boost::mpl::and_<
+                            boost::unordered_detail::move_detail::is_convertible<T, U>,                            
+                            is_movable<T>
+                        >,
+                        R
+                    >
+{ };
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief This version of move is selected when T is_movable . It in turn calls the move
+constructor. This call, with the help of the return value optimization, will cause x to be moved
+instead of copied to its destination. See adobe/test/move/main.cpp for examples.
+
+*/
+template <typename T>
+T move(T& x, typename move_sink<T>::type = 0) { return T(move_from<T>(x)); }
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief This version of move is selected when T is not movable . The net result will be that
+x gets copied.
+*/
+template <typename T>
+T& move(T& x, typename copy_sink<T>::type = 0) { return x; }
+
+/*************************************************************************************************/
+
+#else // BOOST_NO_SFINAE
+
+// On compilers without SFINAE, define copy_sink to always use the copy function.
+
+template <typename T,
+          typename U = T,
+          typename R = void*>
+struct copy_sink
+{
+    typedef R type;
+};
+
+// Always copy the element unless this is overloaded.
+
+template <typename T>
+T& move(T& x) {
+    return x;
+}
+
+#endif // BOOST_NO_SFINAE
+
+} // namespace unordered_detail
+} // namespace boost
+
+/*************************************************************************************************/
+
+#endif
+
+/*************************************************************************************************/

include/boost/unordered/detail/node.hpp

@@ -0,0 +1,226 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2009 Daniel James
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// This contains the basic data structure, apart from the actual values. There's
+// no construction or deconstruction here. So this only depends on the pointer
+// type.
+
+#ifndef BOOST_UNORDERED_DETAIL_NODE_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_NODE_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/unordered/detail/fwd.hpp>
+
+#if BOOST_WORKAROUND(__BORLANDC__, <= 0X0582)
+#define BOOST_UNORDERED_BORLAND_BOOL(x) (bool)(x)
+#else
+#define BOOST_UNORDERED_BORLAND_BOOL(x) x
+#endif
+
+namespace boost { namespace unordered_detail {
+
+    ////////////////////////////////////////////////////////////////////////////
+    // ungrouped node implementation
+    
+    template <class A>
+    inline BOOST_DEDUCED_TYPENAME ungrouped_node_base<A>::node_ptr&
+        ungrouped_node_base<A>::next_group(node_ptr ptr)
+    {
+        return ptr->next_;
+    }
+
+    template <class A>
+    inline std::size_t ungrouped_node_base<A>::group_count(node_ptr)
+    {
+        return 1;
+    }
+
+    template <class A>
+    inline void ungrouped_node_base<A>::add_to_bucket(node_ptr n, bucket& b)
+    {
+        n->next_ = b.next_;
+        b.next_ = n;
+    }
+
+    template <class A>
+    inline void ungrouped_node_base<A>::add_after_node(node_ptr n,
+        node_ptr position)
+    {
+        n->next_ = position->next_;
+        position->next_ = position;
+    }
+    
+    template <class A>
+    inline void ungrouped_node_base<A>::unlink_nodes(bucket& b,
+        node_ptr begin, node_ptr end)
+    {
+        node_ptr* pos = &b.next_;
+        while(*pos != begin) pos = &(*pos)->next_;
+        *pos = end;
+    }
+
+    template <class A>
+    inline void ungrouped_node_base<A>::unlink_nodes(bucket& b, node_ptr end)
+    {
+        b.next_ = end;
+    }
+
+    template <class A>
+    inline void ungrouped_node_base<A>::unlink_node(bucket& b, node_ptr n)
+    {
+        unlink_nodes(b, n, n->next_);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // grouped node implementation
+    
+    // If ptr is the first element in a group, return pointer to next group.
+    // Otherwise returns a pointer to ptr.
+    template <class A>
+    inline BOOST_DEDUCED_TYPENAME grouped_node_base<A>::node_ptr&
+        grouped_node_base<A>::next_group(node_ptr ptr)
+    {
+        return get(ptr).group_prev_->next_;
+    }
+
+    template <class A>
+    inline BOOST_DEDUCED_TYPENAME grouped_node_base<A>::node_ptr
+        grouped_node_base<A>::first_in_group(node_ptr ptr)
+    {
+        while(next_group(ptr) == ptr)
+            ptr = get(ptr).group_prev_;
+        return ptr;
+    }
+
+    template <class A>
+    inline std::size_t grouped_node_base<A>::group_count(node_ptr ptr)
+    {
+        node_ptr start = ptr;
+        std::size_t size = 0;
+        do {
+            ++size;
+            ptr = get(ptr).group_prev_;
+        } while(ptr != start);
+        return size;
+    }
+
+    template <class A>
+    inline void grouped_node_base<A>::add_to_bucket(node_ptr n, bucket& b)
+    {
+        n->next_ = b.next_;
+        get(n).group_prev_ = n;
+        b.next_ = n;
+    }
+
+    template <class A>
+    inline void grouped_node_base<A>::add_after_node(node_ptr n, node_ptr pos)
+    {
+        n->next_ = next_group(pos);
+        get(n).group_prev_ = get(pos).group_prev_;
+        next_group(pos) = n;
+        get(pos).group_prev_ = n;
+    }
+
+    // Break a ciruclar list into two, with split as the beginning
+    // of the second group (if split is at the beginning then don't
+    // split).
+    template <class A>
+    inline BOOST_DEDUCED_TYPENAME grouped_node_base<A>::node_ptr
+        grouped_node_base<A>::split_group(node_ptr split)
+    {
+        node_ptr first = first_in_group(split);
+        if(first == split) return split;
+
+        node_ptr last = get(first).group_prev_;
+        get(first).group_prev_ = get(split).group_prev_;
+        get(split).group_prev_ = last;
+
+        return first;
+    }
+
+    template <class A>
+    void grouped_node_base<A>::unlink_node(bucket& b, node_ptr n)
+    {
+        node_ptr next = n->next_;
+        node_ptr* pos = &next_group(n);
+
+        if(*pos != n) {
+            // The node is at the beginning of a group.
+
+            // Find the previous node pointer:
+            pos = &b.next_;
+            while(*pos != n) pos = &next_group(*pos);
+
+            // Remove from group
+            if(BOOST_UNORDERED_BORLAND_BOOL(next) &&
+                get(next).group_prev_ == n)
+            {
+                get(next).group_prev_ = get(n).group_prev_;
+            }
+        }
+        else if(BOOST_UNORDERED_BORLAND_BOOL(next) &&
+            get(next).group_prev_ == n)
+        {
+            // The deleted node is not at the end of the group, so
+            // change the link from the next node.
+            get(next).group_prev_ = get(n).group_prev_;
+        }
+        else {
+            // The deleted node is at the end of the group, so the
+            // first node in the group is pointing to it.
+            // Find that to change its pointer.
+            node_ptr x = get(n).group_prev_;
+            while(get(x).group_prev_ != n) {
+                x = get(x).group_prev_;
+            }
+            get(x).group_prev_ = get(n).group_prev_;
+        }
+        *pos = next;
+    }
+
+    template <class A>
+    void grouped_node_base<A>::unlink_nodes(bucket& b,
+        node_ptr begin, node_ptr end)
+    {
+        node_ptr* pos = &next_group(begin);
+
+        if(*pos != begin) {
+            // The node is at the beginning of a group.
+
+            // Find the previous node pointer:
+            pos = &b.next_;
+            while(*pos != begin) pos = &next_group(*pos);
+
+            // Remove from group
+            if(BOOST_UNORDERED_BORLAND_BOOL(end)) split_group(end);
+        }
+        else {
+            node_ptr group1 = split_group(begin);
+            if(BOOST_UNORDERED_BORLAND_BOOL(end)) {
+                node_ptr group2 = split_group(end);
+
+                if(begin == group2) {
+                    node_ptr end1 = get(group1).group_prev_;
+                    node_ptr end2 = get(group2).group_prev_;
+                    get(group1).group_prev_ = end2;
+                    get(group2).group_prev_ = end1;
+                }
+            }
+        }
+        *pos = end;
+    }
+
+    template <class A>
+    void grouped_node_base<A>::unlink_nodes(bucket& b, node_ptr end)
+    {
+        split_group(end);
+        b.next_ = end;
+    }
+}}
+
+#endif

include/boost/unordered/detail/set.hpp

@@ -1,75 +0,0 @@
-
-// Copyright (C) 2005-2016 Daniel James
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/unordered/unordered_set_fwd.hpp>
-#include <boost/unordered/detail/equivalent.hpp>
-#include <boost/unordered/detail/unique.hpp>
-
-namespace boost { namespace unordered { namespace detail {
-    template <typename A, typename T, typename H, typename P>
-    struct set
-    {
-        typedef boost::unordered::detail::set<A, T, H, P> types;
-
-        typedef A allocator;
-        typedef T value_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef T key_type;
-
-        typedef boost::unordered::detail::allocator_traits<allocator> traits;
-        typedef boost::unordered::detail::pick_node<allocator, value_type> pick;
-        typedef typename pick::node node;
-        typedef typename pick::bucket bucket;
-        typedef typename pick::link_pointer link_pointer;
-
-        typedef boost::unordered::detail::table_impl<types> table;
-        typedef boost::unordered::detail::set_extractor<value_type> extractor;
-
-        typedef typename boost::unordered::detail::pick_policy<T>::type policy;
-
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> iterator;
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> c_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> l_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> cl_iterator;
-    };
-
-    template <typename A, typename T, typename H, typename P>
-    struct multiset
-    {
-        typedef boost::unordered::detail::multiset<A, T, H, P> types;
-
-        typedef A allocator;
-        typedef T value_type;
-        typedef H hasher;
-        typedef P key_equal;
-        typedef T key_type;
-
-        typedef boost::unordered::detail::allocator_traits<allocator> traits;
-        typedef boost::unordered::detail::pick_grouped_node<allocator,
-            value_type> pick;
-        typedef typename pick::node node;
-        typedef typename pick::bucket bucket;
-        typedef typename pick::link_pointer link_pointer;
-
-        typedef boost::unordered::detail::grouped_table_impl<types> table;
-        typedef boost::unordered::detail::set_extractor<value_type> extractor;
-
-        typedef typename boost::unordered::detail::pick_policy<T>::type policy;
-
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> iterator;
-        typedef boost::unordered::iterator_detail::
-            c_iterator<node> c_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> l_iterator;
-        typedef boost::unordered::iterator_detail::
-            cl_iterator<node, policy> cl_iterator;
-    };
-}}}

include/boost/unordered/detail/util.hpp

@@ -1,68 +1,39 @@
 
 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
-// Copyright (C) 2005-2011 Daniel James
+// Copyright (C) 2005-2009 Daniel James
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #ifndef BOOST_UNORDERED_DETAIL_UTIL_HPP_INCLUDED
 #define BOOST_UNORDERED_DETAIL_UTIL_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_empty.hpp>
+#include <cstddef>
+#include <utility>
+#include <algorithm>
+#include <boost/limits.hpp>
 #include <boost/iterator/iterator_categories.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/detail/select_type.hpp>
-#include <boost/move/move.hpp>
 #include <boost/preprocessor/seq/size.hpp>
 #include <boost/preprocessor/seq/enum.hpp>
-#include <boost/swap.hpp>
+#include <boost/unordered/detail/fwd.hpp>
 
-namespace boost { namespace unordered { namespace detail {
-
-    static const float minimum_max_load_factor = 1e-3f;
-    static const std::size_t default_bucket_count = 11;
-    struct move_tag {};
-    struct empty_emplace {};
-
-    namespace func {
-        template <class T>
-        inline void ignore_unused_variable_warning(T const&) {}
-    }
+namespace boost { namespace unordered_detail {
 
     ////////////////////////////////////////////////////////////////////////////
-    // iterator SFINAE
+    // convert double to std::size_t
 
-    template <typename I>
-    struct is_forward :
-        boost::is_convertible<
-            typename boost::iterator_traversal<I>::type,
-            boost::forward_traversal_tag>
-    {};
-
-    template <typename I, typename ReturnType>
-    struct enable_if_forward :
-        boost::enable_if_c<
-            boost::unordered::detail::is_forward<I>::value,
-            ReturnType>
-    {};
-
-    template <typename I, typename ReturnType>
-    struct disable_if_forward :
-        boost::disable_if_c<
-            boost::unordered::detail::is_forward<I>::value,
-            ReturnType>
-    {};
+    inline std::size_t double_to_size_t(double f)
+    {
+        return f >= static_cast<double>(
+            (std::numeric_limits<std::size_t>::max)()) ?
+            (std::numeric_limits<std::size_t>::max)() :
+            static_cast<std::size_t>(f);
+    }
 
     ////////////////////////////////////////////////////////////////////////////
     // primes
 
 #define BOOST_UNORDERED_PRIMES \
-    (17ul)(29ul)(37ul)(53ul)(67ul)(79ul) \
+    (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) \
@@ -121,129 +92,240 @@ namespace boost { namespace unordered { namespace detail {
         return *bound;
     }
 
+    ////////////////////////////////////////////////////////////////////////////
+    // pair_cast - because some libraries don't have the full pair constructors.
+
+    template <class Dst1, class Dst2, class Src1, class Src2>
+    inline std::pair<Dst1, Dst2> pair_cast(std::pair<Src1, Src2> const& x)
+    {
+        return std::pair<Dst1, Dst2>(Dst1(x.first), Dst2(x.second));
+    }
+
     ////////////////////////////////////////////////////////////////////////////
     // insert_size/initial_size
 
+#if !defined(BOOST_NO_STD_DISTANCE)
+    using ::std::distance;
+#else
+    template <class ForwardIterator>
+    inline std::size_t distance(ForwardIterator i, ForwardIterator j) {
+        std::size_t x;
+        std::distance(i, j, x);
+        return x;
+    }
+#endif
+
     template <class I>
-    inline std::size_t insert_size(I i, I j, typename
-        boost::unordered::detail::enable_if_forward<I, void*>::type = 0)
+    inline std::size_t insert_size(I i, I j, boost::forward_traversal_tag)
     {
-        return static_cast<std::size_t>(std::distance(i, j));
+        return std::distance(i, j);
     }
 
     template <class I>
-    inline std::size_t insert_size(I, I, typename
-        boost::unordered::detail::disable_if_forward<I, void*>::type = 0)
+    inline std::size_t insert_size(I, I, boost::incrementable_traversal_tag)
     {
         return 1;
     }
 
     template <class I>
-    inline std::size_t initial_size(I i, I j,
-        std::size_t num_buckets =
-            boost::unordered::detail::default_bucket_count)
+    inline std::size_t insert_size(I i, I j)
     {
-        // TODO: Why +1?
-        return (std::max)(
-            boost::unordered::detail::insert_size(i, j) + 1,
+        BOOST_DEDUCED_TYPENAME boost::iterator_traversal<I>::type
+            iterator_traversal_tag;
+        return insert_size(i, j, iterator_traversal_tag);
+    }
+    
+    template <class I>
+    inline std::size_t initial_size(I i, I j,
+        std::size_t num_buckets = boost::unordered_detail::default_bucket_count)
+    {
+        return (std::max)(static_cast<std::size_t>(insert_size(i, j)) + 1,
             num_buckets);
     }
 
     ////////////////////////////////////////////////////////////////////////////
-    // compressed
+    // Node Constructors
 
-    template <typename T, int Index>
-    struct compressed_base : private T
+#if defined(BOOST_UNORDERED_STD_FORWARD)
+
+    template <class T, class... Args>
+    inline void construct_impl(T*, void* address, Args&&... args)
     {
-        compressed_base(T const& x) : T(x) {}
-        compressed_base(T& x, move_tag) : T(boost::move(x)) {}
+        new(address) T(std::forward<Args>(args)...);
+    }
 
-        T& get() { return *this; }
-        T const& get() const { return *this; }
-    };
-    
-    template <typename T, int Index>
-    struct uncompressed_base
+#if defined(BOOST_UNORDERED_CPP0X_PAIR)
+    template <class First, class Second, class Key, class Arg0, class... Args>
+    inline void construct_impl(std::pair<First, Second>*, void* address,
+        Key&& k, Arg0&& arg0, Args&&... args)
+    )
     {
-        uncompressed_base(T const& x) : value_(x) {}
-        uncompressed_base(T& x, move_tag) : value_(boost::move(x)) {}
+        new(address) std::pair<First, Second>(k,
+            Second(arg0, std::forward<Args>(args)...);
+    }
+#endif
 
-        T& get() { return value_; }
-        T const& get() const { return value_; }
-    private:
-        T value_;
-    };
-    
-    template <typename T, int Index>
-    struct generate_base
-      : boost::detail::if_true<
-            boost::is_empty<T>::value
-        >:: BOOST_NESTED_TEMPLATE then<
-            boost::unordered::detail::compressed_base<T, Index>,
-            boost::unordered::detail::uncompressed_base<T, Index>
-        >
-    {};
-    
-    template <typename T1, typename T2>
-    struct compressed
-      : private boost::unordered::detail::generate_base<T1, 1>::type,
-        private boost::unordered::detail::generate_base<T2, 2>::type
+#else
+
+#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _)                       \
+    template <                                                                 \
+        class T,                                                               \
+        BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)                           \
+    >                                                                          \
+    inline void construct_impl(                                                \
+        T*, void* address,                                                     \
+        BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)                         \
+    )                                                                          \
+    {                                                                          \
+        new(address) T(                                                        \
+            BOOST_UNORDERED_CALL_PARAMS(z, num_params));                       \
+    }                                                                          \
+                                                                               \
+    template <class First, class Second, class Key,                            \
+        BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)                           \
+    >                                                                          \
+    inline void construct_impl(                                                \
+        std::pair<First, Second>*, void* address,                              \
+        Key const& k, BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params))          \
+    {                                                                          \
+        new(address) std::pair<First, Second>(k,                               \
+            Second(BOOST_UNORDERED_CALL_PARAMS(z, num_params)));               \
+    }
+
+    BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+        BOOST_UNORDERED_CONSTRUCT_IMPL, _)
+
+#undef BOOST_UNORDERED_CONSTRUCT_IMPL
+#endif
+
+    // hash_node_constructor
+    //
+    // Used to construct nodes in an exception safe manner.
+
+    template <class Alloc, class Grouped>
+    class hash_node_constructor
     {
-        typedef typename generate_base<T1, 1>::type base1;
-        typedef typename generate_base<T2, 2>::type base2;
+        typedef hash_buckets<Alloc, Grouped> buckets;
+        typedef BOOST_DEDUCED_TYPENAME buckets::node node;
+        typedef BOOST_DEDUCED_TYPENAME buckets::real_node_ptr real_node_ptr;
+        typedef BOOST_DEDUCED_TYPENAME buckets::value_type value_type;
 
-        typedef T1 first_type;
-        typedef T2 second_type;
-        
-        first_type& first() {
-            return static_cast<base1*>(this)->get();
-        }
+        buckets& buckets_;
+        real_node_ptr node_;
+        bool node_constructed_;
+        bool value_constructed_;
 
-        first_type const& first() const {
-            return static_cast<base1 const*>(this)->get();
-        }
+    public:
 
-        second_type& second() {
-            return static_cast<base2*>(this)->get();
-        }
-
-        second_type const& second() const {
-            return static_cast<base2 const*>(this)->get();
-        }
-
-        template <typename First, typename Second>
-        compressed(First const& x1, Second const& x2)
-            : base1(x1), base2(x2) {}
-
-        compressed(compressed const& x)
-            : base1(x.first()), base2(x.second()) {}
-
-        compressed(compressed& x, move_tag m)
-            : base1(x.first(), m), base2(x.second(), m) {}
-
-        void assign(compressed const& x)
+        hash_node_constructor(buckets& m) :
+            buckets_(m),
+            node_(),
+            node_constructed_(false),
+            value_constructed_(false)
         {
-            first() = x.first();
-            second() = x.second();
         }
 
-        void move_assign(compressed& x)
+        ~hash_node_constructor();
+        void construct_preamble();
+
+#if defined(BOOST_UNORDERED_STD_FORWARD)
+        template <class... Args>
+        void construct(Args&&... args)
         {
-            first() = boost::move(x.first());
-            second() = boost::move(x.second());
+            construct_preamble();
+            construct_impl((value_type*) 0, node_->address(),
+                std::forward<Args>(args)...);
+            value_constructed_ = true;
         }
-        
-        void swap(compressed& x)
-        {
-            boost::swap(first(), x.first());
-            boost::swap(second(), x.second());
+#else
+
+#define BOOST_UNORDERED_CONSTRUCT(z, num_params, _)                            \
+        template <                                                             \
+            BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)                       \
+        >                                                                      \
+        void construct(                                                        \
+            BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)                     \
+        )                                                                      \
+        {                                                                      \
+            construct_preamble();                                              \
+            construct_impl(                                                    \
+                (value_type*) 0, node_->address(),                             \
+                BOOST_UNORDERED_CALL_PARAMS(z, num_params)                     \
+            );                                                                 \
+            value_constructed_ = true;                                         \
         }
 
+        BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+            BOOST_UNORDERED_CONSTRUCT, _)
+
+#undef BOOST_UNORDERED_CONSTRUCT
+
+#endif
+        template <class K, class M>
+        void construct_pair(K const& k, M*)
+        {
+            construct_preamble();
+            new(node_->address()) value_type(k, M());                    
+            value_constructed_ = true;
+        }
+
+        value_type& value() const
+        {
+            BOOST_ASSERT(node_);
+            return node_->value();
+        }
+
+        // no throw
+        BOOST_DEDUCED_TYPENAME buckets::node_ptr release()
+        {
+            real_node_ptr p = node_;
+            node_ = real_node_ptr();
+            // node_ptr cast
+            return buckets_.bucket_alloc().address(*p);
+        }
+
     private:
-        // Prevent assignment just to make use of assign or
-        // move_assign explicit.
-        compressed& operator=(compressed const&);
+        hash_node_constructor(hash_node_constructor const&);
+        hash_node_constructor& operator=(hash_node_constructor const&);
     };
-}}}
+    
+    // hash_node_constructor
+
+    template <class Alloc, class Grouped>
+    inline hash_node_constructor<Alloc, Grouped>::~hash_node_constructor()
+    {
+        if (node_) {
+            if (value_constructed_) {
+#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
+                struct dummy { hash_node<Alloc, Grouped> x; };
+#endif
+                boost::unordered_detail::destroy(node_->value_ptr());
+            }
+
+            if (node_constructed_)
+                buckets_.node_alloc().destroy(node_);
+
+            buckets_.node_alloc().deallocate(node_, 1);
+        }
+    }
+
+    template <class Alloc, class Grouped>
+    inline void hash_node_constructor<Alloc, Grouped>::construct_preamble()
+    {
+        if(!node_) {
+            node_constructed_ = false;
+            value_constructed_ = false;
+
+            node_ = buckets_.node_alloc().allocate(1);
+            buckets_.node_alloc().construct(node_, node());
+            node_constructed_ = true;
+        }
+        else {
+            BOOST_ASSERT(node_constructed_ && value_constructed_);
+            boost::unordered_detail::destroy(node_->value_ptr());
+            value_constructed_ = false;
+        }
+    }
+}}
 
 #endif

include/boost/unordered/unordered_map_fwd.hpp

@@ -1,65 +1,53 @@
 
-// Copyright (C) 2008-2011 Daniel James.
+// Copyright (C) 2008-2009 Daniel James.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #ifndef BOOST_UNORDERED_MAP_FWD_HPP_INCLUDED
 #define BOOST_UNORDERED_MAP_FWD_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
+#include <boost/config.hpp>
 #include <memory>
 #include <functional>
 #include <boost/functional/hash_fwd.hpp>
-#include <boost/unordered/detail/fwd.hpp>
 
 namespace boost
 {
-    namespace unordered
-    {
-        template <class K,
-            class T,
-            class H = boost::hash<K>,
-            class P = std::equal_to<K>,
-            class A = std::allocator<std::pair<const K, T> > >
-        class unordered_map;
+    template <class K,
+        class T,
+        class H = hash<K>,
+        class P = std::equal_to<K>,
+        class A = std::allocator<std::pair<const K, T> > >
+    class unordered_map;
+    template <class K, class T, class H, class P, class A>
+    inline bool operator==(unordered_map<K, T, H, P, A> const&,
+        unordered_map<K, T, H, P, A> const&);
+    template <class K, class T, class H, class P, class A>
+    inline bool operator!=(unordered_map<K, T, H, P, A> const&,
+        unordered_map<K, T, H, P, A> const&);
+    template <class K, class T, class H, class P, class A>
+    inline void swap(unordered_map<K, T, H, P, A>&,
+            unordered_map<K, T, H, P, A>&);
 
-        template <class K, class T, class H, class P, class A>
-        inline bool operator==(unordered_map<K, T, H, P, A> const&,
-            unordered_map<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline bool operator!=(unordered_map<K, T, H, P, A> const&,
-            unordered_map<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline void swap(unordered_map<K, T, H, P, A>&,
-                unordered_map<K, T, H, P, A>&);
-
-        template <class K,
-            class T,
-            class H = boost::hash<K>,
-            class P = std::equal_to<K>,
-            class A = std::allocator<std::pair<const K, T> > >
-        class unordered_multimap;
-
-        template <class K, class T, class H, class P, class A>
-        inline bool operator==(unordered_multimap<K, T, H, P, A> const&,
-            unordered_multimap<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline bool operator!=(unordered_multimap<K, T, H, P, A> const&,
-            unordered_multimap<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline void swap(unordered_multimap<K, T, H, P, A>&,
-                unordered_multimap<K, T, H, P, A>&);
-    }
-
-    using boost::unordered::unordered_map;
-    using boost::unordered::unordered_multimap;
-    using boost::unordered::swap;
-    using boost::unordered::operator==;
-    using boost::unordered::operator!=;
+    template <class K,
+        class T,
+        class H = hash<K>,
+        class P = std::equal_to<K>,
+        class A = std::allocator<std::pair<const K, T> > >
+    class unordered_multimap;
+    template <class K, class T, class H, class P, class A>
+    inline bool operator==(unordered_multimap<K, T, H, P, A> const&,
+        unordered_multimap<K, T, H, P, A> const&);
+    template <class K, class T, class H, class P, class A>
+    inline bool operator!=(unordered_multimap<K, T, H, P, A> const&,
+        unordered_multimap<K, T, H, P, A> const&);
+    template <class K, class T, class H, class P, class A>
+    inline void swap(unordered_multimap<K, T, H, P, A>&,
+            unordered_multimap<K, T, H, P, A>&);
 }
 
 #endif

include/boost/unordered/unordered_set_fwd.hpp

@@ -1,63 +1,51 @@
 
-// Copyright (C) 2008-2011 Daniel James.
+// Copyright (C) 2008-2009 Daniel James.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #ifndef BOOST_UNORDERED_SET_FWD_HPP_INCLUDED
 #define BOOST_UNORDERED_SET_FWD_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
+#include <boost/config.hpp>
 #include <memory>
 #include <functional>
 #include <boost/functional/hash_fwd.hpp>
-#include <boost/unordered/detail/fwd.hpp>
 
 namespace boost
 {
-    namespace unordered
-    {
-        template <class T,
-            class H = boost::hash<T>,
-            class P = std::equal_to<T>,
-            class A = std::allocator<T> >
-        class unordered_set;
+    template <class T,
+        class H = hash<T>,
+        class P = std::equal_to<T>,
+        class A = std::allocator<T> >
+    class unordered_set;
+    template <class T, class H, class P, class A>
+    inline bool operator==(unordered_set<T, H, P, A> const&,
+        unordered_set<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    inline bool operator!=(unordered_set<T, H, P, A> const&,
+        unordered_set<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    inline void swap(unordered_set<T, H, P, A> &m1,
+            unordered_set<T, H, P, A> &m2);
 
-        template <class T, class H, class P, class A>
-        inline bool operator==(unordered_set<T, H, P, A> const&,
-            unordered_set<T, H, P, A> const&);
-        template <class T, class H, class P, class A>
-        inline bool operator!=(unordered_set<T, H, P, A> const&,
-            unordered_set<T, H, P, A> const&);
-        template <class T, class H, class P, class A>
-        inline void swap(unordered_set<T, H, P, A> &m1,
-                unordered_set<T, H, P, A> &m2);
-
-        template <class T,
-            class H = boost::hash<T>,
-            class P = std::equal_to<T>,
-            class A = std::allocator<T> >
-        class unordered_multiset;
-
-        template <class T, class H, class P, class A>
-        inline bool operator==(unordered_multiset<T, H, P, A> const&,
-            unordered_multiset<T, H, P, A> const&);
-        template <class T, class H, class P, class A>
-        inline bool operator!=(unordered_multiset<T, H, P, A> const&,
-            unordered_multiset<T, H, P, A> const&);
-        template <class T, class H, class P, class A>
-        inline void swap(unordered_multiset<T, H, P, A> &m1,
-                unordered_multiset<T, H, P, A> &m2);
-    }
-
-    using boost::unordered::unordered_set;
-    using boost::unordered::unordered_multiset;
-    using boost::unordered::swap;
-    using boost::unordered::operator==;
-    using boost::unordered::operator!=;
+    template <class T,
+        class H = hash<T>,
+        class P = std::equal_to<T>,
+        class A = std::allocator<T> >
+    class unordered_multiset;
+    template <class T, class H, class P, class A>
+    inline bool operator==(unordered_multiset<T, H, P, A> const&,
+        unordered_multiset<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    inline bool operator!=(unordered_multiset<T, H, P, A> const&,
+        unordered_multiset<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    inline void swap(unordered_multiset<T, H, P, A> &m1,
+            unordered_multiset<T, H, P, A> &m2);
 }
 
 #endif

include/boost/unordered_map.hpp

@@ -9,9 +9,8 @@
 #ifndef BOOST_UNORDERED_MAP_HPP_INCLUDED
 #define BOOST_UNORDERED_MAP_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
 #include <boost/unordered/unordered_map.hpp>

include/boost/unordered_set.hpp

@@ -9,9 +9,8 @@
 #ifndef BOOST_UNORDERED_SET_HPP_INCLUDED
 #define BOOST_UNORDERED_SET_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
 #include <boost/unordered/unordered_set.hpp>

meta/libraries.json

@@ -1,17 +0,0 @@
-{
-    "key": "unordered",
-    "name": "Unordered",
-    "authors": [
-        "Daniel James"
-    ],
-    "maintainers": [
-        "Daniel James <dnljms -at- gmail.com>"
-    ],
-    "description": "Unordered associative containers.",
-    "std": [
-        "tr1"
-    ],
-    "category": [
-        "Containers"
-    ]
-}

test/Jamfile.v2

@@ -5,82 +5,5 @@
 
 import testing ;
 
-project unordered-test/unordered
-    : requirements
-        <warnings>all
-        <toolset>intel:<warnings>on
-        # Would be nice to define -Wundef, but I'm getting warnings from
-        # Boost.Preprocessor on trunk.
-        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
-        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
-        <toolset>clang:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wsign-conversion -Wconversion -Wfloat-equal -Wshadow"
-        <toolset>msvc:<cxxflags>"/wd4494"
-    ;
-
-#alias framework : /boost/test//boost_unit_test_framework ;
-alias framework : ;
-
-test-suite unordered
-    :
-        [ run unordered/fwd_set_test.cpp ]
-        [ run unordered/fwd_map_test.cpp ]
-        [ run unordered/allocator_traits.cpp ]
-        [ run unordered/minimal_allocator.cpp ]
-        [ run unordered/compile_set.cpp ]
-        [ run unordered/compile_map.cpp ]
-        [ run unordered/compile_map.cpp : :
-            : <define>BOOST_UNORDERED_USE_ALLOCATOR_TRAITS=0
-            : compile_map_unordered_allocator ]
-        [ run unordered/noexcept_tests.cpp ]
-        [ run unordered/link_test_1.cpp unordered/link_test_2.cpp ]
-        [ run unordered/incomplete_test.cpp ]
-        [ run unordered/simple_tests.cpp ]
-        [ run unordered/equivalent_keys_tests.cpp ]
-        [ run unordered/constructor_tests.cpp ]
-        [ run unordered/copy_tests.cpp ]
-        [ run unordered/move_tests.cpp ]
-        [ run unordered/assign_tests.cpp ]
-        [ run unordered/insert_tests.cpp ]
-        [ run unordered/insert_stable_tests.cpp ]
-        [ run unordered/insert_hint_tests.cpp ]
-        [ run unordered/emplace_tests.cpp ]
-        [ run unordered/unnecessary_copy_tests.cpp ]
-        [ run unordered/erase_tests.cpp ]
-        [ run unordered/erase_equiv_tests.cpp ]
-        [ run unordered/find_tests.cpp ]
-        [ run unordered/at_tests.cpp ]
-        [ run unordered/bucket_tests.cpp ]
-        [ run unordered/load_factor_tests.cpp ]
-        [ run unordered/rehash_tests.cpp ]
-        [ run unordered/equality_tests.cpp ]
-        [ run unordered/swap_tests.cpp ]
-
-        [ run unordered/compile_set.cpp : :
-            : <define>BOOST_UNORDERED_USE_MOVE
-            : bmove_compile_set ]
-        [ run unordered/compile_map.cpp : :
-            : <define>BOOST_UNORDERED_USE_MOVE
-            : bmove_compile_map ]
-        [ run unordered/copy_tests.cpp : :
-            : <define>BOOST_UNORDERED_USE_MOVE
-            : bmove_copy ]
-        [ run unordered/move_tests.cpp : :
-            : <define>BOOST_UNORDERED_USE_MOVE
-            : bmove_move ]
-        [ run unordered/assign_tests.cpp : :
-            : <define>BOOST_UNORDERED_USE_MOVE
-            : bmove_assign ]
-    ;
-
-test-suite unordered-exception
-    :
-        [ run exception/constructor_exception_tests.cpp framework ]
-        [ run exception/copy_exception_tests.cpp framework ]
-        [ run exception/assign_exception_tests.cpp framework ]
-        [ run exception/move_assign_exception_tests.cpp framework ]
-        [ run exception/insert_exception_tests.cpp framework ]
-        [ run exception/erase_exception_tests.cpp framework ]
-        [ run exception/rehash_exception_tests.cpp framework ]
-        [ run exception/swap_exception_tests.cpp framework : : :
-            <define>BOOST_UNORDERED_SWAP_METHOD=2 ]
-    ;
+build-project unordered ;
+build-project exception ;

test/exception/Jamfile.v2

@@ -0,0 +1,34 @@
+
+# Copyright 2006-2008 Daniel James.
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+import testing ;
+
+#alias framework : /boost/test//boost_unit_test_framework ;
+alias framework : ;
+
+project unordered-test/exception-tests
+    : requirements
+        <warnings>all
+        <toolset>intel:<warnings>on
+        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
+        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
+        <toolset>gcc:<define>_GLIBCXX_DEBUG
+        #<toolset>darwin:<define>_GLIBCXX_DEBUG
+        <toolset>msvc:<warnings-as-errors>on
+        #<toolset>gcc:<warnings-as-errors>on
+        #<toolset>darwin:<warnings-as-errors>on
+    ;
+
+test-suite unordered-exception
+    :
+        [ run constructor_exception_tests.cpp framework ]
+        [ run copy_exception_tests.cpp framework ]
+        [ run assign_exception_tests.cpp framework ]
+        [ run insert_exception_tests.cpp framework ]
+        [ run erase_exception_tests.cpp framework ]
+        [ run rehash_exception_tests.cpp framework ]
+        [ run swap_exception_tests.cpp framework : : :
+            <define>BOOST_UNORDERED_SWAP_METHOD=2 ]
+    ;

test/exception/assign_exception_tests.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
@@ -11,13 +13,13 @@
 #pragma warning(disable:4512) // assignment operator could not be generated
 #endif
 
-test::seed_t initialize_seed(12847);
+test::seed_t seed(12847);
 
 template <class T>
 struct self_assign_base : public test::exception_base
 {
     test::random_values<T> values;
-    self_assign_base(std::size_t count = 0) : values(count) {}
+    self_assign_base(int count = 0) : values(count) {}
 
     typedef T data_type;
     T init() const { return T(values.begin(), values.end()); }
@@ -38,111 +40,54 @@ struct self_assign_test2 : self_assign_base<T>
 template <class T>
 struct assign_base : public test::exception_base
 {
-    test::random_values<T> x_values, y_values;
-    T x,y;
+    const test::random_values<T> x_values, y_values;
+    const T x,y;
 
     typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
     typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
-    assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
-        x_values(),
-        y_values(),
-        x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
-        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
-    {
-        x.max_load_factor(mlf1);
-        y.max_load_factor(mlf2);
-    }
+    assign_base(unsigned int count1, unsigned int count2, int tag1, int tag2) :
+        x_values(count1),
+        y_values(count2),
+        x(x_values.begin(), x_values.end(), 0, hasher(tag1), key_equal(tag1),
+            allocator_type(tag1)),
+        y(y_values.begin(), y_values.end(), 0, hasher(tag2), key_equal(tag2),
+            allocator_type(tag2))
+    {}
 
     typedef T data_type;
     T init() const { return T(x); }
     void run(T& x1) const { x1 = y; }
     void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x1) const
-    {
-        test::check_equivalent_keys(x1);
-
-        // If the container is empty at the point of the exception, the
-        // internal structure is hidden, this exposes it, at the cost of
-        // messing up the data.
-        if (x_values.size()) {
-            T& x2 = const_cast<T&>(x1);
-            x2.emplace(*x_values.begin());
-            test::check_equivalent_keys(x2);
-        }
-    }
+        { test::check_equivalent_keys(x1); }
 };
 
 template <class T>
-struct assign_values : assign_base<T>
+struct assign_test1 : assign_base<T>
 {
-    assign_values(unsigned int count1, unsigned int count2,
-            int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
-        assign_base<T>(tag1, tag2, mlf1, mlf2)
-    {
-        this->x_values.fill(count1);
-        this->y_values.fill(count2);
-        this->x.insert(this->x_values.begin(), this->x_values.end());
-        this->y.insert(this->y_values.begin(), this->y_values.end());
-    }
+    assign_test1() : assign_base<T>(0, 0, 0, 0) {}
 };
 
 template <class T>
-struct assign_test1 : assign_values<T>
+struct assign_test2 : assign_base<T>
 {
-    assign_test1() : assign_values<T>(0, 0, 0, 0) {}
+    assign_test2() : assign_base<T>(60, 0, 0, 0) {}    
 };
 
 template <class T>
-struct assign_test2 : assign_values<T>
+struct assign_test3 : assign_base<T>
 {
-    assign_test2() : assign_values<T>(60, 0, 0, 0) {}
+    assign_test3() : assign_base<T>(0, 60, 0, 0) {}    
 };
 
 template <class T>
-struct assign_test3 : assign_values<T>
+struct assign_test4 : assign_base<T>
 {
-    assign_test3() : assign_values<T>(0, 60, 0, 0) {}
+    assign_test4() : assign_base<T>(10, 10, 1, 2) {}
 };
 
-template <class T>
-struct assign_test4 : assign_values<T>
-{
-    assign_test4() : assign_values<T>(10, 10, 1, 2) {}
-};
-
-template <class T>
-struct assign_test4a : assign_values<T>
-{
-    assign_test4a() : assign_values<T>(10, 100, 1, 2) {}
-};
-
-template <class T>
-struct assign_test5 : assign_values<T>
-{
-    assign_test5() : assign_values<T>(5, 60, 0, 0, 1.0f, 0.1f) {}
-};
-
-template <class T>
-struct equivalent_test1 : assign_base<T>
-{
-    equivalent_test1() :
-        assign_base<T>(0, 0)
-    {
-        test::random_values<T> x_values2(10);
-        this->x_values.insert(x_values2.begin(), x_values2.end());
-        this->x_values.insert(x_values2.begin(), x_values2.end());
-        test::random_values<T> y_values2(10);
-        this->y_values.insert(y_values2.begin(), y_values2.end());
-        this->y_values.insert(y_values2.begin(), y_values2.end());
-        this->x.insert(this->x_values.begin(), this->x_values.end());
-        this->y.insert(this->y_values.begin(), this->y_values.end());
-    }
-};
-
-EXCEPTION_TESTS(
+RUN_EXCEPTION_TESTS(
     (self_assign_test1)(self_assign_test2)
-    (assign_test1)(assign_test2)(assign_test3)(assign_test4)(assign_test4a)(assign_test5)
-    (equivalent_test1),
+    (assign_test1)(assign_test2)(assign_test3)(assign_test4),
     CONTAINER_SEQ)
-RUN_TESTS()

test/exception/constructor_exception_tests.cpp

@@ -3,13 +3,15 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/input_iterator.hpp"
 
 template <typename T> inline void avoid_unused_warning(T const&) {}
 
-test::seed_t initialize_seed(91274);
+test::seed_t seed(91274);
 
 struct objects
 {
@@ -159,7 +161,7 @@ struct copy_range_construct_test : public range<T>, objects
     }
 };
 
-EXCEPTION_TESTS(
+RUN_EXCEPTION_TESTS(
     (construct_test1)
     (construct_test2)
     (construct_test3)
@@ -174,4 +176,3 @@ EXCEPTION_TESTS(
     (input_range_construct_test)
     (copy_range_construct_test),
     CONTAINER_SEQ)
-RUN_TESTS()

test/exception/containers.hpp

@@ -3,10 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include "../helpers/prefix.hpp"
 #include <boost/unordered_map.hpp>
 #include <boost/unordered_set.hpp>
-#include "../helpers/postfix.hpp"
 #include "../objects/exception.hpp"
 
 typedef boost::unordered_set<
@@ -18,13 +16,13 @@ typedef boost::unordered_multiset<
     test::exception::object,
     test::exception::hash,
     test::exception::equal_to,
-    test::exception::allocator2<test::exception::object> > test_multiset;
+    test::exception::allocator<test::exception::object> > test_multiset;
 typedef boost::unordered_map<
     test::exception::object,
     test::exception::object,
     test::exception::hash,
     test::exception::equal_to,
-    test::exception::allocator2<test::exception::object> > test_map;
+    test::exception::allocator<test::exception::object> > test_map;
 typedef boost::unordered_multimap<
     test::exception::object,
     test::exception::object,

test/exception/copy_exception_tests.cpp

@@ -3,12 +3,14 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include "../helpers/random_values.hpp"
 
 template <typename T> inline void avoid_unused_warning(T const&) {}
 
-test::seed_t initialize_seed(73041);
+test::seed_t seed(73041);
 
 template <class T>
 struct copy_test1 : public test::exception_base
@@ -64,7 +66,6 @@ struct copy_with_allocator_test : public test::exception_base
     }
 };
 
-EXCEPTION_TESTS(
+RUN_EXCEPTION_TESTS(
     (copy_test1)(copy_test2)(copy_test3)(copy_with_allocator_test),
     CONTAINER_SEQ)
-RUN_TESTS()

test/exception/erase_exception_tests.cpp

@@ -3,12 +3,14 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
 #include "../helpers/helpers.hpp"
 
-test::seed_t initialize_seed(835193);
+test::seed_t seed(835193);
 
 template <class T>
 struct erase_test_base : public test::exception_base
@@ -49,7 +51,6 @@ struct erase_by_key_test1 : public erase_test_base<T>
     }
 };
 
-EXCEPTION_TESTS(
+RUN_EXCEPTION_TESTS(
     (erase_by_key_test1),
     CONTAINER_SEQ)
-RUN_TESTS()

test/exception/insert_exception_tests.cpp

@@ -3,21 +3,23 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include <string>
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
 #include "../helpers/strong.hpp"
-#include "../helpers/helpers.hpp"
+#include <boost/utility.hpp>
 #include <cmath>
 
-test::seed_t initialize_seed(747373);
+test::seed_t seed(747373);
 
 template <class T>
 struct insert_test_base : public test::exception_base
 {
     test::random_values<T> values;
-    insert_test_base(unsigned int count = 5) : values(count, test::limited_range) {}
+    insert_test_base(unsigned int count = 5) : values(count) {}
 
     typedef T data_type;
     typedef test::strong<T> strong_type;
@@ -32,12 +34,12 @@ struct insert_test_base : public test::exception_base
         std::string scope(test::scope);
 
         if(scope.find("hash::operator()") == std::string::npos)
-            strong.test(x, test::detail::tracker.count_allocations);
+            strong.test(x, test::exception::detail::tracker.count_allocations);
         test::check_equivalent_keys(x);
     }
 };
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
 
 template <class T>
 struct emplace_test1 : public insert_test_base<T>
@@ -49,7 +51,7 @@ struct emplace_test1 : public insert_test_base<T>
             it = this->values.begin(), end = this->values.end();
             it != end; ++it)
         {
-            strong.store(x, test::detail::tracker.count_allocations);
+            strong.store(x, test::exception::detail::tracker.count_allocations);
             x.emplace(*it);
         }
     }
@@ -67,7 +69,7 @@ struct insert_test1 : public insert_test_base<T>
             it = this->values.begin(), end = this->values.end();
             it != end; ++it)
         {
-            strong.store(x, test::detail::tracker.count_allocations);
+            strong.store(x, test::exception::detail::tracker.count_allocations);
             x.insert(*it);
         }
     }
@@ -83,7 +85,7 @@ struct insert_test2 : public insert_test_base<T>
             it = this->values.begin(), end = this->values.end();
             it != end; ++it)
         {
-            strong.store(x, test::detail::tracker.count_allocations);
+            strong.store(x, test::exception::detail::tracker.count_allocations);
             x.insert(x.begin(), *it);
         }
     }
@@ -111,8 +113,8 @@ struct insert_test4 : public insert_test_base<T>
             it = this->values.begin(), end = this->values.end();
             it != end; ++it)
         {
-            strong.store(x, test::detail::tracker.count_allocations);
-            x.insert(it, test::next(it));
+            strong.store(x, test::exception::detail::tracker.count_allocations);
+            x.insert(it, boost::next(it));
         }
     }
 };
@@ -130,13 +132,12 @@ struct insert_test_rehash1 : public insert_test_base<T>
 
         T x;
         x.max_load_factor(0.25);
-        // TODO: This doesn't really work is bucket_count is 0
         size_type bucket_count = x.bucket_count();
         size_type initial_elements = static_cast<size_type>(
-            ceil((double) bucket_count * (double) x.max_load_factor()) - 1);
+            ceil(bucket_count * (double) x.max_load_factor()) - 1);
         BOOST_TEST(initial_elements < this->values.size());
         x.insert(this->values.begin(),
-                test::next(this->values.begin(), initial_elements));
+                boost::next(this->values.begin(), initial_elements));
         BOOST_TEST(bucket_count == x.bucket_count());
         return x;
     }
@@ -147,11 +148,11 @@ struct insert_test_rehash1 : public insert_test_base<T>
         BOOST_DEDUCED_TYPENAME T::const_iterator pos = x.cbegin();
 
         for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = test::next(this->values.begin(), x.size()),
+            it = boost::next(this->values.begin(), x.size()),
                 end = this->values.end();
             it != end && count < 10; ++it, ++count)
         {
-            strong.store(x, test::detail::tracker.count_allocations);
+            strong.store(x, test::exception::detail::tracker.count_allocations);
             pos = x.insert(pos, *it);
         }
 
@@ -171,11 +172,11 @@ struct insert_test_rehash2 : public insert_test_rehash1<T>
         int count = 0;
 
         for(BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-            it = test::next(this->values.begin(), x.size()),
+            it = boost::next(this->values.begin(), x.size()),
                 end = this->values.end();
             it != end && count < 10; ++it, ++count)
         {
-            strong.store(x, test::detail::tracker.count_allocations);
+            strong.store(x, test::exception::detail::tracker.count_allocations);
             x.insert(*it);
         }
 
@@ -202,14 +203,14 @@ struct insert_test_rehash3 : public insert_test_base<T>
 
         original_bucket_count = x.bucket_count();
         rehash_bucket_count = static_cast<size_type>(
-            ceil((double) original_bucket_count * (double) x.max_load_factor())) - 1;
+            ceil(original_bucket_count * (double) x.max_load_factor())) - 1;
 
         size_type initial_elements =
             rehash_bucket_count > 5 ? rehash_bucket_count - 5 : 1;
 
         BOOST_TEST(initial_elements < this->values.size());
         x.insert(this->values.begin(),
-                test::next(this->values.begin(), initial_elements));
+                boost::next(this->values.begin(), initial_elements));
         BOOST_TEST(original_bucket_count == x.bucket_count());
         return x;
     }
@@ -217,8 +218,8 @@ struct insert_test_rehash3 : public insert_test_base<T>
     void run(T& x) const {
         BOOST_DEDUCED_TYPENAME T::size_type bucket_count = x.bucket_count();
 
-        x.insert(test::next(this->values.begin(), x.size()),
-                test::next(this->values.begin(), x.size() + 20));
+        x.insert(boost::next(this->values.begin(), x.size()),
+                boost::next(this->values.begin(), x.size() + 20));
 
         // This isn't actually a failure, but it means the test isn't doing its
         // job.
@@ -237,12 +238,11 @@ struct insert_test_rehash3 : public insert_test_base<T>
     (insert_test1)(insert_test2)(insert_test3)(insert_test4) \
     (insert_test_rehash1)(insert_test_rehash2)(insert_test_rehash3)
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
 #define ALL_TESTS (emplace_test1)BASIC_TESTS
 #else
 #define ALL_TESTS BASIC_TESTS
 #endif
 
 
-EXCEPTION_TESTS(ALL_TESTS, CONTAINER_SEQ)
-RUN_TESTS()
+RUN_EXCEPTION_TESTS(ALL_TESTS, CONTAINER_SEQ)

test/exception/move_assign_exception_tests.cpp

@@ -1,131 +0,0 @@
-
-// Copyright 2006-2009 Daniel James.
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <iostream>
-#include "./containers.hpp"
-#include "../helpers/random_values.hpp"
-#include "../helpers/invariants.hpp"
-
-#if defined(BOOST_MSVC)
-#pragma warning(disable:4512) // move_assignment operator could not be generated
-#endif
-
-test::seed_t initialize_seed(12847);
-
-template <class T>
-struct move_assign_base : public test::exception_base
-{
-    test::random_values<T> x_values, y_values;
-    T x,y;
-
-    typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
-    typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
-    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
-
-    move_assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
-        x_values(),
-        y_values(),
-        x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
-        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
-    {
-        x.max_load_factor(mlf1);
-        y.max_load_factor(mlf2);
-    }
-
-    typedef T data_type;
-    T init() const { return T(x); }
-    void run(T& x1) const {
-        test::exceptions_enable disable_exceptions(false);
-        T y1 = y;
-        disable_exceptions.release();
-        x1 = boost::move(y1);
-    }
-    void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x1) const
-    {
-        test::check_equivalent_keys(x1);
-
-        // If the container is empty at the point of the exception, the
-        // internal structure is hidden, this exposes it, at the cost of
-        // messing up the data.
-        if (x_values.size()) {
-            T& x2 = const_cast<T&>(x1);
-            x2.emplace(*x_values.begin());
-            test::check_equivalent_keys(x2);
-        }
-    }
-};
-
-template <class T>
-struct move_assign_values : move_assign_base<T>
-{
-    move_assign_values(unsigned int count1, unsigned int count2,
-            int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
-        move_assign_base<T>(tag1, tag2, mlf1, mlf2)
-    {
-        this->x_values.fill(count1);
-        this->y_values.fill(count2);
-        this->x.insert(this->x_values.begin(), this->x_values.end());
-        this->y.insert(this->y_values.begin(), this->y_values.end());
-    }
-};
-
-template <class T>
-struct move_assign_test1 : move_assign_values<T>
-{
-    move_assign_test1() : move_assign_values<T>(0, 0, 0, 0) {}
-};
-
-template <class T>
-struct move_assign_test2 : move_assign_values<T>
-{
-    move_assign_test2() : move_assign_values<T>(60, 0, 0, 0) {}
-};
-
-template <class T>
-struct move_assign_test3 : move_assign_values<T>
-{
-    move_assign_test3() : move_assign_values<T>(0, 60, 0, 0) {}
-};
-
-template <class T>
-struct move_assign_test4 : move_assign_values<T>
-{
-    move_assign_test4() : move_assign_values<T>(10, 10, 1, 2) {}
-};
-
-template <class T>
-struct move_assign_test4a : move_assign_values<T>
-{
-    move_assign_test4a() : move_assign_values<T>(10, 100, 1, 2) {}
-};
-
-template <class T>
-struct move_assign_test5 : move_assign_values<T>
-{
-    move_assign_test5() : move_assign_values<T>(5, 60, 0, 0, 1.0f, 0.1f) {}
-};
-
-template <class T>
-struct equivalent_test1 : move_assign_base<T>
-{
-    equivalent_test1() :
-        move_assign_base<T>(0, 0)
-    {
-        test::random_values<T> x_values2(10);
-        this->x_values.insert(x_values2.begin(), x_values2.end());
-        this->x_values.insert(x_values2.begin(), x_values2.end());
-        test::random_values<T> y_values2(10);
-        this->y_values.insert(y_values2.begin(), y_values2.end());
-        this->y_values.insert(y_values2.begin(), y_values2.end());
-        this->x.insert(this->x_values.begin(), this->x_values.end());
-        this->y.insert(this->y_values.begin(), this->y_values.end());
-    }
-};
-
-EXCEPTION_TESTS(
-    (move_assign_test1)(move_assign_test2)(move_assign_test3)(move_assign_test4)(move_assign_test4a)(move_assign_test5)
-    (equivalent_test1),
-    CONTAINER_SEQ)
-RUN_TESTS()

test/exception/rehash_exception_tests.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include <string>
 #include "../helpers/random_values.hpp"
@@ -11,15 +13,15 @@
 
 #include <iostream>
 
-test::seed_t initialize_seed(3298597);
+test::seed_t seed(3298597);
 
 template <class T>
 struct rehash_test_base : public test::exception_base
 {
     test::random_values<T> values;
     unsigned int n;
-    rehash_test_base(unsigned int count = 100, unsigned int n_ = 0)
-        : values(count), n(n_)
+    rehash_test_base(unsigned int count = 100, unsigned int n = 0)
+        : values(count), n(n)
     {}
 
     typedef T data_type;
@@ -79,7 +81,7 @@ struct rehash_test4 : rehash_test_base<T>
     void run(T& x) const { x.rehash(0); }
 };
 
-EXCEPTION_TESTS(
+RUN_EXCEPTION_TESTS(
     (rehash_test0)(rehash_test1)(rehash_test2)(rehash_test3)(rehash_test4),
     CONTAINER_SEQ)
-RUN_TESTS()
+

test/exception/swap_exception_tests.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "../helpers/prefix.hpp"
+
 #include "./containers.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/invariants.hpp"
@@ -11,13 +13,13 @@
 #pragma warning(disable:4512) // assignment operator could not be generated
 #endif
 
-test::seed_t initialize_seed(9387);
+test::seed_t seed(9387);
 
 template <class T>
 struct self_swap_base : public test::exception_base
 {
     test::random_values<T> values;
-    self_swap_base(std::size_t count = 0) : values(count) {}
+    self_swap_base(int count = 0) : values(count) {}
 
     typedef T data_type;
     T init() const { return T(values.begin(), values.end()); }
@@ -25,12 +27,13 @@ struct self_swap_base : public test::exception_base
     void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const {
         std::string scope(test::scope);
 
-        // TODO: In C++11 exceptions are only allowed in the swap function.
+#if BOOST_UNORDERED_SWAP_METHOD != 2
         BOOST_TEST(
-                scope == "hash::hash(hash)" ||
+                scope == "hash::operator(hash)" ||
                 scope == "hash::operator=(hash)" ||
-                scope == "equal_to::equal_to(equal_to)" ||
+                scope == "equal_to::operator(equal_to)" ||
                 scope == "equal_to::operator=(equal_to)");
+#endif
 
         test::check_equivalent_keys(x);
     }
@@ -60,20 +63,17 @@ struct swap_base : public test::exception_base
         initial_x(x_values.begin(), x_values.end(), 0, hasher(tag1),
                 key_equal(tag1), allocator_type(tag1)),
         initial_y(y_values.begin(), y_values.end(), 0, hasher(tag2),
-                key_equal(tag2), allocator_type(
-                    T::allocator_type::propagate_on_container_swap::value ?
-                        tag2 : tag1))
+                key_equal(tag2), allocator_type(tag2))
     {}
 
     struct data_type {
-        data_type(T const& x_, T const& y_)
-            : x(x_), y(y_) {}
+        data_type(T const& x, T const& y)
+            : x(x), y(y) {}
 
         T x, y;
     };
 
     data_type init() const { return data_type(initial_x, initial_y); }
-
     void run(data_type& d) const {
         try {
             d.x.swap(d.y);
@@ -82,12 +82,13 @@ struct swap_base : public test::exception_base
     void check BOOST_PREVENT_MACRO_SUBSTITUTION(data_type const& d) const {
         std::string scope(test::scope);
 
-        // TODO: In C++11 exceptions are only allowed in the swap function.
+#if BOOST_UNORDERED_SWAP_METHOD != 2
         BOOST_TEST(
-                scope == "hash::hash(hash)" ||
+                scope == "hash::operator(hash)" ||
                 scope == "hash::operator=(hash)" ||
-                scope == "equal_to::equal_to(equal_to)" ||
+                scope == "equal_to::operator(equal_to)" ||
                 scope == "equal_to::operator=(equal_to)");
+#endif
         
         test::check_equivalent_keys(d.x);
         test::check_equivalent_keys(d.y);
@@ -118,8 +119,7 @@ struct swap_test4 : swap_base<T>
     swap_test4() : swap_base<T>(10, 10, 1, 2) {}
 };
 
-EXCEPTION_TESTS(
+RUN_EXCEPTION_TESTS(
     (self_swap_test1)(self_swap_test2)
     (swap_test1)(swap_test2)(swap_test3)(swap_test4),
     CONTAINER_SEQ)
-RUN_TESTS()

test/helpers/allocator.hpp

@@ -0,0 +1,84 @@
+
+// Copyright 2006-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_UNORDERED_TEST_MALLOC_ALLOCATOR_HEADER)
+#define BOOST_UNORDERED_TEST_MALLOC_ALLOCATOR_HEADER
+
+#include <cstddef>
+#include <cstdlib>
+#include <boost/limits.hpp>
+#include <new>
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4100) // unreferenced formal parameter
+#endif
+
+namespace test
+{
+    template <class T>
+    struct malloc_allocator
+    {
+        typedef std::size_t size_type;
+        typedef std::ptrdiff_t difference_type;
+        typedef T* pointer;
+        typedef T const* const_pointer;
+        typedef T& reference;
+        typedef T const& const_reference;
+        typedef T value_type;
+
+        template <class U> struct rebind { typedef malloc_allocator<U> other; };
+
+        malloc_allocator() {}
+        template <class Y> malloc_allocator(malloc_allocator<Y> const&) {}
+        malloc_allocator(malloc_allocator const&) {}
+
+        pointer address(reference r) { return &r; }
+        const_pointer address(const_reference r) { return &r; }
+
+        pointer allocate(size_type n) {
+            using namespace std;
+            T* ptr = static_cast<T*>(malloc(n * sizeof(T)));
+            if(!ptr) throw std::bad_alloc();
+            return ptr;
+        }
+
+        pointer allocate(size_type n, void const* u) { return allocate(n); }
+
+        void deallocate(pointer p, size_type) {
+            using namespace std;
+            free(p);
+        }
+        void construct(pointer p, T const& t) { new(p) T(t); }
+        void destroy(pointer p) { p->~T(); }
+
+        size_type max_size() const {
+            return (std::numeric_limits<size_type>::max)();
+        }
+
+        bool operator==(malloc_allocator const&) const { return true; }
+        bool operator!=(malloc_allocator const&) const { return false; }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+        template <class T> void deallocate(T* p, size_type) {
+            using namespace std;
+            free(p);
+        }
+        char* _Charalloc(size_type n) {
+            using namespace std;
+            T* ptr = static_cast<T*>(malloc(n * sizeof(char)));
+            if(!ptr) throw std::bad_alloc();
+            return (char*) ptr;
+        }
+#endif
+    };
+}
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#pragma warning(disable:4100) // unreferenced formal parameter
+#endif
+
+#endif

test/helpers/check_return_type.hpp

@@ -6,7 +6,7 @@
 #if !defined(BOOST_UNORDERED_TEST_HELPERS_CHECK_RETURN_TYPE_HEADER)
 #define BOOST_UNORDERED_TEST_HELPERS_CHECK_RETURN_TYPE_HEADER
 
-#include <boost/static_assert.hpp>
+#include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 
@@ -18,19 +18,19 @@ namespace test
         template <class T2>
         static void equals(T2)
         {
-            BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
+            BOOST_MPL_ASSERT((boost::is_same<T1, T2>));
         }
 
         template <class T2>
         static void equals_ref(T2&)
         {
-            BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
+            BOOST_MPL_ASSERT((boost::is_same<T1, T2>));
         }
 
         template <class T2>
         static void convertible(T2)
         {
-            BOOST_STATIC_ASSERT((boost::is_convertible<T2, T1>::value));
+            BOOST_MPL_ASSERT((boost::is_convertible<T2, T1>));
         }
     };
 }

test/helpers/count.hpp

@@ -52,34 +52,29 @@ namespace test {
         }
     };
 
+    template <class T>
+    struct counted_object
+    {
+        static object_count count_;
+
+        counted_object() { count_.construct(); }
+        counted_object(counted_object const&) { count_.construct(); }
+        ~counted_object() { count_.destruct(); }
+    };
+
+    template <class T> object_count counted_object<T>::count_;
+
+    struct globally_counted_object
+        : counted_object<globally_counted_object> {};
+
     // This won't be a problem as I'm only using a single compile unit
     // in each test (this is actually require by the minimal test
     // framework).
     // 
     // boostinspect:nounnamed
     namespace {
-        object_count global_object_count;
+        object_count& global_object_count = globally_counted_object::count_;
     }
-    
-    struct counted_object
-    {
-        counted_object() { global_object_count.construct(); }
-        counted_object(counted_object const&) { global_object_count.construct(); }
-        ~counted_object() { global_object_count.destruct(); }
-    };
-
-    struct check_instances {
-        int instances_;
-        int constructions_;
-        
-        check_instances() :
-            instances_(global_object_count.instances),
-            constructions_(global_object_count.constructions) {}
-        ~check_instances() { BOOST_TEST(global_object_count.instances == instances_); }
-
-        int instances() const { return global_object_count.instances - instances_; }
-        int constructions() const { return global_object_count.constructions - constructions_; }
-    };
 }
 
 #endif

test/helpers/equivalent.hpp

@@ -42,15 +42,20 @@ namespace test
     }
 
     struct equivalent_type {
-        equivalent_type() {}
-
         template <class T1, class T2>
-        bool operator()(T1 const& x, T2 const& y) const {
+        bool operator()(T1 const& x, T2 const& y) {
             return equivalent_impl(x, y, derived);
         }
     };
 
-    const equivalent_type equivalent;
+    // This won't be a problem as I'm only using a single compile unit
+    // in each test (this is actually require by the minimal test
+    // framework).
+    // 
+    // boostinspect:nounnamed
+    namespace {
+        equivalent_type equivalent;
+    }
 
     template <class Container>
     class unordered_equivalence_tester

test/helpers/exception_test.hpp

@@ -20,37 +20,22 @@
                 fixture, BOOST_STRINGIZE(test_func<type>));                 \
         }                                                                   \
 
-#   define UNORDERED_EXCEPTION_TEST_CASE_REPEAT(name, test_func, n, type)   \
-        UNORDERED_AUTO_TEST(name)                                           \
-        {                                                                   \
-            for (unsigned i = 0; i < n; ++i) {                              \
-                test_func< type > fixture;                                  \
-                ::test::lightweight::exception_safety(                      \
-                    fixture, BOOST_STRINGIZE(test_func<type>));             \
-            }                                                               \
-        }                                                                   \
-
-
 #    define UNORDERED_EPOINT_IMPL ::test::lightweight::epoint
 
 #define UNORDERED_EXCEPTION_TEST_POSTFIX RUN_TESTS()
 
-#define EXCEPTION_TESTS(test_seq, param_seq)                                \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(EXCEPTION_TESTS_OP,                       \
-        (test_seq)((1))(param_seq))
+#define RUN_EXCEPTION_TESTS(test_seq, param_seq)                            \
+    BOOST_PP_SEQ_FOR_EACH_PRODUCT(RUN_EXCEPTION_TESTS_OP,                   \
+        (test_seq)(param_seq))                                              \
+    RUN_TESTS()                                                             \
 
-#define EXCEPTION_TESTS_REPEAT(n, test_seq, param_seq)                      \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(EXCEPTION_TESTS_OP,                       \
-        (test_seq)((n))(param_seq))
-
-#define EXCEPTION_TESTS_OP(r, product)                                      \
-    UNORDERED_EXCEPTION_TEST_CASE_REPEAT(                                   \
+#define RUN_EXCEPTION_TESTS_OP(r, product)                                  \
+    UNORDERED_EXCEPTION_TEST_CASE(                                          \
         BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, product),                         \
-            BOOST_PP_CAT(_, BOOST_PP_SEQ_ELEM(2, product))                  \
+            BOOST_PP_CAT(_, BOOST_PP_SEQ_ELEM(1, product))                  \
         ),                                                                  \
         BOOST_PP_SEQ_ELEM(0, product),                                      \
-        BOOST_PP_SEQ_ELEM(1, product),                                      \
-        BOOST_PP_SEQ_ELEM(2, product)                                       \
+        BOOST_PP_SEQ_ELEM(1, product)                                       \
     )                                                                       \
 
 #define UNORDERED_SCOPE(scope_name)                                         \
@@ -111,28 +96,16 @@ namespace test {
         exceptions_enable(exceptions_enable const&);
 
         bool old_value_;
-        bool released_;
     public:
         exceptions_enable(bool enable)
-            : old_value_(exceptions_enabled), released_(false)
+            : old_value_(exceptions_enabled)
         {
             exceptions_enabled = enable;
         }
 
         ~exceptions_enable()
         {
-            if (!released_) {
-                exceptions_enabled = old_value_;
-                released_ = true;
-            }
-        }
-
-        void release()
-        {
-            if (!released_) {
-                exceptions_enabled = old_value_;
-                released_ = true;
-            }
+            exceptions_enabled = old_value_;
         }
     };
 
@@ -179,13 +152,12 @@ namespace test {
     class test_runner
     {
         Test const& test_;
-        bool exception_in_check_;
 
         test_runner(test_runner const&);
         test_runner& operator=(test_runner const&);
     public:
-        test_runner(Test const& t) : test_(t), exception_in_check_(false) {}
-        void run() {
+        test_runner(Test const& t) : test_(t) {}
+        void operator()() const {
             DISABLE_EXCEPTIONS;
             test::scope = "";
             BOOST_DEDUCED_TYPENAME Test::data_type x(test_.init());
@@ -200,24 +172,14 @@ namespace test {
                 >(&Test::run, test_, x, strong);
             }
             catch(...) {
-                try {
-                    DISABLE_EXCEPTIONS;
-                    call_ignore_extra_parameters<
-                        Test,
-                        BOOST_DEDUCED_TYPENAME Test::data_type const,
-                        BOOST_DEDUCED_TYPENAME Test::strong_type const
-                    >(&Test::check, test_, constant(x), constant(strong));
-                } catch(...) {
-                    exception_in_check_ = true;
-                }
+                call_ignore_extra_parameters<
+                    Test,
+                    BOOST_DEDUCED_TYPENAME Test::data_type const,
+                    BOOST_DEDUCED_TYPENAME Test::strong_type const
+                >(&Test::check, test_, constant(x), constant(strong));
                 throw;
             }
         }
-        void end() {
-            if (exception_in_check_) {
-                BOOST_ERROR("Unexcpected exception in test_runner check call.");
-            }
-        }
     };
 
     // Quick exception testing based on lightweight test
@@ -247,30 +209,26 @@ namespace test {
 
             iteration = 0;
             bool success = false;
-            char const* error_msg = 0;
             do {
                 ++iteration;
                 count = 0;
 
                 try {
-                    runner.run();
+                    runner();
                     success = true;
                 }
                 catch(test_failure) {
-                    error_msg = "test_failure caught.";
+                    BOOST_ERROR("test_failure caught.");
                     break;
                 }
                 catch(test_exception) {
                     continue;
                 }
                 catch(...) {
-                    error_msg = "Unexpected exception.";
+                    BOOST_ERROR("Unexpected exception.");
                     break;
                 }
             } while(!success);
-
-            if (error_msg) { BOOST_ERROR(error_msg); }
-            runner.end();
         }
     }
 }

test/helpers/fwd.hpp

@@ -10,17 +10,11 @@
 
 namespace test
 {
-    typedef enum {
-        default_generator,
-        generate_collisions,
-        limited_range
-    } random_generator;
-
-    int generate(int const*, random_generator);
-    char generate(char const*, random_generator);
-    signed char generate(signed char const*, random_generator);
-    std::string generate(std::string const*, random_generator);
-    float generate(float const*, random_generator);
+    int generate(int const*);
+    char generate(char const*);
+    signed char generate(signed char const*);
+    std::string generate(std::string*);
+    float generate(float const*);
 
     struct base_type {} base;
     struct derived_type : base_type {} derived;

test/helpers/generators.hpp

@@ -27,32 +27,25 @@ namespace test
         }
     };
 
-    std::size_t random_value(std::size_t max) {
-        using namespace std;
-        return static_cast<std::size_t>(rand()) % max;
-    }
-
-    inline int generate(int const*, random_generator g)
+    inline int generate(int const*)
     {
         using namespace std;
-        int value = rand();
-        if (g == limited_range) { value = value % 100; }
-        return value;
+        return rand();
     }
 
-    inline char generate(char const*, random_generator)
+    inline char generate(char const*)
     {
         using namespace std;
         return static_cast<char>((rand() >> 1) % (128-32) + 32);
     }
 
-    inline signed char generate(signed char const*, random_generator)
+    inline signed char generate(signed char const*)
     {
         using namespace std;
         return static_cast<signed char>(rand());
     }
 
-    inline std::string generate(std::string const*, random_generator g)
+    inline std::string generate(std::string const*)
     {
         using namespace std;
 
@@ -60,30 +53,17 @@ namespace test
 
         std::string result;
 
-        if (g == limited_range) {
-            std::size_t length = test::random_value(2) + 2;
-
-            char const* strings[] = { "'vZh(3~ms", "%m", "_Y%U", "N'Y", "4,J_J" };
-            for (std::size_t i = 0; i < length; ++i) {
-                result += strings[random_value(sizeof(strings) / sizeof(strings[0]))];
-            }
-        }
-        else {
-            std::size_t length = test::random_value(10) + 1;
-            for (std::size_t i = 0; i < length; ++i) {
-                result += generate(char_ptr, g);
-            }
-        }
+        int length = rand() % 10;
+        for(int i = 0; i < length; ++i)
+            result += generate(char_ptr);
 
         return result;
     }
 
-    float generate(float const*, random_generator g)
+    float generate(float const*)
     {
         using namespace std;
-        int x = 0;
-        int value = generate(&x, g);
-        return (float) value / (float) RAND_MAX;
+        return (float) rand() / (float) RAND_MAX;
     }
 }
 

test/helpers/helpers.hpp

@@ -38,26 +38,6 @@ namespace test
     {
         return get_key_impl<Container>::get_key(x);
     }
-
-    // test::next
-    //
-    // Increments an iterator by 1 or a given value.
-    // Like boost::next, but simpler and slower.
-
-    template <typename Iterator>
-    Iterator next(Iterator it)
-    {
-        return ++it;
-    }
-
-    template <typename Iterator, typename IntType>
-    Iterator next(Iterator it, IntType x)
-    {
-        for(; x > 0; --x) {
-            ++it;
-        }
-        return it;
-    }
 }
 
 #endif

test/helpers/input_iterator.hpp

@@ -7,8 +7,8 @@
 #define BOOST_UNORDERED_TEST_HELPERS_INPUT_ITERATOR_HEADER
 
 #include <boost/config.hpp>
+#include <boost/iterator.hpp>
 #include <boost/iterator/iterator_traits.hpp>
-#include <iterator>
 
 namespace test
 {
@@ -28,7 +28,7 @@ namespace test
 
     template <class Iterator>
     struct input_iterator_adaptor
-        : public std::iterator<
+        : public boost::iterator<
             std::input_iterator_tag,
             BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
             std::ptrdiff_t,
@@ -72,7 +72,7 @@ namespace test
 
     template <class Iterator>
     struct copy_iterator_adaptor
-        : public std::iterator<
+        : public boost::iterator<
             BOOST_DEDUCED_TYPENAME boost::iterator_category<Iterator>::type,
             BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
             BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type,

test/helpers/invariants.hpp

@@ -13,6 +13,7 @@
 #include <cmath>
 #include "./metafunctions.hpp"
 #include "./helpers.hpp"
+#include "./allocator.hpp"
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
@@ -28,13 +29,16 @@ namespace test
     {
         BOOST_DEDUCED_TYPENAME X::key_equal eq = x1.key_eq();
         typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
-        std::set<key_type, std::less<key_type> > found_;
+        // Boost.Test was reporting memory leaks for std::set on g++-3.3.
+        // So I work around it by using malloc.
+        std::set<key_type, std::less<key_type>,
+            test::malloc_allocator<key_type> > found_;
 
         BOOST_DEDUCED_TYPENAME X::const_iterator
             it = x1.begin(), end = x1.end();
         BOOST_DEDUCED_TYPENAME X::size_type size = 0;
         while(it != end) {
-            // First test that the current key has not occurred before, required
+            // First test that the current key has not occured before, required
             // to test either that keys are unique or that equivalent keys are
             // adjacent. (6.3.1/6)
             key_type key = get_key<X>(*it);
@@ -61,61 +65,42 @@ namespace test
                 std::cerr<<x1.count(key)<<","<<count<<"\n";
             }
 
-            // Check that the keys are in the correct bucket and are
-            // adjacent in the bucket.
-            BOOST_DEDUCED_TYPENAME X::size_type bucket = x1.bucket(key);
-            BOOST_DEDUCED_TYPENAME X::const_local_iterator
-                lit = x1.begin(bucket), lend = x1.end(bucket);
-            for(; lit != lend && !eq(get_key<X>(*lit), key); ++lit) continue;
-            if(lit == lend)
-                BOOST_ERROR("Unable to find element with a local_iterator");
-            unsigned int count2 = 0;
-            for(; lit != lend && eq(get_key<X>(*lit), key); ++lit) ++count2;
-            if(count != count2)
-                BOOST_ERROR("Element count doesn't match local_iterator.");
-            for(; lit != lend; ++lit) {
-                if(eq(get_key<X>(*lit), key)) {
-                    BOOST_ERROR("Non-adjacent element with equivalent key "
-                        "in bucket.");
-                    break;
-                }
-            }
+            // I'm not bothering with the following test for now, as the
+            // previous test is probably more enough to catch the kind of
+            // errors that this would catch (if an element was in the wrong
+            // bucket it not be found by the call to count, if elements are not
+            // adjacent then they would be caught when checking against
+            // found_.
+
+            // // Check that the keys are in the correct bucket and are
+            // // adjacent in the bucket.
+            // BOOST_DEDUCED_TYPENAME X::size_type bucket = x1.bucket(key);
+            // BOOST_DEDUCED_TYPENAME X::const_local_iterator
+            //     lit = x1.begin(bucket), lend = x1.end(bucket);
+            // for(; lit != lend && !eq(get_key<X>(*lit), key); ++lit) continue;
+            // if(lit == lend)
+            //     BOOST_ERROR("Unable to find element with a local_iterator");
+            // unsigned int count2 = 0;
+            // for(; lit != lend && eq(get_key<X>(*lit), key); ++lit) ++count2;
+            // if(count != count2)
+            //     BOOST_ERROR("Element count doesn't match local_iterator.");
+            // for(; lit != lend; ++lit) {
+            //     if(eq(get_key<X>(*lit), key)) {
+            //         BOOST_ERROR("Non-adjacent element with equivalent key "
+            //             "in bucket.");
+            //         break;
+            //     }
+            // }
         };
 
-        // Check that size matches up.
-
-        if(x1.size() != size) {
+        // Finally, check that size matches up.
+        if(x1.size() != size)
             BOOST_ERROR("x1.size() doesn't match actual size.");
-            std::cout<<x1.size()<<"/"<<size<<std::endl;
-        }
-
-        // Check the load factor.
-
-        float load_factor = size == 0 ? 0 :
+        float load_factor =
             static_cast<float>(size) / static_cast<float>(x1.bucket_count());
         using namespace std;
         if(fabs(x1.load_factor() - load_factor) > x1.load_factor() / 64)
             BOOST_ERROR("x1.load_factor() doesn't match actual load_factor.");
-
-        // Check that size in the buckets matches up.
-
-        BOOST_DEDUCED_TYPENAME X::size_type bucket_size = 0;
-
-        for (BOOST_DEDUCED_TYPENAME X::size_type
-                i = 0; i < x1.bucket_count(); ++i)
-        {
-            for (BOOST_DEDUCED_TYPENAME X::const_local_iterator
-                    begin2 = x1.begin(i), end2 = x1.end(i);
-                    begin2 != end2; ++begin2)
-            {
-                ++bucket_size;
-            }
-        }
-
-        if(x1.size() != bucket_size) {
-            BOOST_ERROR("x1.size() doesn't match bucket size.");
-            std::cout<<x1.size()<<"/"<<bucket_size<<std::endl;
-        }
     }
 }
 

test/helpers/list.hpp

@@ -11,8 +11,8 @@
 #if !defined(UNORDERED_TEST_LIST_HEADER)
 #define UNORDERED_TEST_LIST_HEADER
 
+#include <boost/iterator.hpp>
 #include <boost/limits.hpp>
-#include <iterator>
 #include <functional>
 
 namespace test
@@ -83,7 +83,7 @@ namespace test
 
         template <typename T>
         class list_iterator
-            : public std::iterator<
+            : public boost::iterator<
                 std::forward_iterator_tag, T,
                   int, T*, T&>
         {
@@ -109,7 +109,7 @@ namespace test
 
         template <typename T>
         class list_const_iterator
-            : public std::iterator<
+            : public boost::iterator<
                 std::forward_iterator_tag, T,
                   int, T const*, T const&>
         {
@@ -219,14 +219,14 @@ namespace test
             data_.last_ptr_ = &data_.first_;
         }
 
-        void erase(const_iterator i, const_iterator j) {
+        void erase(const_iterator start, const_iterator end) {
             node** ptr = &data_.first_;
 
-            while(*ptr != i.ptr_) {
+            while(*ptr != start.ptr_) {
                 ptr = &(*ptr)->next_;
             }
 
-            while(*ptr != j.ptr_) {
+            while(*ptr != end.ptr_) {
                 node* to_delete = *ptr;
                 *ptr = (*ptr)->next_;
                 --data_.size_;

test/helpers/memory.hpp

@@ -8,8 +8,10 @@
 
 #include <memory>
 #include <map>
+#include <boost/mpl/apply.hpp>
 #include <boost/assert.hpp>
-#include <boost/unordered/detail/allocate.hpp>
+#include <boost/unordered/detail/allocator_helpers.hpp>
+#include <boost/mpl/aux_/config/eti.hpp>
 #include "../helpers/test.hpp"
 
 namespace test
@@ -51,10 +53,30 @@ namespace test
             }
         };
 
-        struct memory_tracker {
+        template <class Alloc>
+        struct allocator_memory_type_gen {
             typedef std::map<memory_area, memory_track, memory_area_compare,
-                    std::allocator<std::pair<memory_area const, memory_track> >
-                > allocated_memory_type;
+                Alloc> type;
+        };
+
+#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG)
+        template <>
+        struct allocator_memory_type_gen<int> {
+            typedef std::map<memory_area, memory_track, memory_area_compare>
+                type;
+        };
+#endif
+
+        template <class Alloc = std::allocator<int> >
+        struct memory_tracker {
+            typedef BOOST_DEDUCED_TYPENAME
+                boost::unordered_detail::rebind_wrap<Alloc,
+                    std::pair<memory_area const, memory_track> >::type
+                allocator_type;
+
+            typedef BOOST_DEDUCED_TYPENAME
+                allocator_memory_type_gen<allocator_type>::type
+                allocated_memory_type;
 
             allocated_memory_type allocated_memory;
             unsigned int count_allocators;
@@ -115,9 +137,9 @@ namespace test
             }
 
             void track_deallocate(void* ptr, std::size_t n, std::size_t size,
-                int tag, bool check_tag_ = true)
+                int tag)
             {
-                allocated_memory_type::iterator pos =
+                BOOST_DEDUCED_TYPENAME allocated_memory_type::iterator pos =
                     allocated_memory.find(
                         memory_area(ptr, (char*) ptr + n * size));
                 if(pos == allocated_memory.end()) {
@@ -125,7 +147,7 @@ namespace test
                 } else {
                     BOOST_TEST(pos->first.start == ptr);
                     BOOST_TEST(pos->first.end == (char*) ptr + n * size);
-                    if (check_tag_) BOOST_TEST(pos->second.tag_ == tag);
+                    BOOST_TEST(pos->second.tag_ == tag);
                     allocated_memory.erase(pos);
                 }
                 BOOST_TEST(count_allocations > 0);
@@ -146,18 +168,6 @@ namespace test
             }
         };
     }
-
-    namespace detail
-    {
-        // This won't be a problem as I'm only using a single compile unit
-        // in each test (this is actually required by the minimal test
-        // framework).
-        // 
-        // boostinspect:nounnamed
-        namespace {
-            test::detail::memory_tracker tracker;
-        }
-    }
 }
 
 #endif

test/helpers/metafunctions.hpp

@@ -8,23 +8,72 @@
 
 #include <boost/config.hpp>
 #include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
 
 namespace test
 {
+    /*
+    struct unordered_set_type { char x[100]; };
+    struct unordered_multiset_type { char x[200]; };
+    struct unordered_map_type { char x[300]; };
+    struct unordered_multimap_type { char x[400]; };
+
+    template <class V, class H, class P, class A>
+    unordered_set_type container_type(
+            boost::unordered_set<V, H, P, A> const*);
+    template <class V, class H, class P, class A>
+    unordered_multiset_type container_type(
+            boost::unordered_multiset<V, H, P, A> const*);
+    template <class K, class M, class H, class P, class A>
+    unordered_map_type container_type(
+            boost::unordered_map<K, M, H, P, A> const*);
+    template <class K, class M, class H, class P, class A>
+    unordered_multimap_type container_type(
+            boost::unordered_multimap<K, M, H, P, A> const*);
+    */
+
     template <class Container>
     struct is_set
         : public boost::is_same<
             BOOST_DEDUCED_TYPENAME Container::key_type,
             BOOST_DEDUCED_TYPENAME Container::value_type> {};
 
+    template <class Container>
+    struct is_map
+        : public boost::mpl::not_<is_set<Container> > {};
+
+    struct yes_type { char x[100]; };
+    struct no_type { char x[200]; };
+
+    template <class V, class H, class P, class A>
+    yes_type has_unique_key_impl(
+            boost::unordered_set<V, H, P, A> const*);
+    template <class V, class H, class P, class A>
+    no_type has_unique_key_impl(
+            boost::unordered_multiset<V, H, P, A> const*);
+    template <class K, class M, class H, class P, class A>
+    yes_type has_unique_key_impl(
+            boost::unordered_map<K, M, H, P, A> const*);
+    template <class K, class M, class H, class P, class A>
+    no_type has_unique_key_impl(
+            boost::unordered_multimap<K, M, H, P, A> const*);
+
     template <class Container>
     struct has_unique_keys
     {
-        static char flip(BOOST_DEDUCED_TYPENAME Container::iterator const&);
-        static long flip(std::pair<BOOST_DEDUCED_TYPENAME Container::iterator, bool> const&);
-        BOOST_STATIC_CONSTANT(bool, value = sizeof(long) == sizeof(
-                flip(((Container*) 0)->insert(*(BOOST_DEDUCED_TYPENAME Container::value_type*) 0))
-            ));
+        BOOST_STATIC_CONSTANT(bool, value = 
+            sizeof(has_unique_key_impl((Container const*)0))
+                == sizeof(yes_type));
+    };
+
+    template <class Container>
+    struct has_equivalent_keys
+    {
+        BOOST_STATIC_CONSTANT(bool, value = 
+            sizeof(has_unique_key_impl((Container const*)0))
+                == sizeof(no_type));
     };
 }
 

test/helpers/postfix.hpp

@@ -1,10 +0,0 @@
-
-// Copyright 2012 Daniel James.
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// Include this after the boost headers, but before other test headers.
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif

test/helpers/random_values.hpp

@@ -8,12 +8,17 @@
 
 #include "./list.hpp"
 #include <algorithm>
-#include <boost/detail/select_type.hpp>
+#include <boost/mpl/if.hpp>
 #include "./generators.hpp"
 #include "./metafunctions.hpp"
 
 namespace test
 {
+    typedef enum {
+        default_generator,
+        generate_collisions
+    } random_generator;
+
     template <class X>
     struct unordered_generator_set
     {
@@ -27,15 +32,15 @@ namespace test
         template <class T>
         void fill(T& x, std::size_t len) {
             value_type* value_ptr = 0;
-            len += x.size();
+            int* int_ptr = 0;
 
-            for (std::size_t i = 0; i < len; ++i) {
-                value_type value = generate(value_ptr, type_);
+            for(std::size_t i = 0; i < len; ++i) {
+                value_type value = generate(value_ptr);
 
-                std::size_t count = type_ == generate_collisions ?
-                    random_value(5) + 1 : 1;
-
-                for(std::size_t j = 0; j < count; ++j) {
+                for(int count =
+                    type_ == generate_collisions ?
+                    generate(int_ptr) % 10 : 1;
+                    count; --count) {
                     x.push_back(value);
                 }
             }
@@ -57,16 +62,18 @@ namespace test
         void fill(T& x, std::size_t len) {
             key_type* key_ptr = 0;
             mapped_type* mapped_ptr = 0;
+            int* int_ptr = 0;
 
-            for (std::size_t i = 0; i < len; ++i) {
-                key_type key = generate(key_ptr, type_);
+            for(std::size_t i = 0; i < len; ++i) {
+                key_type key = generate(key_ptr);
 
-                std::size_t count = type_ == generate_collisions ?
-                    random_value(5) + 1 : 1;
-
-                for(std::size_t j = 0; j < count; ++j) {
-                    x.push_back(std::pair<key_type const, mapped_type>(
-                        key, generate(mapped_ptr, type_)));
+                for(int count =
+                    type_ == generate_collisions ?
+                    generate(int_ptr) % 10 : 1;
+                    count; --count) {
+                    x.push_back(
+                        std::pair<key_type const, mapped_type>(
+                            key, generate(mapped_ptr)));
                 }
             }
         }
@@ -74,12 +81,10 @@ namespace test
 
     template <class X>
     struct unordered_generator_base
-        : public boost::detail::if_true<
-            test::is_set<X>::value
-        >::BOOST_NESTED_TEMPLATE then<
+        : public boost::mpl::if_<
+            test::is_set<X>,
             test::unordered_generator_set<X>,
-            test::unordered_generator_map<X>
-        >
+            test::unordered_generator_map<X> >
     {
     };
 
@@ -96,18 +101,10 @@ namespace test
     struct random_values
         : public test::list<BOOST_DEDUCED_TYPENAME X::value_type>
     {
-        random_values() {}
-
-        explicit random_values(std::size_t count, test::random_generator const& generator =
+        random_values(int count, test::random_generator const& generator =
             test::default_generator)
         {
-            fill(count, generator);
-        }
-
-        void fill(std::size_t count, test::random_generator const& generator =
-                test::default_generator)
-        {
-            test::unordered_generator<X> gen(generator);
+            static test::unordered_generator<X> gen(generator);
             gen.fill(*this, count);
         }
     };

test/helpers/strong.hpp

@@ -8,6 +8,7 @@
 
 #include <boost/config.hpp>
 #include <iterator>
+#include "./metafunctions.hpp"
 #include "./equivalent.hpp"
 #include "./list.hpp"
 #include "./exception_test.hpp"

test/helpers/test.hpp

@@ -24,11 +24,7 @@
     void BOOST_PP_CAT(x, _type)::run()                                      \
 
 #define RUN_TESTS() int main(int, char**)                                   \
-    {                                                                       \
-        ::test::write_compiler_info();                                      \
-        ::test::test_list::run_tests();                                     \
-        return boost::report_errors();                                      \
-    }
+    { ::test::test_list::run_tests(); return boost::report_errors(); }      \
 
 namespace test {
     struct registered_test_base {
@@ -70,21 +66,6 @@ namespace test {
             }
         }
     }
-
-    inline void write_compiler_info() {
-#if defined(BOOST_GCC_CXX11)
-        char const* cpp11 = "true";
-#else
-        char const* cpp11 = "false";
-#endif
-
-        std::cout
-            << "Compiler: " << BOOST_COMPILER << "\n"
-            << "Library: " << BOOST_STDLIB << "\n"
-            << "C++11: " << cpp11 << "\n"
-            << "\n"
-            << std::flush;
-    }
 }
 
 #include <boost/preprocessor/seq/for_each_product.hpp>
@@ -95,29 +76,21 @@ namespace test {
 
 // Run test with every combination of the parameters (a sequence of sequences)
 #define UNORDERED_TEST(name, parameters)                                    \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP,                        \
-        ((name))((1)) parameters)                                           \
-
-#define UNORDERED_TEST_REPEAT(name, n, parameters)                          \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP,                        \
-        ((name))((n)) parameters)                                           \
+    BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP, ((name)) parameters)   \
 
 #define UNORDERED_TEST_OP(r, product)                                       \
     UNORDERED_TEST_OP2(                                                     \
-        BOOST_PP_SEQ_ELEM(0, product),                                      \
-        BOOST_PP_SEQ_ELEM(1, product),                                      \
-        BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_TAIL(product)))                      \
+        BOOST_PP_SEQ_HEAD(product),                                         \
+        BOOST_PP_SEQ_TAIL(product))                                         \
 
-#define UNORDERED_TEST_OP2(name, n, params)                                 \
+#define UNORDERED_TEST_OP2(name, params)                                    \
     UNORDERED_AUTO_TEST(                                                    \
         BOOST_PP_SEQ_FOLD_LEFT(UNORDERED_TEST_OP_JOIN, name, params))       \
     {                                                                       \
-        for (int i = 0; i < n; ++i)                                         \
-            name BOOST_PP_SEQ_TO_TUPLE(params);                             \
+        name BOOST_PP_SEQ_TO_TUPLE(params);                                 \
     }                                                                       \
 
 #define UNORDERED_TEST_OP_JOIN(s, state, elem)                              \
     BOOST_PP_CAT(state, BOOST_PP_CAT(_, elem))                              \
 
-
 #endif

test/helpers/tracker.hpp

@@ -13,6 +13,10 @@
 #include <map>
 #include <iterator>
 #include <algorithm>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_same.hpp>
 #include "../objects/fwd.hpp"
 #include "./metafunctions.hpp"
 #include "./helpers.hpp"
@@ -21,17 +25,21 @@
 
 namespace test
 {
-    template <typename X>
-    struct equals_to_compare
+    template <class X>
+    struct equals_to_compare2
+        : public boost::mpl::identity<
+            std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type> >
     {
-        typedef std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type>
-            type;
     };
 
-    template <>
-    struct equals_to_compare<test::equal_to>
+    template <class X>
+    struct equals_to_compare
+        : public boost::mpl::eval_if<
+            boost::is_same<X, test::equal_to>,
+            boost::mpl::identity<test::less>,
+            equals_to_compare2<X>
+        >
     {
-        typedef test::less type;
     };
 
     template <class X1, class X2>
@@ -59,48 +67,51 @@ namespace test
                     values2.begin(), test::equivalent));
     }
 
-    template <typename X,
-             bool is_set = test::is_set<X>::value,
-             bool has_unique_keys = test::has_unique_keys<X>::value>
-    struct ordered_base;
+    template <class X>
+    struct ordered_set : public
+        boost::mpl::if_<
+            test::has_unique_keys<X>,
+            std::set<
+                BOOST_DEDUCED_TYPENAME X::value_type,
+                BOOST_DEDUCED_TYPENAME equals_to_compare<
+                    BOOST_DEDUCED_TYPENAME X::key_equal
+                >::type
+            >,
+            std::multiset<
+                BOOST_DEDUCED_TYPENAME X::value_type,
+                BOOST_DEDUCED_TYPENAME equals_to_compare<
+                    BOOST_DEDUCED_TYPENAME X::key_equal
+                >::type
+            >
+        > {};
 
-    template <typename X>
-    struct ordered_base<X, true, true>
-    {
-        typedef std::set<
-            BOOST_DEDUCED_TYPENAME X::value_type,
-            BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
-            type;
-    };
+    template <class X>
+    struct ordered_map : public
+        boost::mpl::if_<
+            test::has_unique_keys<X>,
+            std::map<
+                BOOST_DEDUCED_TYPENAME X::key_type,
+                BOOST_DEDUCED_TYPENAME X::mapped_type,
+                BOOST_DEDUCED_TYPENAME equals_to_compare<
+                    BOOST_DEDUCED_TYPENAME X::key_equal
+                >::type
+            >,
+            std::multimap<
+                BOOST_DEDUCED_TYPENAME X::key_type,
+                BOOST_DEDUCED_TYPENAME X::mapped_type,
+                BOOST_DEDUCED_TYPENAME equals_to_compare<
+                    BOOST_DEDUCED_TYPENAME X::key_equal
+                >::type
+            >
+        > {};
 
-    template <typename X>
-    struct ordered_base<X, true, false>
-    {
-        typedef std::multiset<
-            BOOST_DEDUCED_TYPENAME X::value_type,
-            BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
-            type;
-    };
-
-    template <typename X>
-    struct ordered_base<X, false, true>
-    {
-        typedef std::map<
-            BOOST_DEDUCED_TYPENAME X::key_type,
-            BOOST_DEDUCED_TYPENAME X::mapped_type,
-            BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
-            type;
-    };
-
-    template <typename X>
-    struct ordered_base<X, false, false>
-    {
-        typedef std::multimap<
-            BOOST_DEDUCED_TYPENAME X::key_type,
-            BOOST_DEDUCED_TYPENAME X::mapped_type,
-            BOOST_DEDUCED_TYPENAME equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
-            type;
-    };
+    template <class X>
+    struct ordered_base : public
+        boost::mpl::eval_if<
+            test::is_set<X>,
+            test::ordered_set<X>,
+            test::ordered_map<X>
+        > {};
 
     template <class X>
     class ordered : public ordered_base<X>::type
@@ -113,8 +124,8 @@ namespace test
             : base()
         {}
 
-        explicit ordered(key_compare const& kc)
-            : base(kc)
+        explicit ordered(key_compare const& compare)
+            : base(compare)
         {}
 
         void compare(X const& x)
@@ -132,10 +143,10 @@ namespace test
         }
 
         template <class It>
-        void insert_range(It b, It e) {
-            while(b != e) {
-                this->insert(*b);
-                ++b;
+        void insert_range(It begin, It end) {
+            while(begin != end) {
+                this->insert(*begin);
+                ++begin;
             }
         }
     };

test/objects/cxx11_allocator.hpp

@@ -1,321 +0,0 @@
-
-// Copyright 2006-2011 Daniel James.
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#if !defined(BOOST_UNORDERED_TEST_CXX11_ALLOCATOR_HEADER)
-#define BOOST_UNORDERED_TEST_CXX11_ALLOCATOR_HEADER
-
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <cstddef>
-
-#include "../helpers/fwd.hpp"
-#include "../helpers/memory.hpp"
-
-namespace test
-{
-    struct allocator_false
-    {
-        enum {
-            is_select_on_copy = 0,
-            is_propagate_on_swap = 0,
-            is_propagate_on_assign = 0,
-            is_propagate_on_move = 0,
-            cxx11_construct = 0
-        };
-    };
-
-    struct allocator_flags_all
-    {
-        enum {
-            is_select_on_copy = 1,
-            is_propagate_on_swap = 1,
-            is_propagate_on_assign = 1,
-            is_propagate_on_move = 1,
-            cxx11_construct = 1
-        };
-    };
-    
-    struct select_copy : allocator_false
-    { enum { is_select_on_copy = 1 }; };
-    struct propagate_swap : allocator_false
-    { enum { is_propagate_on_swap = 1 }; };
-    struct propagate_assign : allocator_false
-    { enum { is_propagate_on_assign = 1 }; };
-    struct propagate_move : allocator_false
-    { enum { is_propagate_on_move = 1 }; };
-
-    struct no_select_copy : allocator_flags_all
-    { enum { is_select_on_copy = 0 }; };
-    struct no_propagate_swap : allocator_flags_all
-    { enum { is_propagate_on_swap = 0 }; };
-    struct no_propagate_assign : allocator_flags_all
-    { enum { is_propagate_on_assign = 0 }; };
-    struct no_propagate_move : allocator_flags_all
-    { enum { is_propagate_on_move = 0 }; };
-    
-    template <typename Flag>
-    struct swap_allocator_base
-    {
-        struct propagate_on_container_swap {
-            enum { value = Flag::is_propagate_on_swap }; };
-    };
-
-    template <typename Flag>
-    struct assign_allocator_base
-    {
-        struct propagate_on_container_copy_assignment {
-            enum { value = Flag::is_propagate_on_assign }; };
-    };
-
-    template <typename Flag>
-    struct move_allocator_base
-    {
-        struct propagate_on_container_move_assignment {
-            enum { value = Flag::is_propagate_on_move }; };
-    };
-
-    namespace
-    {
-        // boostinspect:nounnamed
-        bool force_equal_allocator_value = false;
-    }
-
-    struct force_equal_allocator
-    {
-        bool old_value_;
-    
-        explicit force_equal_allocator(bool value)
-            : old_value_(force_equal_allocator_value)
-        { force_equal_allocator_value = value; }
-        
-        ~force_equal_allocator()
-        { force_equal_allocator_value = old_value_; }
-    };
-
-    template <typename T>
-    struct cxx11_allocator_base
-    {
-        int tag_;
-        int selected_;
-
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-        typedef T* pointer;
-        typedef T const* const_pointer;
-        typedef T& reference;
-        typedef T const& const_reference;
-        typedef T value_type;
-
-        explicit cxx11_allocator_base(int t)
-            : tag_(t), selected_(0)
-        {
-            detail::tracker.allocator_ref();
-        }
-        
-        template <typename Y> cxx11_allocator_base(
-                cxx11_allocator_base<Y> const& x)
-            : tag_(x.tag_), selected_(x.selected_)
-        {
-            detail::tracker.allocator_ref();
-        }
-
-        cxx11_allocator_base(cxx11_allocator_base const& x)
-            : tag_(x.tag_), selected_(x.selected_)
-        {
-            detail::tracker.allocator_ref();
-        }
-
-        ~cxx11_allocator_base()
-        {
-            detail::tracker.allocator_unref();
-        }
-
-        pointer address(reference r)
-        {
-            return pointer(&r);
-        }
-
-        const_pointer address(const_reference r)
-        {
-            return const_pointer(&r);
-        }
-
-        pointer allocate(size_type n) {
-            pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return ptr;
-        }
-
-        pointer allocate(size_type n, void const*)
-        {
-            pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return ptr;
-        }
-
-        void deallocate(pointer p, size_type n)
-        {
-            // Only checking tags when propagating swap.
-            // Note that tags will be tested
-            // properly in the normal allocator.
-            detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_,
-                 !force_equal_allocator_value);
-            ::operator delete((void*) p);
-        }
-
-        void construct(T* p, T const& t) {
-            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(t);
-        }
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<typename... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(boost::forward<Args>(args)...);
-        }
-#endif
-
-        void destroy(T* p) {
-            detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
-            p->~T();
-        }
-
-        size_type max_size() const {
-            return (std::numeric_limits<size_type>::max)();
-        }
-    };
-
-    template <typename T, typename Flags = propagate_swap,
-        typename Enable = void>
-    struct cxx11_allocator;
-
-    template <typename T, typename Flags>
-    struct cxx11_allocator<
-        T, Flags,
-        typename boost::disable_if_c<Flags::is_select_on_copy>::type
-    > : public cxx11_allocator_base<T>,
-        public swap_allocator_base<Flags>,
-        public assign_allocator_base<Flags>,
-        public move_allocator_base<Flags>,
-        Flags
-    {
-#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
-        template <typename U> struct rebind {
-            typedef cxx11_allocator<U, Flags> other;
-        };
-#endif
-
-        explicit cxx11_allocator(int t = 0)
-            : cxx11_allocator_base<T>(t)
-        {
-        }
-        
-        template <typename Y> cxx11_allocator(
-                cxx11_allocator<Y, Flags> const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
-
-        cxx11_allocator(cxx11_allocator const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
-
-        // When not propagating swap, allocators are always equal
-        // to avoid undefined behaviour.
-        bool operator==(cxx11_allocator const& x) const
-        {
-            return force_equal_allocator_value || (this->tag_ == x.tag_);
-        }
-
-        bool operator!=(cxx11_allocator const& x) const
-        {
-            return !(*this == x);
-        }
-    };
-
-    template <typename T, typename Flags>
-    struct cxx11_allocator<
-        T, Flags,
-        typename boost::enable_if_c<Flags::is_select_on_copy>::type
-    > : public cxx11_allocator_base<T>,
-        public swap_allocator_base<Flags>,
-        public assign_allocator_base<Flags>,
-        public move_allocator_base<Flags>,
-        Flags
-    {
-        cxx11_allocator select_on_container_copy_construction() const
-        {
-            cxx11_allocator tmp(*this);
-            ++tmp.selected_;
-            return tmp;
-        }
-
-#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
-        template <typename U> struct rebind {
-            typedef cxx11_allocator<U, Flags> other;
-        };
-#endif
-
-        explicit cxx11_allocator(int t = 0)
-            : cxx11_allocator_base<T>(t)
-        {
-        }
-        
-        template <typename Y> cxx11_allocator(
-                cxx11_allocator<Y, Flags> const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
-
-        cxx11_allocator(cxx11_allocator const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
-
-        // When not propagating swap, allocators are always equal
-        // to avoid undefined behaviour.
-        bool operator==(cxx11_allocator const& x) const
-        {
-            return force_equal_allocator_value || (this->tag_ == x.tag_);
-        }
-
-        bool operator!=(cxx11_allocator const& x) const
-        {
-            return !(*this == x);
-        }
-    };
-
-    template <typename T, typename Flags>
-    bool equivalent_impl(
-            cxx11_allocator<T, Flags> const& x,
-            cxx11_allocator<T, Flags> const& y,
-            test::derived_type)
-    {
-        return x.tag_ == y.tag_;
-    }
-
-    // Function to check how many times an allocator has been selected,
-    // return 0 for other allocators.
-
-    struct convert_from_anything
-    {
-        template <typename T>
-        convert_from_anything(T const&) {}
-    };
-
-    inline int selected_count(convert_from_anything)
-    {
-        return 0;
-    }
-
-    template <typename T, typename Flags>
-    int selected_count(cxx11_allocator<T, Flags> const& x)
-    {
-        return x.selected_;
-    }
-}
-
-#endif

test/objects/exception.hpp

@@ -13,27 +13,26 @@
 #include <boost/limits.hpp>
 #include <new>
 #include "../helpers/fwd.hpp"
+#include "../helpers/allocator.hpp"
 #include "../helpers/memory.hpp"
 
 namespace test
 {
 namespace exception
 {
+    namespace detail
+    {
+        namespace
+        {
+            test::detail::memory_tracker<test::malloc_allocator<int> > tracker;
+        }
+    }
+
     class object;
     class hash;
     class equal_to;
     template <class T> class allocator;
-    object generate(object const*, random_generator);
-
-    struct true_type
-    {
-        enum { value = true };
-    };
-
-    struct false_type
-    {
-        enum { value = false };
-    };
+    object generate(object const*);
 
     class object
     {
@@ -101,9 +100,9 @@ namespace exception
                 (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
         }
 
-        friend object generate(object const*, random_generator g) {
+        friend object generate(object const*) {
             int* x = 0;
-            return object(::test::generate(x, g), ::test::generate(x, g));
+            return object(::test::generate(x), ::test::generate(x));
         }
 
         friend std::ostream& operator<<(std::ostream& out, object const& o)
@@ -146,18 +145,14 @@ namespace exception
                 UNORDERED_EPOINT("Mock hash function.");
             }
 
-            int result;
             switch(tag_) {
             case 1:
-                result = x.tag1_;
-                break;
+                return x.tag1_;
             case 2:
-                result = x.tag2_;
-                break;
+                return x.tag2_;
             default:
-                result = x.tag1_ + x.tag2_; 
+                return x.tag1_ + x.tag2_; 
             }
-            return static_cast<std::size_t>(result);
         }
 
         friend bool operator==(hash const& x1, hash const& x2) {
@@ -254,7 +249,7 @@ namespace exception
             UNORDERED_SCOPE(allocator::allocator()) {
                 UNORDERED_EPOINT("Mock allocator default constructor.");
             }
-            test::detail::tracker.allocator_ref();
+            detail::tracker.allocator_ref();
         }
 
         template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_)
@@ -262,7 +257,7 @@ namespace exception
             UNORDERED_SCOPE(allocator::allocator()) {
                 UNORDERED_EPOINT("Mock allocator template copy constructor.");
             }
-            test::detail::tracker.allocator_ref();
+            detail::tracker.allocator_ref();
         }
 
         allocator(allocator const& x) : tag_(x.tag_)
@@ -270,11 +265,11 @@ namespace exception
             UNORDERED_SCOPE(allocator::allocator()) {
                 UNORDERED_EPOINT("Mock allocator copy constructor.");
             }
-            test::detail::tracker.allocator_ref();
+            detail::tracker.allocator_ref();
         }
 
         ~allocator() {
-            test::detail::tracker.allocator_unref();
+            detail::tracker.allocator_unref();
         }
 
         allocator& operator=(allocator const& x) {
@@ -312,13 +307,13 @@ namespace exception
                 ptr = (T*) malloc(n * sizeof(T));
                 if(!ptr) throw std::bad_alloc();
             }
-            test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
+            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
             return pointer(ptr);
 
             //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
         }
 
-        pointer allocate(size_type n, void const*)
+        pointer allocate(size_type n, void const* u)
         {
             T* ptr = 0;
             UNORDERED_SCOPE(allocator::allocate(size_type, const_pointer)) {
@@ -328,7 +323,7 @@ namespace exception
                 ptr = (T*) malloc(n * sizeof(T));
                 if(!ptr) throw std::bad_alloc();
             }
-            test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
+            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
             return pointer(ptr);
 
             //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
@@ -338,32 +333,32 @@ namespace exception
         {
             //::operator delete((void*) p);
             if(p) {
-                test::detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
+                detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
                 using namespace std;
                 free(p);
             }
         }
 
         void construct(pointer p, T const& t) {
-            UNORDERED_SCOPE(allocator::construct(T*, T)) {
+            UNORDERED_SCOPE(allocator::construct(pointer, T)) {
                 UNORDERED_EPOINT("Mock allocator construct function.");
                 new(p) T(t);
             }
-            test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
         }
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            UNORDERED_SCOPE(allocator::construct(pointer, BOOST_FWD_REF(Args)...)) {
+#if defined(BOOST_UNORDERED_STD_FORWARD)
+        template<class... Args> void construct(pointer p, Args&&... args) {
+            UNORDERED_SCOPE(allocator::construct(pointer, Args&&...)) {
                 UNORDERED_EPOINT("Mock allocator construct function.");
-                new(p) T(boost::forward<Args>(args)...);
+                new(p) T(std::forward<Args>(args)...);
             }
-            test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
+            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
         }
 #endif
 
-        void destroy(T* p) {
-            test::detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
+        void destroy(pointer p) {
+            detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
             p->~T();
         }
 
@@ -373,10 +368,6 @@ namespace exception
             }
             return (std::numeric_limits<std::size_t>::max)();
         }
-
-        typedef true_type propagate_on_container_copy_assignment;
-        typedef true_type propagate_on_container_move_assignment;
-        typedef true_type propagate_on_container_swap;
     };
 
     template <class T>
@@ -405,186 +396,6 @@ namespace exception
         //}
         return x.tag_ != y.tag_;
     }
-
-    template <class T>
-    class allocator2
-    {
-    public:
-        int tag_;
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-        typedef T* pointer;
-        typedef T const* const_pointer;
-        typedef T& reference;
-        typedef T const& const_reference;
-        typedef T value_type;
-
-        template <class U> struct rebind { typedef allocator2<U> other; };
-
-        explicit allocator2(int t = 0) : tag_(t)
-        {
-            UNORDERED_SCOPE(allocator2::allocator2()) {
-                UNORDERED_EPOINT("Mock allocator2 default constructor.");
-            }
-            test::detail::tracker.allocator_ref();
-        }
-
-        allocator2(allocator<T> const& x) : tag_(x.tag_)
-        {
-            UNORDERED_SCOPE(allocator2::allocator2()) {
-                UNORDERED_EPOINT("Mock allocator2 constructor from allocator.");
-            }
-            test::detail::tracker.allocator_ref();
-        }
-
-        template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
-        {
-            UNORDERED_SCOPE(allocator2::allocator2()) {
-                UNORDERED_EPOINT("Mock allocator2 template copy constructor.");
-            }
-            test::detail::tracker.allocator_ref();
-        }
-
-        allocator2(allocator2 const& x) : tag_(x.tag_)
-        {
-            UNORDERED_SCOPE(allocator2::allocator2()) {
-                UNORDERED_EPOINT("Mock allocator2 copy constructor.");
-            }
-            test::detail::tracker.allocator_ref();
-        }
-
-        ~allocator2() {
-            test::detail::tracker.allocator_unref();
-        }
-
-        allocator2& operator=(allocator2 const& x) {
-            UNORDERED_SCOPE(allocator2::allocator2()) {
-                UNORDERED_EPOINT("Mock allocator2 assignment operator.");
-                tag_ = x.tag_;
-            }
-            return *this;
-        }
-
-        // If address throws, then it can't be used in erase or the
-        // destructor, which is very limiting. I need to check up on
-        // this.
-
-        pointer address(reference r) {
-            //UNORDERED_SCOPE(allocator2::address(reference)) {
-            //    UNORDERED_EPOINT("Mock allocator2 address function.");
-            //}
-            return pointer(&r);
-        }
-
-        const_pointer address(const_reference r)  {
-            //UNORDERED_SCOPE(allocator2::address(const_reference)) {
-            //    UNORDERED_EPOINT("Mock allocator2 const address function.");
-            //}
-            return const_pointer(&r);
-        }
-
-        pointer allocate(size_type n) {
-            T* ptr = 0;
-            UNORDERED_SCOPE(allocator2::allocate(size_type)) {
-                UNORDERED_EPOINT("Mock allocator2 allocate function.");
-
-                using namespace std;
-                ptr = (T*) malloc(n * sizeof(T));
-                if(!ptr) throw std::bad_alloc();
-            }
-            test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return pointer(ptr);
-
-            //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
-        }
-
-        pointer allocate(size_type n, void const*)
-        {
-            T* ptr = 0;
-            UNORDERED_SCOPE(allocator2::allocate(size_type, const_pointer)) {
-                UNORDERED_EPOINT("Mock allocator2 allocate function.");
-
-                using namespace std;
-                ptr = (T*) malloc(n * sizeof(T));
-                if(!ptr) throw std::bad_alloc();
-            }
-            test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return pointer(ptr);
-
-            //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
-        }
-
-        void deallocate(pointer p, size_type n)
-        {
-            //::operator delete((void*) p);
-            if(p) {
-                test::detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
-                using namespace std;
-                free(p);
-            }
-        }
-
-        void construct(pointer p, T const& t) {
-            UNORDERED_SCOPE(allocator2::construct(T*, T)) {
-                UNORDERED_EPOINT("Mock allocator2 construct function.");
-                new(p) T(t);
-            }
-            test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-        }
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            UNORDERED_SCOPE(allocator2::construct(pointer, BOOST_FWD_REF(Args)...)) {
-                UNORDERED_EPOINT("Mock allocator2 construct function.");
-                new(p) T(boost::forward<Args>(args)...);
-            }
-            test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-        }
-#endif
-
-        void destroy(T* p) {
-            test::detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
-            p->~T();
-        }
-
-        size_type max_size() const {
-            UNORDERED_SCOPE(allocator2::construct(pointer, T)) {
-                UNORDERED_EPOINT("Mock allocator2 max_size function.");
-            }
-            return (std::numeric_limits<std::size_t>::max)();
-        }
-
-        typedef false_type propagate_on_container_copy_assignment;
-        typedef false_type propagate_on_container_move_assignment;
-        typedef false_type propagate_on_container_swap;
-    };
-
-    template <class T>
-    void swap(allocator2<T>& x, allocator2<T>& y)
-    {
-        std::swap(x.tag_, y.tag_);
-    }
-
-    // It's pretty much impossible to write a compliant swap when these
-    // two can throw. So they don't.
-
-    template <class T>
-    inline bool operator==(allocator2<T> const& x, allocator2<T> const& y)
-    {
-        //UNORDERED_SCOPE(operator==(allocator2, allocator2)) {
-        //    UNORDERED_EPOINT("Mock allocator2 equality operator.");
-        //}
-        return x.tag_ == y.tag_;
-    }
-
-    template <class T>
-    inline bool operator!=(allocator2<T> const& x, allocator2<T> const& y)
-    {
-        //UNORDERED_SCOPE(operator!=(allocator2, allocator2)) {
-        //    UNORDERED_EPOINT("Mock allocator2 inequality operator.");
-        //}
-        return x.tag_ != y.tag_;
-    }
 }
 }
 
@@ -592,9 +403,8 @@ namespace exception
 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
 namespace test
 {
-    test::exception::object generate(test::exception::object const* x,
-        random_generator g) {
-        return test::exception::generate(x, g);
+    test::exception::object generate(test::exception::object const* x) {
+        return test::exception::generate(x);
     }
 }
 #endif

test/objects/minimal.hpp

@@ -11,64 +11,35 @@
 #define BOOST_UNORDERED_OBJECTS_MINIMAL_HEADER
 
 #include <cstddef>
-#include <boost/move/move.hpp>
-#include <utility>
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
 #pragma warning(disable:4100) // unreferenced formal parameter
 #endif
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, == 1500)
-#define BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED 1
-#else
-#define BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED 0
-#endif
-
 namespace test
 {
 namespace minimal
 {
-    class destructible;
     class copy_constructible;
     class copy_constructible_equality_comparable;
-    class default_assignable;
+    class default_copy_constructible;
     class assignable;
 
-    struct ampersand_operator_used {
-        ampersand_operator_used() { BOOST_TEST(false); }
-    };
+    struct ampersand_operator_used {};
 
     template <class T> class hash;
     template <class T> class equal_to;
     template <class T> class ptr;
     template <class T> class const_ptr;
     template <class T> class allocator;
-    template <class T> class cxx11_allocator;
-
-    struct constructor_param
-    {
-        operator int() const { return 0; }
-    };
-
-    class destructible
-    {
-    public:
-        destructible(constructor_param const&) {}
-        ~destructible() {}
-        void dummy_member() const {}
-    private:
-        destructible(destructible const&);
-        destructible& operator=(destructible const&);
-    };
 
     class copy_constructible
     {
     public:
-        copy_constructible(constructor_param const&) {}
+        static copy_constructible create() { return copy_constructible(); }
         copy_constructible(copy_constructible const&) {}
         ~copy_constructible() {}
-        void dummy_member() const {}
     private:
         copy_constructible& operator=(copy_constructible const&);
         copy_constructible() {}
@@ -77,7 +48,9 @@ namespace minimal
     class copy_constructible_equality_comparable
     {
     public:
-        copy_constructible_equality_comparable(constructor_param const&) {}
+        static copy_constructible_equality_comparable create() {
+            return copy_constructible_equality_comparable();
+        }
 
         copy_constructible_equality_comparable(
             copy_constructible_equality_comparable const&)
@@ -88,15 +61,11 @@ namespace minimal
         {
         }
 
-        void dummy_member() const {}
     private:
         copy_constructible_equality_comparable& operator=(
             copy_constructible_equality_comparable const&);
         copy_constructible_equality_comparable() {}
-#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
+        ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     bool operator==(
@@ -113,185 +82,90 @@ namespace minimal
         return false;
     }
 
-    class default_assignable
+    class default_copy_constructible
     {
     public:
-        default_assignable(constructor_param const&) {}
+        static default_copy_constructible create()
+        {
+            return default_copy_constructible();
+        }
 
-        default_assignable()
+        default_copy_constructible()
         {
         }
 
-        default_assignable(default_assignable const&)
+        default_copy_constructible(default_copy_constructible const&)
         {
         }
 
-        default_assignable& operator=(default_assignable const&)
-        {
-            return *this;
-        }
-
-        ~default_assignable()
+        ~default_copy_constructible()
         {
         }
 
-        void dummy_member() const {}
-
-#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
+    private:
+        default_copy_constructible& operator=(
+            default_copy_constructible const&);
+        ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     class assignable
     {
     public:
-        assignable(constructor_param const&) {}
+        static assignable create() { return assignable(); }
         assignable(assignable const&) {}
         assignable& operator=(assignable const&) { return *this; }
         ~assignable() {}
-        void dummy_member() const {}
+
     private:
         assignable() {}
-#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
+        // TODO: This messes up a concept check in the tests.
+        //ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
-    struct movable_init {};
-
-    class movable1
-    {
-        BOOST_MOVABLE_BUT_NOT_COPYABLE(movable1)
-
-    public:
-        movable1(constructor_param const&) {}
-        movable1() {}
-        explicit movable1(movable_init) {}
-        movable1(BOOST_RV_REF(movable1)) {}
-        movable1& operator=(BOOST_RV_REF(movable1)) { return *this; }
-        ~movable1() {}
-        void dummy_member() const {}
-    };
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    class movable2
-    {
-    public:
-        movable2(constructor_param const&) {}
-        explicit movable2(movable_init) {}
-        movable2(movable2&&) {}
-        ~movable2() {}
-        movable2& operator=(movable2&&) { return *this; }
-        void dummy_member() const {}
-    private:
-        movable2() {}
-        movable2(movable2 const&);
-        movable2& operator=(movable2 const&);
-    };
-#else
-    typedef movable1 movable2;
-#endif
-
     template <class T>
     class hash
     {
     public:
-        hash(constructor_param const&) {}
+        static hash create() { return hash<T>(); }
         hash() {}
         hash(hash const&) {}
         hash& operator=(hash const&) { return *this; }
         ~hash() {}
 
         std::size_t operator()(T const&) const { return 0; }
-#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
+    private:
+        ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     template <class T>
     class equal_to
     {
     public:
-        equal_to(constructor_param const&) {}
+        static equal_to create() { return equal_to<T>(); }
         equal_to() {}
         equal_to(equal_to const&) {}
         equal_to& operator=(equal_to const&) { return *this; }
         ~equal_to() {}
 
         bool operator()(T const&, T const&) const { return true; }
-#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
+    private:
+        ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     template <class T> class ptr;
     template <class T> class const_ptr;
 
-    struct void_ptr
-    {
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename T>
-        friend class ptr;
-    private:
-#endif
-
-        void* ptr_;
-
-    public:
-        void_ptr() : ptr_(0) {}
-
-        template <typename T>
-        explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
-
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
-
-        bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
-    };
-
-    class void_const_ptr
-    {
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename T>
-        friend class const_ptr;
-    private:
-#endif
-
-        void* ptr_;
-
-    public:
-        void_const_ptr() : ptr_(0) {}
-
-        template <typename T>
-        explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_) {}
-
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
-
-        bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
-    };
-
     template <class T>
     class ptr
     {
         friend class allocator<T>;
         friend class const_ptr<T>;
-        friend struct void_ptr;
 
         T* ptr_;
 
         ptr(T* x) : ptr_(x) {}
     public:
         ptr() : ptr_(0) {}
-        explicit ptr(void_ptr const& x) : ptr_((T*) x.ptr_) {}
 
         T& operator*() const { return *ptr_; }
         T* operator->() const { return ptr_; }
@@ -313,17 +187,22 @@ namespace minimal
         bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
         bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
         bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
-#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
+
+        bool operator==(const_ptr<T> const& x) const { return ptr_ == x.ptr_; }
+        bool operator!=(const_ptr<T> const& x) const { return ptr_ != x.ptr_; }
+        bool operator<(const_ptr<T> const& x) const { return ptr_ < x.ptr_; }
+        bool operator>(const_ptr<T> const& x) const { return ptr_ > x.ptr_; }
+        bool operator<=(const_ptr<T> const& x) const { return ptr_ <= x.ptr_; }
+        bool operator>=(const_ptr<T> const& x) const { return ptr_ >= x.ptr_; }
+    private:
+        // TODO:
+        //ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     template <class T>
     class const_ptr
     {
         friend class allocator<T>;
-        friend struct const_void_ptr;
 
         T const* ptr_;
 
@@ -331,7 +210,6 @@ namespace minimal
     public:
         const_ptr() : ptr_(0) {}
         const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
-        explicit const_ptr(void_const_ptr const& x) : ptr_((T const*) x.ptr_) {}
 
         T const& operator*() const { return *ptr_; }
         T const* operator->() const { return ptr_; }
@@ -345,16 +223,22 @@ namespace minimal
         bool operator!() const { return !ptr_; }
         operator bool() const { return !!ptr_; }
 
+        bool operator==(ptr<T> const& x) const { return ptr_ == x.ptr_; }
+        bool operator!=(ptr<T> const& x) const { return ptr_ != x.ptr_; }
+        bool operator<(ptr<T> const& x) const { return ptr_ < x.ptr_; }
+        bool operator>(ptr<T> const& x) const { return ptr_ > x.ptr_; }
+        bool operator<=(ptr<T> const& x) const { return ptr_ <= x.ptr_; }
+        bool operator>=(ptr<T> const& x) const { return ptr_ >= x.ptr_; }
+
         bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
         bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
         bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
         bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
         bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
         bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
-#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
+    private:
+        // TODO:
+        //ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     template <class T>
@@ -363,8 +247,6 @@ namespace minimal
     public:
         typedef std::size_t size_type;
         typedef std::ptrdiff_t difference_type;
-        typedef void_ptr void_pointer;
-        typedef void_const_ptr const_void_pointer;
         typedef ptr<T> pointer;
         typedef const_ptr<T> const_pointer;
         typedef T& reference;
@@ -386,7 +268,7 @@ namespace minimal
         }
 
         template <class Y>
-        pointer allocate(size_type n, const_ptr<Y>)
+        pointer allocate(size_type n, const_ptr<Y> u)
         {
             return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
         }
@@ -396,15 +278,15 @@ namespace minimal
             ::operator delete((void*) p.ptr_);
         }
 
-        void construct(T* p, T const& t) { new((void*)p) T(t); }
+        void construct(pointer p, T const& t) { new((void*)p.ptr_) T(t); }
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            new((void*)p) T(boost::forward<Args>(args)...);
+#if defined(BOOST_UNORDERED_STD_FORWARD)
+        template<class... Args> void construct(pointer p, Args&&... args) {
+            new((void*)p.ptr_) T(std::forward<Args>(args)...);
         }
 #endif
 
-        void destroy(T* p) { p->~T(); }
+        void destroy(pointer p) { ((T*)p.ptr_)->~T(); }
 
         size_type max_size() const { return 1000; }
 
@@ -414,10 +296,8 @@ namespace minimal
 #else
     private: allocator& operator=(allocator const&);
 #endif
-#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
+    private:
+        ampersand_operator_used operator&() const { return ampersand_operator_used(); }
     };
 
     template <class T>
@@ -436,69 +316,6 @@ namespace minimal
     void swap(allocator<T>&, allocator<T>&)
     {
     }
-
-    // C++11 allocator
-    //
-    // Not a fully minimal C++11 allocator, just what I support. Hopefully will
-    // cut down further in the future.
-
-    template <class T>
-    class cxx11_allocator
-    {
-    public:
-        typedef T value_type;
-        //template <class U> struct rebind { typedef cxx11_allocator<U> other; };
-
-        cxx11_allocator() {}
-        template <class Y> cxx11_allocator(cxx11_allocator<Y> const&) {}
-        cxx11_allocator(cxx11_allocator const&) {}
-        ~cxx11_allocator() {}
-
-        T* address(T& r) { return &r; }
-        T const* address(T const& r) { return &r; }
-
-        T* allocate(std::size_t n) {
-            return static_cast<T*>(::operator new(n * sizeof(T)));
-        }
-
-        template <class Y>
-        T* allocate(std::size_t n, const_ptr<Y>) {
-            return static_cast<T*>(::operator new(n * sizeof(T)));
-        }
-
-        void deallocate(T* p, std::size_t) {
-            ::operator delete((void*) p);
-        }
-
-        void construct(T* p, T const& t) { new((void*)p) T(t); }
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            new((void*)p) T(boost::forward<Args>(args)...);
-        }
-#endif
-
-        void destroy(T* p) { p->~T(); }
-
-        std::size_t max_size() const { return 1000u; }
-    };
-
-    template <class T>
-    inline bool operator==(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
-    {
-        return true;
-    }
-
-    template <class T>
-    inline bool operator!=(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
-    {
-        return false;
-    }
-
-    template <class T>
-    void swap(cxx11_allocator<T>&, cxx11_allocator<T>&)
-    {
-    }
 }
 }
 

test/objects/test.hpp

@@ -9,29 +9,26 @@
 #include <boost/config.hpp>
 #include <boost/limits.hpp>
 #include <cstddef>
+#include <iostream>
 #include "../helpers/fwd.hpp"
 #include "../helpers/count.hpp"
 #include "../helpers/memory.hpp"
+#include <map>
 
 namespace test
 {
     // Note that the default hash function will work for any equal_to (but not
     // very well).
     class object;
-    class movable;
     class implicitly_convertible;
     class hash;
     class less;
     class equal_to;
-    template <class T> class allocator1;
-    template <class T> class allocator2;
-    object generate(object const*, random_generator);
-    movable generate(movable const*, random_generator);
-    implicitly_convertible generate(implicitly_convertible const*, random_generator);
+    template <class T> class allocator;
+    object generate(object const*);
+    implicitly_convertible generate(implicitly_convertible const*);
 
-    inline void ignore_variable(void const*) {}
-
-    class object : private counted_object
+    class object : globally_counted_object
     {
         friend class hash;
         friend class equal_to;
@@ -58,9 +55,9 @@ namespace test
                 (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
         }
 
-        friend object generate(object const*, random_generator g) {
+        friend object generate(object const*) {
             int* x = 0;
-            return object(generate(x, g), generate(x, g));
+            return object(generate(x), generate(x));
         }
 
         friend std::ostream& operator<<(std::ostream& out, object const& o)
@@ -69,82 +66,7 @@ namespace test
         }
     };
 
-    class movable : private counted_object
-    {
-        friend class hash;
-        friend class equal_to;
-        friend class less;
-        int tag1_, tag2_;
-        
-        BOOST_COPYABLE_AND_MOVABLE(movable)
-    public:
-        explicit movable(int t1 = 0, int t2 = 0) : tag1_(t1), tag2_(t2) {}
-        
-        movable(movable const& x) :
-            counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
-        {
-            BOOST_TEST(x.tag1_ != -1);
-        }
-        
-        movable(BOOST_RV_REF(movable) x) :
-            counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
-        {
-            BOOST_TEST(x.tag1_ != -1);
-            x.tag1_ = -1;
-            x.tag2_ = -1;
-        }
-
-        movable& operator=(BOOST_COPY_ASSIGN_REF(movable) x) // Copy assignment
-        {
-            BOOST_TEST(x.tag1_ != -1);
-            tag1_ = x.tag1_;
-            tag2_ = x.tag2_;
-            return *this;
-        }
-
-        movable& operator=(BOOST_RV_REF(movable) x) //Move assignment
-        {
-            BOOST_TEST(x.tag1_ != -1);
-            tag1_ = x.tag1_;
-            tag2_ = x.tag2_;
-            x.tag1_ = -1;
-            x.tag2_ = -1;
-            return *this;
-        }
-
-        ~movable() {
-            tag1_ = -1;
-            tag2_ = -1;
-        }
-
-        friend bool operator==(movable const& x1, movable const& x2) {
-            BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
-            return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
-        }
-
-        friend bool operator!=(movable const& x1, movable const& x2) {
-            BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
-            return x1.tag1_ != x2.tag1_ || x1.tag2_ != x2.tag2_;
-        }
-
-        friend bool operator<(movable const& x1, movable const& x2) {
-            BOOST_TEST(x1.tag1_ != -1 && x2.tag1_ != -1);
-            return x1.tag1_ < x2.tag1_ ||
-                (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
-        }
-
-        friend movable generate(movable const*, random_generator g) {
-            int* x = 0;
-            return movable(generate(x, g), generate(x, g));
-        }
-
-        friend std::ostream& operator<<(std::ostream& out, movable const& o)
-        {
-            return out<<"("<<o.tag1_<<","<<o.tag2_<<")";
-        }
-    };
-
-    class implicitly_convertible : private counted_object
+    class implicitly_convertible : globally_counted_object
     {
         int tag1_, tag2_;
     public:
@@ -158,14 +80,9 @@ namespace test
             return object(tag1_, tag2_);
         }
 
-        operator movable() const
-        {
-            return movable(tag1_, tag2_);
-        }
-
-        friend implicitly_convertible generate(implicitly_convertible const*, random_generator g) {
+        friend implicitly_convertible generate(implicitly_convertible const*) {
             int* x = 0;
-            return implicitly_convertible(generate(x, g), generate(x, g));
+            return implicitly_convertible(generate(x), generate(x));
         }
 
         friend std::ostream& operator<<(std::ostream& out, implicitly_convertible const& o)
@@ -174,7 +91,6 @@ namespace test
         }
     };
 
-    // Note: This is a deliberately bad hash function.
     class hash
     {
         int type_;
@@ -182,48 +98,18 @@ namespace test
         explicit hash(int t = 0) : type_(t) {}
 
         std::size_t operator()(object const& x) const {
-            int result;
             switch(type_) {
             case 1:
-                result = x.tag1_;
-                break;
+                return x.tag1_;
             case 2:
-                result = x.tag2_;
-                break;
+                return x.tag2_;
             default:
-                result = x.tag1_ + x.tag2_; 
+                return x.tag1_ + x.tag2_; 
             }
-            return static_cast<std::size_t>(result);
-        }
-
-        std::size_t operator()(movable const& x) const {
-            int result;
-            switch(type_) {
-            case 1:
-                result = x.tag1_;
-                break;
-            case 2:
-                result = x.tag2_;
-                break;
-            default:
-                result = x.tag1_ + x.tag2_; 
-            }
-            return static_cast<std::size_t>(result);
         }
 
         std::size_t operator()(int x) const {
-            int result;
-            switch(type_) {
-            case 1:
-                result = x;
-                break;
-            case 2:
-                result = x * 7;
-                break;
-            default:
-                result = x * 256; 
-            }
-            return static_cast<std::size_t>(result);
+            return x;
         }
 
         friend bool operator==(hash const& x1, hash const& x2) {
@@ -239,10 +125,6 @@ namespace test
         return hash()(x);
     }
 
-    std::size_t hash_value(test::movable const& x) {
-        return hash()(x);
-    }
-
     class less
     {
         int type_;
@@ -260,17 +142,6 @@ namespace test
             }
         }
 
-        bool operator()(movable const& x1, movable const& x2) const {
-            switch(type_) {
-            case 1:
-                return x1.tag1_ < x2.tag1_;
-            case 2:
-                return x1.tag2_ < x2.tag2_;
-            default:
-                return x1 < x2;
-            }
-        }
-
         std::size_t operator()(int x1, int x2) const {
             return x1 < x2;
         }
@@ -297,17 +168,6 @@ namespace test
             }
         }
 
-        bool operator()(movable const& x1, movable const& x2) const {
-            switch(type_) {
-            case 1:
-                return x1.tag1_ == x2.tag1_;
-            case 2:
-                return x1.tag2_ == x2.tag2_;
-            default:
-                return x1 == x2;
-            }
-        }
-
         std::size_t operator()(int x1, int x2) const {
             return x1 == x2;
         }
@@ -325,253 +185,56 @@ namespace test
         }
     };
 
-    // allocator1 only has the old fashioned 'construct' method and has
-    // a few less typedefs. allocator2 uses a custom pointer class.
+    namespace detail
+    {
+        // This won't be a problem as I'm only using a single compile unit
+        // in each test (this is actually require by the minimal test
+        // framework).
+        // 
+        // boostinspect:nounnamed
+        namespace {
+            test::detail::memory_tracker<std::allocator<int> > tracker;
+        }
+    }
 
     template <class T>
-    class allocator1
-    {
-    public:
-        int tag_;
-
-        typedef T value_type;
-
-        template <class U> struct rebind { typedef allocator1<U> other; };
-
-        explicit allocator1(int t = 0) : tag_(t)
-        {
-            detail::tracker.allocator_ref();
-        }
-
-        template <class Y> allocator1(allocator1<Y> const& x)
-            : tag_(x.tag_)
-        {
-            detail::tracker.allocator_ref();
-        }
-
-        allocator1(allocator1 const& x)
-            : tag_(x.tag_)
-        {
-            detail::tracker.allocator_ref();
-        }
-
-        ~allocator1()
-        {
-            detail::tracker.allocator_unref();
-        }
-
-        T* allocate(std::size_t n) {
-            T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return ptr;
-        }
-
-        T* allocate(std::size_t n, void const*)
-        {
-            T* ptr(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return ptr;
-        }
-
-        void deallocate(T* p, std::size_t n)
-        {
-            detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
-            ::operator delete((void*) p);
-        }
-
-        void construct(T* p, T const& t) {
-            // Don't count constructions here as it isn't always called.
-            //detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(t);
-        }
-
-        void destroy(T* p) {
-            //detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
-            p->~T();
-
-            // Work around MSVC buggy unused parameter warning.
-            ignore_variable(&p);
-        }
-
-        bool operator==(allocator1 const& x) const
-        {
-            return tag_ == x.tag_;
-        }
-
-        bool operator!=(allocator1 const& x) const
-        {
-            return tag_ != x.tag_;
-        }
-
-        enum {
-            is_select_on_copy = false,
-            is_propagate_on_swap = false,
-            is_propagate_on_assign = false,
-            is_propagate_on_move = false
-        };
-    };
-
-    template <class T> class ptr;
-    template <class T> class const_ptr;
-
-    struct void_ptr
-    {
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename T>
-        friend class ptr;
-    private:
-#endif
-
-        void* ptr_;
-
-    public:
-        void_ptr() : ptr_(0) {}
-
-        template <typename T>
-        explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
-
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
-
-        bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
-    };
-
-    class void_const_ptr
-    {
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename T>
-        friend class const_ptr;
-    private:
-#endif
-
-        void* ptr_;
-
-    public:
-        void_const_ptr() : ptr_(0) {}
-
-        template <typename T>
-        explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_) {}
-
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
-
-        bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
-    };
-
-    template <class T>
-    class ptr
-    {
-        friend class allocator2<T>;
-        friend class const_ptr<T>;
-        friend struct void_ptr;
-
-        T* ptr_;
-
-        ptr(T* x) : ptr_(x) {}
-    public:
-        ptr() : ptr_(0) {}
-        explicit ptr(void_ptr const& x) : ptr_((T*) x.ptr_) {}
-
-        T& operator*() const { return *ptr_; }
-        T* operator->() const { return ptr_; }
-        ptr& operator++() { ++ptr_; return *this; }
-        ptr operator++(int) { ptr tmp(*this); ++ptr_; return tmp; }
-        ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
-        friend ptr operator+(std::ptrdiff_t s, ptr p)
-            { return ptr<T>(s + p.ptr_); }
-        T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
-        bool operator!() const { return !ptr_; }
-
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
-
-        bool operator==(ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(ptr const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(ptr const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
-    };
-
-    template <class T>
-    class const_ptr
-    {
-        friend class allocator2<T>;
-        friend struct const_void_ptr;
-
-        T const* ptr_;
-
-        const_ptr(T const* ptr) : ptr_(ptr) {}
-    public:
-        const_ptr() : ptr_(0) {}
-        const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
-        explicit const_ptr(void_const_ptr const& x) : ptr_((T const*) x.ptr_) {}
-
-        T const& operator*() const { return *ptr_; }
-        T const* operator->() const { return ptr_; }
-        const_ptr& operator++() { ++ptr_; return *this; }
-        const_ptr operator++(int) { const_ptr tmp(*this); ++ptr_; return tmp; }
-        const_ptr operator+(std::ptrdiff_t s) const
-            { return const_ptr(ptr_ + s); }
-        friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
-            { return ptr<T>(s + p.ptr_); }
-        T const& operator[](int s) const { return ptr_[s]; }
-        bool operator!() const { return !ptr_; }
-        operator bool() const { return !!ptr_; }
-
-        bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
-    };
-
-    template <class T>
-    class allocator2
+    class allocator
     {
 # ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
     public:
 # else
-        template <class> friend class allocator2;
+        template <class> friend class allocator;
 # endif
         int tag_;
     public:
         typedef std::size_t size_type;
         typedef std::ptrdiff_t difference_type;
-        typedef void_ptr void_pointer;
-        typedef void_const_ptr const_void_pointer;
-        typedef ptr<T> pointer;
-        typedef const_ptr<T> const_pointer;
+        typedef T* pointer;
+        typedef T const* const_pointer;
         typedef T& reference;
         typedef T const& const_reference;
         typedef T value_type;
 
-        template <class U> struct rebind { typedef allocator2<U> other; };
+        template <class U> struct rebind { typedef allocator<U> other; };
 
-        explicit allocator2(int t = 0) : tag_(t)
+        explicit allocator(int t = 0) : tag_(t)
         {
             detail::tracker.allocator_ref();
         }
         
-        template <class Y> allocator2(allocator2<Y> const& x)
+        template <class Y> allocator(allocator<Y> const& x)
             : tag_(x.tag_)
         {
             detail::tracker.allocator_ref();
         }
 
-        allocator2(allocator2 const& x)
+        allocator(allocator const& x)
             : tag_(x.tag_)
         {
             detail::tracker.allocator_ref();
         }
 
-        ~allocator2()
+        ~allocator()
         {
             detail::tracker.allocator_unref();
         }
@@ -587,12 +250,12 @@ namespace test
         }
 
         pointer allocate(size_type n) {
-            pointer p(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) p.ptr_, n, sizeof(T), tag_);
-            return p;
+            pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
+            return ptr;
         }
 
-        pointer allocate(size_type n, void const*)
+        pointer allocate(size_type n, void const* u)
         {
             pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
             detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
@@ -601,23 +264,23 @@ namespace test
 
         void deallocate(pointer p, size_type n)
         {
-            detail::tracker.track_deallocate((void*) p.ptr_, n, sizeof(T), tag_);
-            ::operator delete((void*) p.ptr_);
+            detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
+            ::operator delete((void*) p);
         }
 
-        void construct(T* p, T const& t) {
+        void construct(pointer p, T const& t) {
             detail::tracker.track_construct((void*) p, sizeof(T), tag_);
             new(p) T(t);
         }
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
+#if defined(BOOST_UNORDERED_STD_FORWARD)
+        template<class... Args> void construct(pointer p, Args&&... args) {
             detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(boost::forward<Args>(args)...);
+            new(p) T(std::forward<Args>(args)...);
         }
 #endif
 
-        void destroy(T* p) {
+        void destroy(pointer p) {
             detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
             p->~T();
         }
@@ -626,33 +289,19 @@ namespace test
             return (std::numeric_limits<size_type>::max)();
         }
 
-        bool operator==(allocator2 const& x) const
+        bool operator==(allocator const& x) const
         {
             return tag_ == x.tag_;
         }
 
-        bool operator!=(allocator2 const& x) const
+        bool operator!=(allocator const& x) const
         {
             return tag_ != x.tag_;
         }
-
-        enum {
-            is_select_on_copy = false,
-            is_propagate_on_swap = false,
-            is_propagate_on_assign = false,
-            is_propagate_on_move = false
-        };
     };
 
     template <class T>
-    bool equivalent_impl(allocator1<T> const& x, allocator1<T> const& y,
-        test::derived_type)
-    {
-        return x == y;
-    }
-
-    template <class T>
-    bool equivalent_impl(allocator2<T> const& x, allocator2<T> const& y,
+    bool equivalent_impl(allocator<T> const& x, allocator<T> const& y,
         test::derived_type)
     {
         return x == y;

test/unordered/Jamfile.v2

@@ -0,0 +1,47 @@
+
+# Copyright 2006-2008 Daniel James.
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+import testing ;
+
+project unordered-test/unordered
+    : requirements
+        <warnings>all
+        <toolset>intel:<warnings>on
+        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion"
+        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion"
+        <toolset>gcc:<define>_GLIBCXX_DEBUG
+        #<toolset>darwin:<define>_GLIBCXX_DEBUG
+        <toolset>msvc:<warnings-as-errors>on
+        #<toolset>gcc:<warnings-as-errors>on
+        #<toolset>darwin:<warnings-as-errors>on
+    ;
+
+test-suite unordered
+    :
+        [ run fwd_set_test.cpp ]
+        [ run fwd_map_test.cpp ]
+        [ run compile_set.cpp ]
+        [ run compile_map.cpp ]
+        [ run link_test_1.cpp link_test_2.cpp ]
+        [ run incomplete_test.cpp ]
+        [ run simple_tests.cpp ]
+        [ run equivalent_keys_tests.cpp ]
+        [ run constructor_tests.cpp ]
+        [ run copy_tests.cpp ]
+        [ run move_tests.cpp ]
+        [ run assign_tests.cpp ]
+        [ run insert_tests.cpp ]
+        [ run insert_stable_tests.cpp ]
+        [ run unnecessary_copy_tests.cpp ]
+        [ run erase_tests.cpp ]
+        [ run erase_equiv_tests.cpp ]
+        [ run find_tests.cpp ]
+        [ run at_tests.cpp ]
+        [ run bucket_tests.cpp ]
+        [ run load_factor_tests.cpp ]
+        [ run rehash_tests.cpp ]
+        [ run equality_tests.cpp ]
+        [ run swap_tests.cpp : : : <define>BOOST_UNORDERED_SWAP_METHOD=2 ]
+    ;

test/unordered/allocator_traits.cpp

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

test/unordered/assign_tests.cpp

@@ -4,36 +4,30 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
 #include "../helpers/test.hpp"
 #include "../objects/test.hpp"
-#include "../objects/cxx11_allocator.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
 #include "../helpers/equivalent.hpp"
 
 #include <iostream>
 
-#if defined(BOOST_MSVC)
-#pragma warning(disable:4127) // conditional expression is constant
-#endif
-
 namespace assign_tests {
 
-test::seed_t initialize_seed(96785);
+test::seed_t seed(96785);
 
 template <class T>
-void assign_tests1(T*, test::random_generator generator)
+void assign_tests1(T*,
+    test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
 
     std::cerr<<"assign_tests1.1\n";
     {
-        test::check_instances check_;
-
         T x;
         x = x;
         BOOST_TEST(x.empty());
@@ -43,8 +37,6 @@ void assign_tests1(T*, test::random_generator generator)
 
     std::cerr<<"assign_tests1.2\n";
     {
-        test::check_instances check_;
-
         test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end());
 
@@ -56,18 +48,15 @@ void assign_tests1(T*, test::random_generator generator)
 
         T y;
         y.max_load_factor(x.max_load_factor() / 20);
-        float mlf = x.max_load_factor();
         y = x;
-        tracker.compare(x);
         tracker.compare(y);
-        BOOST_TEST(x.max_load_factor() == mlf);
-        BOOST_TEST(y.max_load_factor() == mlf);
-        BOOST_TEST(y.load_factor() <= y.max_load_factor());
+        BOOST_TEST(x.max_load_factor() == y.max_load_factor());
     }
 }
 
 template <class T>
-void assign_tests2(T*, test::random_generator generator)
+void assign_tests2(T*,
+    test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
     BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
@@ -75,214 +64,58 @@ void assign_tests2(T*, test::random_generator generator)
     BOOST_DEDUCED_TYPENAME T::key_equal eq2(2);
     BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
-    
-    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
-
-    std::cerr<<"assign_tests2.0 - empty container\n";
-    {
-        test::check_instances check_;
-
-        T x1(0, hf1, eq1);
-        T x2(0, hf2, eq2);
-        x2 = x1;
-        BOOST_TEST(test::equivalent(x1.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x1.key_eq(), eq1));
-        BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
-        test::check_container(x1, x2);
-    }
 
     std::cerr<<"assign_tests2.1\n";
     {
-        test::check_instances check_;
-
         test::random_values<T> v(1000, generator);
         T x1(v.begin(), v.end(), 0, hf1, eq1);
         T x2(0, hf2, eq2);
         x2 = x1;
-        BOOST_TEST(test::equivalent(x1.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x1.key_eq(), eq1));
         BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
         BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
-        test::check_container(x1, v);
         test::check_container(x2, v);
-        BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
-    }
-
-    std::cerr<<"assign_tests2.1a\n";
-    {
-        test::check_instances check_;
-
-        test::random_values<T> v1(0, generator);
-        test::random_values<T> v2(1000, generator);
-        T x1(0, hf2, eq2);
-        T x2(v2.begin(), v2.end(), 0, hf1, eq1);
-        x2 = x1;
-        BOOST_TEST(test::equivalent(x1.hash_function(), hf2));
-        BOOST_TEST(test::equivalent(x1.key_eq(), eq2));
-        BOOST_TEST(test::equivalent(x2.hash_function(), hf2));
-        BOOST_TEST(test::equivalent(x2.key_eq(), eq2));
-        test::check_container(x1, v1);
-        test::check_container(x2, v1);
-        BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
     std::cerr<<"assign_tests2.2\n";
     {
-        test::check_instances check_;
-
         test::random_values<T> v1(100, generator), v2(100, generator);
         T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
         T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
         x2 = x1;
         BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
         BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
-        if (allocator_type::is_propagate_on_assign) {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
-        }
-        else {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
-        }
-        test::check_container(x1, v1);
+        BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
         test::check_container(x2, v1);
-        BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
-    }
-
-    std::cerr<<"assign_tests2.3\n";
-    {
-        test::check_instances check_;
-
-        test::random_values<T> v1(100, generator), v2(1000, generator);
-        T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
-        T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
-        x2 = x1;
-        BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
-        if (allocator_type::is_propagate_on_assign) {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
-        }
-        else {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
-        }
-        test::check_container(x1, v1);
-        test::check_container(x2, v1);
-        BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
-    }
-
-    std::cerr<<"assign_tests2.4\n";
-    {
-        test::check_instances check_;
-
-        test::random_values<T> v1(1000, generator), v2(100, generator);
-        T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
-        T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
-        x2 = x1;
-        BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
-        BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
-        if (allocator_type::is_propagate_on_assign) {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al1));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al2));
-        }
-        else {
-            BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
-            BOOST_TEST(!test::equivalent(x2.get_allocator(), al1));
-        }
-        test::check_container(x1, v1);
-        test::check_container(x2, v1);
-        BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 }
 
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
-    std::allocator<test::object> >* test_map_std_alloc;
-
 boost::unordered_set<test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_set;
+    test::allocator<test::object> >* test_set;
 boost::unordered_multiset<test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_multiset;
+    test::allocator<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_map;
+    test::allocator<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_multimap;
-
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_assign> >*
-    test_set_prop_assign;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_assign> >*
-    test_multiset_prop_assign;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_assign> >*
-    test_map_prop_assign;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_assign> >*
-    test_multimap_prop_assign;
-
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
-    test_set_no_prop_assign;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
-    test_multiset_no_prop_assign;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
-    test_map_no_prop_assign;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_assign> >*
-    test_multimap_no_prop_assign;
+    test::allocator<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
-using test::limited_range;
 
-template <typename T>
-bool is_propagate(T*)
-{
-    return T::allocator_type::is_propagate_on_assign;
-}
-
-UNORDERED_AUTO_TEST(check_traits)
-{
-    BOOST_TEST(!is_propagate(test_set));
-    BOOST_TEST(is_propagate(test_set_prop_assign));
-    BOOST_TEST(!is_propagate(test_set_no_prop_assign));
-}
-
-UNORDERED_TEST(assign_tests1, (
-        (test_map_std_alloc)
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_prop_assign)(test_multiset_prop_assign)(test_map_prop_assign)(test_multimap_prop_assign)
-        (test_set_no_prop_assign)(test_multiset_no_prop_assign)(test_map_no_prop_assign)(test_multimap_no_prop_assign)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
+UNORDERED_TEST(assign_tests1,
+    ((test_set)(test_multiset)(test_map)(test_multimap))
+    ((default_generator)(generate_collisions))
 )
 
-UNORDERED_TEST(assign_tests2, (
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_prop_assign)(test_multiset_prop_assign)(test_map_prop_assign)(test_multimap_prop_assign)
-        (test_set_no_prop_assign)(test_multiset_no_prop_assign)(test_map_no_prop_assign)(test_multimap_no_prop_assign)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
+UNORDERED_TEST(assign_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap))
+    ((default_generator)(generate_collisions))
 )
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
 
 UNORDERED_AUTO_TEST(assign_default_initializer_list) {
     std::cerr<<"Initializer List Tests\n";
@@ -297,7 +130,9 @@ UNORDERED_AUTO_TEST(assign_default_initializer_list) {
 
 #endif
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST) && \
+    !defined(BOOST_NO_INITIALIZER_LISTS)
+
 UNORDERED_AUTO_TEST(assign_initializer_list)
 {
     std::cerr<<"Initializer List Tests\n";

test/unordered/at_tests.cpp

@@ -4,39 +4,29 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
-#include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
 
+#include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
 #include <string>
 
 namespace at_tests {
 
 UNORDERED_AUTO_TEST(at_tests) {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Create Map" << std::endl;
-
     boost::unordered_map<std::string, int> x;
-
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Add elements" << std::endl;
+    typedef boost::unordered_map<std::string, int>::iterator iterator;
 
     x["one"] = 1;
     x["two"] = 2;
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check existing elements" << std::endl;
-
     BOOST_TEST(x.at("one") == 1);
     BOOST_TEST(x.at("two") == 2);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check missing element" << std::endl;
-
     try {
         x.at("three");
         BOOST_ERROR("Should have thrown.");
     }
     catch(std::out_of_range) {
     }
-
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Finished" << std::endl;
 }
 
 }

test/unordered/bucket_tests.cpp

@@ -4,10 +4,9 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
 #include <algorithm>
 #include "../objects/test.hpp"
@@ -21,23 +20,19 @@
 
 namespace bucket_tests {
 
-test::seed_t initialize_seed(54635);
+test::seed_t seed(54635);
 
 template <class X>
-void tests(X*, test::random_generator generator)
+void tests(X* = 0, test::random_generator generator = test::default_generator)
 {
-    test::check_instances check_;
-
     typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
     typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
     test::random_values<X> v(1000, generator);
 
     X x(v.begin(), v.end());
 
-    BOOST_TEST(x.bucket_count() <= x.max_bucket_count());
-    if (!(x.bucket_count() <= x.max_bucket_count())) {
-       std::cerr<<x.bucket_count()<<"<="<<x.max_bucket_count()<<"\n";
-    }
+    BOOST_TEST(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
             it = v.begin(), end = v.end(); it != end; ++it)
@@ -45,7 +40,7 @@ void tests(X*, test::random_generator generator)
         size_type bucket = x.bucket(test::get_key<X>(*it));
 
         BOOST_TEST(bucket < x.bucket_count());
-        if(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
@@ -70,31 +65,20 @@ void tests(X*, test::random_generator generator)
     }
 }
 
-boost::unordered_multimap<test::object, test::object,
-    test::hash, test::equal_to,
-    std::allocator<test::object> >* test_multimap_std_alloc;
-
 boost::unordered_set<test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_set;
+    test::allocator<test::object> >* test_set;
 boost::unordered_multiset<test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_multiset;
+    test::allocator<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_map;
+    test::allocator<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_multimap;
+    test::allocator<test::object> >* test_multimap;
 
-using test::default_generator;
-using test::generate_collisions;
-using test::limited_range;
-
-UNORDERED_TEST(tests,
-    ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
+UNORDERED_TEST(tests, ((test_set)(test_multiset)(test_map)(test_multimap)))
 
 }
 

test/unordered/compile_map.cpp

@@ -7,8 +7,8 @@
 // requirements. Makes sure everything compiles and is defined correctly.
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
 
 #include <iostream>
 #include "../helpers/test.hpp"
@@ -18,119 +18,81 @@
 // Explicit instantiation to catch compile-time errors
 
 template class boost::unordered_map<
-    int,
-    int,
-    boost::hash<int>,
-    std::equal_to<int>,
-    test::minimal::allocator<std::pair<int const, int> > >;
-template class boost::unordered_multimap<
-    int const,
-    int const,
-    boost::hash<int>,
-    std::equal_to<int>,
-    test::minimal::allocator<std::pair<int const, int> > >;
-
-template class boost::unordered_map<
-    test::minimal::assignable const,
-    test::minimal::default_assignable const,
+    test::minimal::assignable,
+    test::minimal::default_copy_constructible,
     test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<test::minimal::assignable> >;
 template class boost::unordered_multimap<
     test::minimal::assignable,
-    test::minimal::assignable,
+    test::minimal::copy_constructible,
     test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<test::minimal::assignable> >;
 
 UNORDERED_AUTO_TEST(test0)
 {
-    test::minimal::constructor_param x;
-
     typedef std::pair<test::minimal::assignable const,
-            test::minimal::assignable> value_type;
-    value_type value(x, x);
+            test::minimal::copy_constructible> value_type;
+    value_type value(
+            test::minimal::assignable::create(),
+            test::minimal::copy_constructible::create());
 
     std::cout<<"Test unordered_map.\n";
 
     boost::unordered_map<int, int> int_map;
 
-    boost::unordered_map<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > int_map2;
-
     boost::unordered_map<
         test::minimal::assignable,
-        test::minimal::assignable,
+        test::minimal::copy_constructible,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
         test::minimal::allocator<value_type> > map;
 
     container_test(int_map, std::pair<int const, int>(0, 0));
-    container_test(int_map2, std::pair<int const, int>(0, 0));
     container_test(map, value);
 
     std::cout<<"Test unordered_multimap.\n";
 
     boost::unordered_multimap<int, int> int_multimap;
 
-    boost::unordered_multimap<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > int_multimap2;
-
     boost::unordered_multimap<
         test::minimal::assignable,
-        test::minimal::assignable,
+        test::minimal::copy_constructible,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
         test::minimal::allocator<value_type> > multimap;
 
     container_test(int_multimap, std::pair<int const, int>(0, 0));
-    container_test(int_multimap2, std::pair<int const, int>(0, 0));
     container_test(multimap, value);
 }
 
 UNORDERED_AUTO_TEST(equality_tests) {
-    typedef std::pair<
-            test::minimal::copy_constructible_equality_comparable const,
-            test::minimal::copy_constructible_equality_comparable> value_type;
+    typedef std::pair<test::minimal::assignable const,
+            test::minimal::copy_constructible> value_type;
 
     boost::unordered_map<int, int> int_map;
 
-    boost::unordered_map<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > int_map2;
-
     boost::unordered_map<
+        test::minimal::assignable,
         test::minimal::copy_constructible_equality_comparable,
-        test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
         test::minimal::allocator<value_type> > map;
 
     equality_test(int_map);
-    equality_test(int_map2);
     equality_test(map);
 
     boost::unordered_multimap<int, int> int_multimap;
 
-    boost::unordered_multimap<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > int_multimap2;
-
     boost::unordered_multimap<
+        test::minimal::assignable,
         test::minimal::copy_constructible_equality_comparable,
-        test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
         test::minimal::allocator<value_type> > multimap;
 
     equality_test(int_multimap);
-    equality_test(int_multimap2);
     equality_test(multimap);
 }
 
@@ -144,90 +106,72 @@ UNORDERED_AUTO_TEST(test1) {
 
     boost::unordered_map<int, int> map;
 
-    boost::unordered_map<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > map2;
-
     unordered_unique_test(map, map_value);
     unordered_map_test(map, value, value);
-    unordered_copyable_test(map, value, map_value, hash, equal_to);
+    unordered_test(map, value, map_value, hash, equal_to);
     unordered_map_functions(map, value, value);
 
-    unordered_unique_test(map2, map_value);
-    unordered_map_test(map2, value, value);
-    unordered_copyable_test(map2, value, map_value, hash, equal_to);
-    unordered_map_functions(map2, value, value);
-
     std::cout<<"Test unordered_multimap.\n";
 
     boost::unordered_multimap<int, int> multimap;
 
-    boost::unordered_multimap<int, int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<std::pair<int const, int> >
-        > multimap2;
-
     unordered_equivalent_test(multimap, map_value);
     unordered_map_test(multimap, value, value);
-    unordered_copyable_test(multimap, value, map_value, hash, equal_to);
-
-    unordered_equivalent_test(multimap2, map_value);
-    unordered_map_test(multimap2, value, value);
-    unordered_copyable_test(multimap2, value, map_value, hash, equal_to);
+    unordered_test(multimap, value, map_value, hash, equal_to);
 }
 
 UNORDERED_AUTO_TEST(test2)
 {
-    test::minimal::constructor_param x;
-
-    test::minimal::assignable assignable(x);
-    test::minimal::copy_constructible copy_constructible(x);
-    test::minimal::hash<test::minimal::assignable> hash(x);
-    test::minimal::equal_to<test::minimal::assignable> equal_to(x);
+    test::minimal::assignable assignable
+        = test::minimal::assignable::create();
+    test::minimal::copy_constructible copy_constructible
+        = test::minimal::copy_constructible::create();
+    test::minimal::hash<test::minimal::assignable> hash
+        = test::minimal::hash<test::minimal::assignable>::create();
+    test::minimal::equal_to<test::minimal::assignable> equal_to
+        = test::minimal::equal_to<test::minimal::assignable>::create();
 
     typedef std::pair<test::minimal::assignable const,
-            test::minimal::assignable> map_value_type;
-    map_value_type map_value(assignable, assignable);
+            test::minimal::copy_constructible> map_value_type;
+    map_value_type map_value(assignable, copy_constructible);
 
     std::cout<<"Test unordered_map.\n";
 
     boost::unordered_map<
         test::minimal::assignable,
-        test::minimal::assignable,
+        test::minimal::copy_constructible,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
         test::minimal::allocator<map_value_type> > map;
 
     unordered_unique_test(map, map_value);
-    unordered_map_test(map, assignable, assignable);
-    unordered_copyable_test(map, assignable, map_value, hash, equal_to);
-    unordered_map_member_test(map, map_value);
+    unordered_map_test(map, assignable, copy_constructible);
+    unordered_test(map, assignable, map_value, hash, equal_to);
+
 
     boost::unordered_map<
         test::minimal::assignable,
-        test::minimal::default_assignable,
+        test::minimal::default_copy_constructible,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
         test::minimal::allocator<map_value_type> > map2;
 
-    test::minimal::default_assignable default_assignable;
+    test::minimal::default_copy_constructible default_copy_constructible;
 
-    unordered_map_functions(map2, assignable, default_assignable);
+    unordered_map_functions(map2, assignable, default_copy_constructible);
 
     std::cout<<"Test unordered_multimap.\n";
 
     boost::unordered_multimap<
         test::minimal::assignable,
-        test::minimal::assignable,
+        test::minimal::copy_constructible,
         test::minimal::hash<test::minimal::assignable>,
         test::minimal::equal_to<test::minimal::assignable>,
         test::minimal::allocator<map_value_type> > multimap;
 
     unordered_equivalent_test(multimap, map_value);
-    unordered_map_test(multimap, assignable, assignable);
-    unordered_copyable_test(multimap, assignable, map_value, hash, equal_to);
-    unordered_map_member_test(multimap, map_value);
+    unordered_map_test(multimap, assignable, copy_constructible);
+    unordered_test(multimap, assignable, map_value, hash, equal_to);
 }
 
 RUN_TESTS()

test/unordered/compile_set.cpp

@@ -7,8 +7,8 @@
 // requirements. Makes sure everything compiles and is defined correctly.
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
-#include "../helpers/postfix.hpp"
 
 #include <iostream>
 #include "../helpers/test.hpp"
@@ -18,18 +18,7 @@
 // Explicit instantiation to catch compile-time errors
 
 template class boost::unordered_set<
-    int,
-    boost::hash<int>,
-    std::equal_to<int>,
-    test::minimal::allocator<int> >;
-template class boost::unordered_multiset<
-    int const,
-    boost::hash<int>,
-    std::equal_to<int>,
-    test::minimal::allocator<int> >;
-
-template class boost::unordered_set<
-    test::minimal::assignable const,
+    test::minimal::assignable,
     test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<test::minimal::assignable> >;
@@ -41,19 +30,10 @@ template class boost::unordered_multiset<
 
 UNORDERED_AUTO_TEST(test0)
 {
-    test::minimal::constructor_param x;
-
-    test::minimal::assignable assignable(x);
+    test::minimal::assignable assignable = test::minimal::assignable::create();
 
     std::cout<<"Test unordered_set.\n";
-
     boost::unordered_set<int> int_set;
-
-    boost::unordered_set<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > int_set2;
-
     boost::unordered_set<
         test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
@@ -61,18 +41,10 @@ UNORDERED_AUTO_TEST(test0)
         test::minimal::allocator<test::minimal::assignable> > set;
 
     container_test(int_set, 0);
-    container_test(int_set2, 0);
     container_test(set, assignable);
 
     std::cout<<"Test unordered_multiset.\n";
-
     boost::unordered_multiset<int> int_multiset;
-
-    boost::unordered_multiset<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > int_multiset2;
-
     boost::unordered_multiset<
         test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
@@ -80,45 +52,32 @@ UNORDERED_AUTO_TEST(test0)
         test::minimal::allocator<test::minimal::assignable> > multiset;
 
     container_test(int_multiset, 0);
-    container_test(int_multiset2, 0);
     container_test(multiset, assignable);
 }
 
 UNORDERED_AUTO_TEST(equality_tests) {
-    typedef test::minimal::copy_constructible_equality_comparable value_type;
+    typedef test::minimal::assignable value_type;
 
     boost::unordered_set<int> int_set;
 
-    boost::unordered_set<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > int_set2;
-
     boost::unordered_set<
-        test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::assignable,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
         test::minimal::allocator<value_type> > set;
 
     equality_test(int_set);
-    equality_test(int_set2);
     equality_test(set);
 
     boost::unordered_multiset<int> int_multiset;
 
-    boost::unordered_multiset<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > int_multiset2;
-
     boost::unordered_multiset<
-        test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
+        test::minimal::assignable,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
         test::minimal::allocator<value_type> > multiset;
 
     equality_test(int_multiset);
-    equality_test(int_multiset2);
     equality_test(multiset);
 }
 
@@ -128,49 +87,33 @@ UNORDERED_AUTO_TEST(test1)
     std::equal_to<int> equal_to;
     int value = 0;
 
-    std::cout<<"Test unordered_set." << std::endl;
+    std::cout<<"Test unordered_set.\n";
 
     boost::unordered_set<int> set;
     
-    boost::unordered_set<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > set2;
-
     unordered_unique_test(set, value);
     unordered_set_test(set, value);
-    unordered_copyable_test(set, value, value, hash, equal_to);
+    unordered_test(set, value, value, hash, equal_to);
 
-    unordered_unique_test(set2, value);
-    unordered_set_test(set2, value);
-    unordered_copyable_test(set2, value, value, hash, equal_to);
-
-    std::cout<<"Test unordered_multiset." << std::endl;
+    std::cout<<"Test unordered_multiset.\n";
 
     boost::unordered_multiset<int> multiset;
     
-    boost::unordered_multiset<int,
-        boost::hash<int>, std::equal_to<int>,
-        test::minimal::cxx11_allocator<int>
-        > multiset2;
-
     unordered_equivalent_test(multiset, value);
     unordered_set_test(multiset, value);
-    unordered_copyable_test(multiset, value, value, hash, equal_to);
-
-    unordered_equivalent_test(multiset2, value);
-    unordered_set_test(multiset2, value);
-    unordered_copyable_test(multiset2, value, value, hash, equal_to);
+    unordered_test(multiset, value, value, hash, equal_to);
 }
 
 UNORDERED_AUTO_TEST(test2)
 {
-    test::minimal::constructor_param x;
- 
-    test::minimal::assignable assignable(x);
-    test::minimal::copy_constructible copy_constructible(x);
-    test::minimal::hash<test::minimal::assignable> hash(x);
-    test::minimal::equal_to<test::minimal::assignable> equal_to(x);
+    test::minimal::assignable assignable
+        = test::minimal::assignable::create();
+    test::minimal::copy_constructible copy_constructible
+        = test::minimal::copy_constructible::create();
+    test::minimal::hash<test::minimal::assignable> hash
+        = test::minimal::hash<test::minimal::assignable>::create();
+    test::minimal::equal_to<test::minimal::assignable> equal_to
+        = test::minimal::equal_to<test::minimal::assignable>::create();
 
     std::cout<<"Test unordered_set.\n";
 
@@ -182,8 +125,7 @@ UNORDERED_AUTO_TEST(test2)
 
     unordered_unique_test(set, assignable);
     unordered_set_test(set, assignable);
-    unordered_copyable_test(set, assignable, assignable, hash, equal_to);
-    unordered_set_member_test(set, assignable);
+    unordered_test(set, assignable, assignable, hash, equal_to);
 
     std::cout<<"Test unordered_multiset.\n";
 
@@ -195,101 +137,7 @@ UNORDERED_AUTO_TEST(test2)
 
     unordered_equivalent_test(multiset, assignable);
     unordered_set_test(multiset, assignable);
-    unordered_copyable_test(multiset, assignable, assignable, hash, equal_to);
-    unordered_set_member_test(multiset, assignable);
-}
-
-UNORDERED_AUTO_TEST(movable1_tests)
-{
-    test::minimal::constructor_param x;
-
-    test::minimal::movable1 movable1(x);
-    test::minimal::hash<test::minimal::movable1> hash(x);
-    test::minimal::equal_to<test::minimal::movable1> equal_to(x);
-
-    std::cout<<"Test unordered_set.\n";
-
-    boost::unordered_set<
-        test::minimal::movable1,
-        test::minimal::hash<test::minimal::movable1>,
-        test::minimal::equal_to<test::minimal::movable1>,
-        test::minimal::allocator<test::minimal::movable1> > set;
-
-    //unordered_unique_test(set, movable1);
-    unordered_set_test(set, movable1);
-    unordered_movable_test(set, movable1, movable1, hash, equal_to);
-
-    std::cout<<"Test unordered_multiset.\n";
-
-    boost::unordered_multiset<
-        test::minimal::movable1,
-        test::minimal::hash<test::minimal::movable1>,
-        test::minimal::equal_to<test::minimal::movable1>,
-        test::minimal::allocator<test::minimal::movable1> > multiset;
-
-    //unordered_equivalent_test(multiset, movable1);
-    unordered_set_test(multiset, movable1);
-    unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
-}
-
-UNORDERED_AUTO_TEST(movable2_tests)
-{
-    test::minimal::constructor_param x;
-
-    test::minimal::movable2 movable2(x);
-    test::minimal::hash<test::minimal::movable2> hash(x);
-    test::minimal::equal_to<test::minimal::movable2> equal_to(x);
-
-    std::cout<<"Test unordered_set.\n";
-
-    boost::unordered_set<
-        test::minimal::movable2,
-        test::minimal::hash<test::minimal::movable2>,
-        test::minimal::equal_to<test::minimal::movable2>,
-        test::minimal::allocator<test::minimal::movable2> > set;
-
-    //unordered_unique_test(set, movable2);
-    unordered_set_test(set, movable2);
-    unordered_movable_test(set, movable2, movable2, hash, equal_to);
-
-    std::cout<<"Test unordered_multiset.\n";
-
-    boost::unordered_multiset<
-        test::minimal::movable2,
-        test::minimal::hash<test::minimal::movable2>,
-        test::minimal::equal_to<test::minimal::movable2>,
-        test::minimal::allocator<test::minimal::movable2> > multiset;
-
-    //unordered_equivalent_test(multiset, movable2);
-    unordered_set_test(multiset, movable2);
-    unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
-}
-
-UNORDERED_AUTO_TEST(destructible_tests)
-{
-    test::minimal::constructor_param x;
-
-    test::minimal::destructible destructible(x);
-    test::minimal::hash<test::minimal::destructible> hash(x);
-    test::minimal::equal_to<test::minimal::destructible> equal_to(x);
-
-    std::cout<<"Test unordered_set.\n";
-
-    boost::unordered_set<
-        test::minimal::destructible,
-        test::minimal::hash<test::minimal::destructible>,
-        test::minimal::equal_to<test::minimal::destructible> > set;
-
-    unordered_destructible_test(set);
-
-    std::cout<<"Test unordered_multiset.\n";
-
-    boost::unordered_multiset<
-        test::minimal::destructible,
-        test::minimal::hash<test::minimal::destructible>,
-        test::minimal::equal_to<test::minimal::destructible> > multiset;
-
-    unordered_destructible_test(multiset);
+    unordered_test(multiset, assignable, assignable, hash, equal_to);
 }
 
 RUN_TESTS()

test/unordered/compile_tests.hpp

@@ -16,19 +16,18 @@
 #pragma warning(pop)
 #endif
 
-#include <boost/static_assert.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/bool.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/limits.hpp>
-#include <boost/utility/swap.hpp>
 #include "../helpers/check_return_type.hpp"
 
 typedef long double comparison_type;
 
 template <class T> void sink(T const&) {}
 template <class T> T rvalue(T const& v) { return v; }
-template <class T> T rvalue_default() { return T(); }
 
 template <class X, class T>
 void container_test(X& r, T const&)
@@ -54,44 +53,47 @@ void container_test(X& r, T const&)
 
     // value_type
 
-    BOOST_STATIC_ASSERT((boost::is_same<T, value_type>::value));
+    BOOST_MPL_ASSERT((boost::is_same<T, value_type>));
     boost::function_requires<boost::CopyConstructibleConcept<X> >();
 
     // reference_type / const_reference_type
 
-    BOOST_STATIC_ASSERT((boost::is_same<T&, reference>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<T const&, const_reference>::value));
+    BOOST_MPL_ASSERT((boost::is_same<T&, reference>));
+    BOOST_MPL_ASSERT((boost::is_same<T const&, const_reference>));
 
     // iterator
 
     boost::function_requires<boost::InputIteratorConcept<iterator> >();
-    BOOST_STATIC_ASSERT((boost::is_same<T, iterator_value_type>::value));
-    BOOST_STATIC_ASSERT((boost::is_convertible<iterator, const_iterator>::value));
+    BOOST_MPL_ASSERT((boost::is_same<T, iterator_value_type>));
+    BOOST_MPL_ASSERT((boost::is_convertible<iterator, const_iterator>));
 
     // const_iterator
 
     boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
-    BOOST_STATIC_ASSERT((boost::is_same<T, const_iterator_value_type>::value));
+    BOOST_MPL_ASSERT((boost::is_same<T, const_iterator_value_type>));
 
     // difference_type
 
-    BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_signed);
-    BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_integer);
-    BOOST_STATIC_ASSERT((boost::is_same<difference_type,
-                iterator_difference_type>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<difference_type,
-                const_iterator_difference_type>::value));
+    BOOST_MPL_ASSERT((boost::mpl::bool_<
+                std::numeric_limits<difference_type>::is_signed>));
+    BOOST_MPL_ASSERT((boost::mpl::bool_<
+                std::numeric_limits<difference_type>::is_integer>));
+    BOOST_MPL_ASSERT((boost::is_same<difference_type,
+                iterator_difference_type>));
+    BOOST_MPL_ASSERT((boost::is_same<difference_type,
+                const_iterator_difference_type>));
 
     // size_type
 
-    BOOST_STATIC_ASSERT(!std::numeric_limits<size_type>::is_signed);
-    BOOST_STATIC_ASSERT(std::numeric_limits<size_type>::is_integer);
+    BOOST_MPL_ASSERT_NOT((boost::mpl::bool_<
+                std::numeric_limits<size_type>::is_signed>));
+    BOOST_MPL_ASSERT((boost::mpl::bool_<
+                std::numeric_limits<size_type>::is_integer>));
 
     // size_type can represent any non-negative value type of difference_type
     // I'm not sure about either of these tests...
-    size_type max_diff = static_cast<size_type>(
-            (std::numeric_limits<difference_type>::max)());
-    difference_type converted_diff(static_cast<difference_type>(max_diff));
+    size_type max_diff((std::numeric_limits<difference_type>::max)());
+    difference_type converted_diff(max_diff);
     BOOST_TEST((std::numeric_limits<difference_type>::max)()
             == converted_diff);
 
@@ -101,83 +103,21 @@ void container_test(X& r, T const&)
         static_cast<comparison_type>(
             (std::numeric_limits<difference_type>::max)()));
 
-    // Constructors
-
     // I don't test the runtime post-conditions here.
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    // It isn't specified in the container requirements that the no argument
-    // constructor is implicit, but it is defined that way in the concrete
-    // container specification.
-    X u_implicit = {};
-    sink(u_implicit);
-#endif
-
     X u;
     BOOST_TEST(u.size() == 0);
     BOOST_TEST(X().size() == 0);
 
     X a,b;
-    X a_const;
 
     sink(X(a));
     X u2(a);
     X u3 = a;
-    X u4(rvalue(a_const));
-    X u5 = rvalue(a_const);
-
-    a.swap(b);
-    boost::swap(a, b);
-    test::check_return_type<X>::equals_ref(r = a);
-
-    // Allocator
-
-    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
-    test::check_return_type<allocator_type>::equals(a_const.get_allocator());
-
-    allocator_type m = a.get_allocator();
-    sink(X(m));
-    X c(m);
-    sink(X(a_const, m));
-    X c2(a_const, m);
-    sink(X(rvalue(a_const), m));
-    X c3(rvalue(a_const), m);
-    
-    // Avoid unused variable warnings:
-
-    sink(u);
-    sink(u2);
-    sink(u3);
-    sink(u4);
-    sink(u5);
-    sink(c);
-    sink(c2);
-    sink(c3);
-}
-
-template <class X>
-void unordered_destructible_test(X&)
-{
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
-
-    X x1;
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    X x2(rvalue_default<X>());
-    X x3 = rvalue_default<X>();
-    // This can only be done if propagate_on_container_move_assignment::value
-    // is true.
-    // x2 = rvalue_default<X>();
-#endif
 
     X* ptr = new X();
     X& a1 = *ptr;
     (&a1)->~X();
-    ::operator delete((void*)(&a1));
 
-    X a,b;
     X const a_const;
     test::check_return_type<iterator>::equals(a.begin());
     test::check_return_type<const_iterator>::equals(a_const.begin());
@@ -189,8 +129,7 @@ void unordered_destructible_test(X&)
     test::check_return_type<const_iterator>::equals(a_const.cend());
 
     a.swap(b);
-    boost::swap(a, b);
- 
+    test::check_return_type<X>::equals_ref(r = a);
     test::check_return_type<size_type>::equals(a.size());
     test::check_return_type<size_type>::equals(a.max_size());
     test::check_return_type<bool>::convertible(a.empty());
@@ -199,6 +138,12 @@ void unordered_destructible_test(X&)
 
     typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
     test::check_return_type<allocator_type>::equals(a_const.get_allocator());
+    
+    // Avoid unused variable warnings:
+
+    sink(u);
+    sink(u2);
+    sink(u3);
 }
 
 template <class X, class Key>
@@ -207,29 +152,7 @@ void unordered_set_test(X&, Key const&)
     typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
     typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
 
-    BOOST_STATIC_ASSERT((boost::is_same<value_type, key_type>::value));
-
-    // iterator pointer / const_pointer_type
-
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::local_iterator local_iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<iterator>::type iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<const_iterator>::type
-            const_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<local_iterator>::type local_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<const_local_iterator>::type
-            const_local_iterator_pointer;
-
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, const_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, local_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, const_local_iterator_pointer>::value));
+    BOOST_MPL_ASSERT((boost::is_same<value_type, key_type>));
 }
 
 template <class X, class Key, class T>
@@ -237,33 +160,8 @@ void unordered_map_test(X& r, Key const& k, T const& v)
 {
     typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
     typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
-
-    BOOST_STATIC_ASSERT((
-        boost::is_same<value_type, std::pair<key_type const, T> >::value));
-
-    // iterator pointer / const_pointer_type
-
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::local_iterator local_iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<iterator>::type iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<const_iterator>::type
-            const_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<local_iterator>::type local_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME
-        boost::iterator_pointer<const_local_iterator>::type
-            const_local_iterator_pointer;
-
-    BOOST_STATIC_ASSERT((boost::is_same<value_type*, iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, const_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type*, local_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*, const_local_iterator_pointer>::value));
-
-    // Calling functions
+    BOOST_MPL_ASSERT((
+        boost::is_same<value_type, std::pair<key_type const, T> >));
 
     r.insert(std::pair<Key const, T>(k, v));
 
@@ -273,9 +171,6 @@ void unordered_map_test(X& r, Key const& k, T const& v)
     r.emplace(k, v);
     r.emplace(k_lvalue, v_lvalue);
     r.emplace(rvalue(k), rvalue(v));
-
-    r.emplace(boost::unordered::piecewise_construct,
-            boost::make_tuple(k), boost::make_tuple(v));
 }
 
 template <class X>
@@ -285,8 +180,6 @@ void equality_test(X& r)
 
     test::check_return_type<bool>::equals(a == b);
     test::check_return_type<bool>::equals(a != b);
-    test::check_return_type<bool>::equals(boost::operator==(a, b));
-    test::check_return_type<bool>::equals(boost::operator!=(a, b));
 }
 
 template <class X, class T>
@@ -318,11 +211,9 @@ void unordered_map_functions(X&, Key const& k, T const&)
     test::check_return_type<mapped_type const>::equals_ref(b.at(k));
 }
 
-template <class X, class Key, class Hash, class Pred>
-void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
+template <class X, class Key, class T, class Hash, class Pred>
+void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
 {
-    unordered_destructible_test(x);
-
     typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
     typedef BOOST_DEDUCED_TYPENAME X::hasher hasher;
     typedef BOOST_DEDUCED_TYPENAME X::key_equal key_equal;
@@ -384,46 +275,40 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
     typedef BOOST_DEDUCED_TYPENAME
         boost::iterator_reference<const_local_iterator>::type
         const_local_iterator_reference;
-    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
 
-    BOOST_STATIC_ASSERT((boost::is_same<Key, key_type>::value));
-    //boost::function_requires<boost::CopyConstructibleConcept<key_type> >();
-    //boost::function_requires<boost::AssignableConcept<key_type> >();
+    BOOST_MPL_ASSERT((boost::is_same<Key, key_type>));
+    boost::function_requires<boost::CopyConstructibleConcept<key_type> >();
+    boost::function_requires<boost::AssignableConcept<key_type> >();
 
-    BOOST_STATIC_ASSERT((boost::is_same<Hash, hasher>::value));
+    BOOST_MPL_ASSERT((boost::is_same<Hash, hasher>));
     test::check_return_type<std::size_t>::equals(hf(k));
 
-    BOOST_STATIC_ASSERT((boost::is_same<Pred, key_equal>::value));
+    BOOST_MPL_ASSERT((boost::is_same<Pred, key_equal>));
     test::check_return_type<bool>::convertible(eq(k, k));
 
     boost::function_requires<boost::InputIteratorConcept<local_iterator> >();
-    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_category,
-        iterator_category>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_difference,
-        iterator_difference>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_pointer,
-        iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_reference,
-        iterator_reference>::value));
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_category,
+        iterator_category>));
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_difference,
+        iterator_difference>));
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_pointer,
+        iterator_pointer>));
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_reference,
+        iterator_reference>));
 
     boost::function_requires<
         boost::InputIteratorConcept<const_local_iterator> >();
-    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_category,
-        const_iterator_category>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_difference,
-        const_iterator_difference>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_pointer,
-        const_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator_reference,
-        const_iterator_reference>::value));
-
-    X a;
-    allocator_type m = a.get_allocator();
-
-    // Constructors
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_category,
+        const_iterator_category>));
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_difference,
+        const_iterator_difference>));
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_pointer,
+        const_iterator_pointer>));
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_reference,
+        const_iterator_reference>));
 
     X(10, hf, eq);
-    X a1(10, hf, eq);
+    X a(10, hf, eq);
     X(10, hf);
     X a2(10, hf);
     X(10);
@@ -431,27 +316,45 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
     X();
     X a4;
 
-    X(10, hf, eq, m);
-    X a1a(10, hf, eq, m);
-    X(10, hf, m);
-    X a2a(10, hf, m);
-    X(10, m);
-    X a3a(10, m);
-    (X(m));
-    X a4a(m);
+    BOOST_DEDUCED_TYPENAME X::value_type* i = 0;
+    BOOST_DEDUCED_TYPENAME X::value_type* j = 0;
 
+    X(i, j, 10, hf, eq);
+    X a5(i, j, 10, hf, eq);
+    X(i, j, 10, hf);
+    X a6(i, j, 10, hf);
+    X(i, j, 10);
+    X a7(i, j, 10);
+    X(i, j);
+    X a8(i, j);
+
+    X const b;
+    sink(X(b));
+    X a9(b);
+    a = b;
+
+    test::check_return_type<hasher>::equals(b.hash_function());
+    test::check_return_type<key_equal>::equals(b.key_eq());
+
+    const_iterator q = a.cbegin();
+    test::check_return_type<iterator>::equals(a.insert(q, t));
+    test::check_return_type<iterator>::equals(a.emplace_hint(q, t));
+
+    a.insert(i, j);
     test::check_return_type<size_type>::equals(a.erase(k));
 
+    BOOST_TEST(a.empty());
+    if(a.empty()) {
+        a.insert(t);
+        q = a.cbegin();
+        test::check_return_type<iterator>::equals(a.erase(q));
+    }
+
     const_iterator q1 = a.cbegin(), q2 = a.cend();
     test::check_return_type<iterator>::equals(a.erase(q1, q2));
 
     a.clear();
 
-    X const b;
-
-    test::check_return_type<hasher>::equals(b.hash_function());
-    test::check_return_type<key_equal>::equals(b.key_eq());
-
     test::check_return_type<iterator>::equals(a.find(k));
     test::check_return_type<const_iterator>::equals(b.find(k));
     test::check_return_type<size_type>::equals(b.count(k));
@@ -482,210 +385,12 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
     // Avoid unused variable warnings:
 
     sink(a);
-    sink(a1);
     sink(a2);
     sink(a3);
     sink(a4);
-    sink(a1a);
-    sink(a2a);
-    sink(a3a);
-    sink(a4a);
-}
-
-template <class X, class Key, class T, class Hash, class Pred>
-void unordered_copyable_test(X& x, Key& k, T& t, Hash& hf, Pred& eq)
-{
-    unordered_test(x, k, hf, eq);
-
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
-
-    X a;
-    allocator_type m = a.get_allocator();
-
-    BOOST_DEDUCED_TYPENAME X::value_type* i = 0;
-    BOOST_DEDUCED_TYPENAME X::value_type* j = 0;
-
-    // Constructors
-
-    X(i, j, 10, hf, eq);
-    X a5(i, j, 10, hf, eq);
-    X(i, j, 10, hf);
-    X a6(i, j, 10, hf);
-    X(i, j, 10);
-    X a7(i, j, 10);
-    X(i, j);
-    X a8(i, j);
-
-    X(i, j, 10, hf, eq, m);
-    X a5a(i, j, 10, hf, eq, m);
-    X(i, j, 10, hf, m);
-    X a6a(i, j, 10, hf, m);
-    X(i, j, 10, m);
-    X a7a(i, j, 10, m);
-
-    // Not specified for some reason (maybe ambiguity with another constructor?)
-    //X(i, j, m);
-    //X a8a(i, j, m);
-    //sink(a8a);
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    std::size_t min_buckets = 10;
-    X({t});
-    X({t}, min_buckets);
-    X({t}, min_buckets, hf);
-    X({t}, min_buckets, hf, eq);
-    //X({t}, m);
-    X({t}, min_buckets, m);
-    X({t}, min_buckets, hf, m);
-    X({t}, min_buckets, hf, eq, m);
-#endif
-
-    X const b;
-    sink(X(b));
-    X a9(b);
-    a = b;
-
-    sink(X(b, m));
-    X a9a(b, m);
-
-    const_iterator q = a.cbegin();
-
-    test::check_return_type<iterator>::equals(a.insert(q, t));
-    test::check_return_type<iterator>::equals(a.emplace_hint(q, t));
-
-    a.insert(i, j);
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    std::initializer_list<T> list = {t};
-    a.insert(list);
-    a.insert({t,t,t});
-
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1900)
-    a.insert({});
-    a.insert({t});
-    a.insert({t,t});
-#endif
-#endif
-
-    X a10;
-    a10.insert(t);
-    q = a10.cbegin();
-    test::check_return_type<iterator>::equals(a10.erase(q));
-
-    // Avoid unused variable warnings:
-
-    sink(a);
     sink(a5);
     sink(a6);
     sink(a7);
     sink(a8);
     sink(a9);
-    sink(a5a);
-    sink(a6a);
-    sink(a7a);
-    sink(a9a);
-}
-
-template <class X, class Key, class T, class Hash, class Pred>
-void unordered_movable_test(X& x, Key& k, T& /* t */, Hash& hf, Pred& eq)
-{
-    unordered_test(x, k, hf, eq);
-
-    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
-    typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    X x1(rvalue_default<X>());
-    X x2(boost::move(x1));
-    x1 = rvalue_default<X>();
-    x2 = boost::move(x1);
-#endif
-
-    X a;
-    allocator_type m = a.get_allocator();
-
-    test::minimal::constructor_param* i = 0; 
-    test::minimal::constructor_param* j = 0;
-
-    // Constructors
-
-    X(i, j, 10, hf, eq);
-    X a5(i, j, 10, hf, eq);
-    X(i, j, 10, hf);
-    X a6(i, j, 10, hf);
-    X(i, j, 10);
-    X a7(i, j, 10);
-    X(i, j);
-    X a8(i, j);
-
-    X(i, j, 10, hf, eq, m);
-    X a5a(i, j, 10, hf, eq, m);
-    X(i, j, 10, hf, m);
-    X a6a(i, j, 10, hf, m);
-    X(i, j, 10, m);
-    X a7a(i, j, 10, m);
-
-    // Not specified for some reason (maybe ambiguity with another constructor?)
-    //X(i, j, m);
-    //X a8a(i, j, m);
-    //sink(a8a);
-
-    const_iterator q = a.cbegin();
-
-    test::minimal::constructor_param v;
-    a.emplace(v);
-    test::check_return_type<iterator>::equals(a.emplace_hint(q, v));
-
-    T v1(v);
-    a.emplace(boost::move(v1));
-    T v2(v);
-    a.insert(boost::move(v2));
-    T v3(v);
-    test::check_return_type<iterator>::equals(
-            a.emplace_hint(q, boost::move(v3)));
-    T v4(v);
-    test::check_return_type<iterator>::equals(
-            a.insert(q, boost::move(v4)));
-
-    a.insert(i, j);
-
-    X a10;
-    T v5(v);
-    a10.insert(boost::move(v5));
-    q = a10.cbegin();
-    test::check_return_type<iterator>::equals(a10.erase(q));
-
-    // Avoid unused variable warnings:
-
-    sink(a);
-    sink(a5);
-    sink(a6);
-    sink(a7);
-    sink(a8);
-    sink(a5a);
-    sink(a6a);
-    sink(a7a);
-    sink(a10);
-}
-
-template <class X, class T>
-void unordered_set_member_test(X& x, T& t)
-{
-    X x1(x);
-    x1.insert(t);
-    x1.begin()->dummy_member();
-    x1.cbegin()->dummy_member();
-}
-
-template <class X, class T>
-void unordered_map_member_test(X& x, T& t)
-{
-    X x1(x);
-    x1.insert(t);
-    x1.begin()->first.dummy_member();
-    x1.cbegin()->first.dummy_member();
-    x1.begin()->second.dummy_member();
-    x1.cbegin()->second.dummy_member();
 }

test/unordered/constructor_tests.cpp

@@ -4,10 +4,9 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
 #include "../objects/test.hpp"
 #include "../helpers/random_values.hpp"
@@ -16,12 +15,15 @@
 #include "../helpers/input_iterator.hpp"
 #include "../helpers/invariants.hpp"
 
+#include <iostream>
+
 namespace constructor_tests {
 
-test::seed_t initialize_seed(356730);
+test::seed_t seed(356730);
 
 template <class T>
-void constructor_tests1(T*, test::random_generator generator)
+void constructor_tests1(T*,
+    test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
@@ -29,8 +31,6 @@ void constructor_tests1(T*, test::random_generator generator)
 
     std::cerr<<"Construct 1\n";
     {
-        test::check_instances check_;
-
         T x(0, hf, eq);
         BOOST_TEST(x.empty());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -41,8 +41,6 @@ void constructor_tests1(T*, test::random_generator generator)
 
     std::cerr<<"Construct 2\n";
     {
-        test::check_instances check_;
-
         T x(100, hf);
         BOOST_TEST(x.empty());
         BOOST_TEST(x.bucket_count() >= 100);
@@ -54,8 +52,6 @@ void constructor_tests1(T*, test::random_generator generator)
 
     std::cerr<<"Construct 3\n";
     {
-        test::check_instances check_;
-
         T x(2000);
         BOOST_TEST(x.empty());
         BOOST_TEST(x.bucket_count() >= 2000);
@@ -67,8 +63,6 @@ void constructor_tests1(T*, test::random_generator generator)
 
     std::cerr<<"Construct 4\n";
     {
-        test::check_instances check_;
-
         T x;
         BOOST_TEST(x.empty());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -79,8 +73,6 @@ void constructor_tests1(T*, test::random_generator generator)
 
     std::cerr<<"Construct 5\n";
     {
-        test::check_instances check_;
-
         test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end(), 10000, hf, eq);
         BOOST_TEST(x.bucket_count() >= 10000);
@@ -93,8 +85,6 @@ void constructor_tests1(T*, test::random_generator generator)
 
     std::cerr<<"Construct 6\n";
     {
-        test::check_instances check_;
-
         test::random_values<T> v(10, generator);
         T x(v.begin(), v.end(), 10000, hf);
         BOOST_TEST(x.bucket_count() >= 10000);
@@ -107,8 +97,6 @@ void constructor_tests1(T*, test::random_generator generator)
 
     std::cerr<<"Construct 7\n";
     {
-        test::check_instances check_;
-
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 100);
         BOOST_TEST(x.bucket_count() >= 100);
@@ -121,8 +109,6 @@ void constructor_tests1(T*, test::random_generator generator)
 
     std::cerr<<"Construct 8\n";
     {
-        test::check_instances check_;
-
         test::random_values<T> v(1, generator);
         T x(v.begin(), v.end());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -134,8 +120,6 @@ void constructor_tests1(T*, test::random_generator generator)
 
     std::cerr<<"Construct 9\n";
     {
-        test::check_instances check_;
-
         T x(0, hf, eq, al);
         BOOST_TEST(x.empty());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -146,8 +130,6 @@ void constructor_tests1(T*, test::random_generator generator)
 
     std::cerr<<"Construct 10\n";
     {
-        test::check_instances check_;
-
         test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end(), 10000, hf, eq, al);
         BOOST_TEST(x.bucket_count() >= 10000);
@@ -160,8 +142,6 @@ void constructor_tests1(T*, test::random_generator generator)
 
     std::cerr<<"Construct 11\n";
     {
-        test::check_instances check_;
-
         T x(al);
         BOOST_TEST(x.empty());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -172,7 +152,8 @@ void constructor_tests1(T*, test::random_generator generator)
 }
 
 template <class T>
-void constructor_tests2(T*, test::random_generator const& generator)
+void constructor_tests2(T*,
+    test::random_generator const& generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
@@ -186,7 +167,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Construct 1\n";
     {
-        test::check_instances check_;
         T x(10000, hf1, eq1);
         BOOST_TEST(x.bucket_count() >= 10000);
         BOOST_TEST(test::equivalent(x.hash_function(), hf1));
@@ -197,7 +177,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Construct 2\n";
     {
-        test::check_instances check_;
         T x(100, hf1);
         BOOST_TEST(x.empty());
         BOOST_TEST(x.bucket_count() >= 100);
@@ -209,7 +188,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Construct 3\n";
     {
-        test::check_instances check_;
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf1, eq1);
         BOOST_TEST(test::equivalent(x.hash_function(), hf1));
@@ -221,7 +199,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Construct 4\n";
     {
-        test::check_instances check_;
         test::random_values<T> v(5, generator);
         T x(v.begin(), v.end(), 1000, hf1);
         BOOST_TEST(x.bucket_count() >= 1000);
@@ -235,7 +212,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Construct 5\n";
     {
-        test::check_instances check_;
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf, eq, al1);
         T y(x.begin(), x.end(), 0, hf1, eq1, al2);
@@ -247,7 +223,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Construct 6\n";
     {
-        test::check_instances check_;
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf1, eq1);
         T y(x.begin(), x.end(), 0, hf, eq);
@@ -259,7 +234,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Construct 7\n";
     {
-        test::check_instances check_;
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf1, eq1);
         T y(x.begin(), x.end(), 0, hf2, eq2);
@@ -271,7 +245,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Construct 8 - from input iterator\n";
     {
-        test::check_instances check_;
         test::random_values<T> v(100, generator);
         BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
             v_begin = v.begin(), v_end = v.end();
@@ -289,7 +262,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
     
     std::cerr<<"Construct 8.5 - from copy iterator\n";
     {
-        test::check_instances check_;
         test::random_values<T> v(100, generator);
         T x(test::copy_iterator(v.begin()),
             test::copy_iterator(v.end()), 0, hf1, eq1);
@@ -303,8 +275,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
     
     std::cerr<<"Construct 9\n";
     {
-        test::check_instances check_;
-
         test::random_values<T> v(100, generator);
         T x(50);
         BOOST_TEST(x.bucket_count() >= 50);
@@ -316,13 +286,11 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(x);
     }
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
     std::initializer_list<BOOST_DEDUCED_TYPENAME T::value_type> list;
     
     std::cerr<<"Initializer list construct 1\n";
     {
-        test::check_instances check_;
-
         T x(list);
         BOOST_TEST(x.empty());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -332,8 +300,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Initializer list construct 2\n";
     {
-        test::check_instances check_;
-
         T x(list, 1000);
         BOOST_TEST(x.empty());
         BOOST_TEST(x.bucket_count() >= 1000);
@@ -344,8 +310,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Initializer list construct 3\n";
     {
-        test::check_instances check_;
-
         T x(list, 10, hf1);
         BOOST_TEST(x.empty());
         BOOST_TEST(x.bucket_count() >= 10);
@@ -356,8 +320,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Initializer list construct 4\n";
     {
-        test::check_instances check_;
-
         T x(list, 10, hf1, eq1);
         BOOST_TEST(x.empty());
         BOOST_TEST(x.bucket_count() >= 10);
@@ -368,8 +330,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 
     std::cerr<<"Initializer list construct 5\n";
     {
-        test::check_instances check_;
-
         T x(list, 10, hf1, eq1, al1);
         BOOST_TEST(x.empty());
         BOOST_TEST(x.bucket_count() >= 10);
@@ -381,7 +341,8 @@ void constructor_tests2(T*, test::random_generator const& generator)
 }
 
 template <class T>
-void map_constructor_test(T*, test::random_generator const& generator)
+void map_constructor_test(T* = 0,
+    test::random_generator const& generator = test::default_generator)
 {
     std::cerr<<"map_constructor_test\n";
 
@@ -399,43 +360,37 @@ void map_constructor_test(T*, test::random_generator const& generator)
     test::check_equivalent_keys(x);
 }
 
-boost::unordered_map<test::object, test::object,
-    test::hash, test::equal_to,
-    std::allocator<test::object> >* test_map_std_alloc;
-
 boost::unordered_set<test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_set;
+    test::allocator<test::object> >* test_set;
 boost::unordered_multiset<test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_multiset;
+    test::allocator<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_map;
+    test::allocator<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_multimap;
+    test::allocator<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
-using test::limited_range;
 
 UNORDERED_TEST(constructor_tests1,
-    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((test_set)(test_multiset)(test_map)(test_multimap))
+    ((default_generator)(generate_collisions))
 )
 
 UNORDERED_TEST(constructor_tests2,
     ((test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((default_generator)(generate_collisions))
 )
 
 UNORDERED_TEST(map_constructor_test,
-    ((test_map_std_alloc)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((test_map)(test_multimap))
 )
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
 
 UNORDERED_AUTO_TEST(test_default_initializer_list) {
     std::cerr<<"Initializer List Tests\n";
@@ -446,7 +401,8 @@ UNORDERED_AUTO_TEST(test_default_initializer_list) {
 
 #endif
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST) && \
+    !defined(BOOST_NO_INITIALIZER_LISTS)
 
 UNORDERED_AUTO_TEST(test_initializer_list) {
     std::cerr<<"Initializer List Tests\n";

test/unordered/copy_tests.cpp

@@ -4,35 +4,30 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
 #include "../objects/test.hpp"
-#include "../objects/cxx11_allocator.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
 #include "../helpers/equivalent.hpp"
 #include "../helpers/invariants.hpp"
 
-test::seed_t initialize_seed(9063);
+test::seed_t seed(9063);
 
 namespace copy_tests
 {
 
 template <class T>
-void copy_construct_tests1(T*, test::random_generator const& generator)
+void copy_construct_tests1(T*,
+    test::random_generator const& generator = test::default_generator)
 {
-    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
-
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
-    BOOST_DEDUCED_TYPENAME T::allocator_type al;    
+    BOOST_DEDUCED_TYPENAME T::allocator_type al;
 
     {
-        test::check_instances check_;
-
         T x;
         T y(x);
         BOOST_TEST(y.empty());
@@ -40,28 +35,20 @@ void copy_construct_tests1(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(y.key_eq(), eq));
         BOOST_TEST(test::equivalent(y.get_allocator(), al));
         BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-        BOOST_TEST(test::selected_count(y.get_allocator()) ==
-            (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 
     {
-        test::check_instances check_;
-
         test::random_values<T> v(1000, generator);
 
         T x(v.begin(), v.end());
         T y(x);
         test::unordered_equivalence_tester<T> equivalent(x);
         BOOST_TEST(equivalent(y));
-        BOOST_TEST(test::selected_count(y.get_allocator()) ==
-            (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 
     {
-        test::check_instances check_;
-
         // In this test I drop the original containers max load factor, so it
         // is much lower than the load factor. The hash table is not allowed
         // to rehash, but the destination container should probably allocate
@@ -74,25 +61,22 @@ void copy_construct_tests1(T*, test::random_generator const& generator)
         BOOST_TEST(equivalent(y));
         // This isn't guaranteed:
         BOOST_TEST(y.load_factor() < y.max_load_factor());
-        BOOST_TEST(test::selected_count(y.get_allocator()) ==
-            (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 }
 
 template <class T>
-void copy_construct_tests2(T*, test::random_generator const& generator)
+void copy_construct_tests2(T* ptr,
+    test::random_generator const& generator = test::default_generator)
 {
+    copy_construct_tests1(ptr);
+
     BOOST_DEDUCED_TYPENAME T::hasher hf(1);
     BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
-    
-    typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
     {
-        test::check_instances check_;
-
         T x(10000, hf, eq, al);
         T y(x);
         BOOST_TEST(y.empty());
@@ -100,14 +84,10 @@ void copy_construct_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(y.key_eq(), eq));
         BOOST_TEST(test::equivalent(y.get_allocator(), al));
         BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-        BOOST_TEST(test::selected_count(y.get_allocator()) ==
-            (allocator_type::is_select_on_copy));
         test::check_equivalent_keys(y);
     }
 
     {
-        test::check_instances check_;
-
         T x(1000, hf, eq, al);
         T y(x, al2);
         BOOST_TEST(y.empty());
@@ -115,13 +95,10 @@ void copy_construct_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(y.key_eq(), eq));
         BOOST_TEST(test::equivalent(y.get_allocator(), al2));
         BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-        BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
         test::check_equivalent_keys(y);
     }
 
     {
-        test::check_instances check_;
-
         test::random_values<T> v(1000, generator);
 
         T x(v.begin(), v.end(), 0, hf, eq, al);
@@ -129,14 +106,10 @@ void copy_construct_tests2(T*, test::random_generator const& generator)
         test::unordered_equivalence_tester<T> equivalent(x);
         BOOST_TEST(equivalent(y));
         test::check_equivalent_keys(y);
-        BOOST_TEST(test::selected_count(y.get_allocator()) ==
-            (allocator_type::is_select_on_copy));
         BOOST_TEST(test::equivalent(y.get_allocator(), al));
     }
 
     {
-        test::check_instances check_;
-
         test::random_values<T> v(500, generator);
 
         T x(v.begin(), v.end(), 0, hf, eq, al);
@@ -144,76 +117,33 @@ void copy_construct_tests2(T*, test::random_generator const& generator)
         test::unordered_equivalence_tester<T> equivalent(x);
         BOOST_TEST(equivalent(y));
         test::check_equivalent_keys(y);
-        BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
         BOOST_TEST(test::equivalent(y.get_allocator(), al2));
     }
 }
 
 boost::unordered_set<test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_set;
+    test::allocator<test::object> >* test_set;
 boost::unordered_multiset<test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_multiset;
+    test::allocator<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_map;
+    test::allocator<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_multimap;
-
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::select_copy> >*
-    test_set_select_copy;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::select_copy> >*
-    test_multiset_select_copy;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::select_copy> >*
-    test_map_select_copy;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::select_copy> >*
-    test_multimap_select_copy;
-
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_select_copy> >*
-    test_set_no_select_copy;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_select_copy> >*
-    test_multiset_no_select_copy;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_select_copy> >*
-    test_map_no_select_copy;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_select_copy> >*
-    test_multimap_no_select_copy;
+    test::allocator<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
-using test::limited_range;
 
-UNORDERED_TEST(copy_construct_tests1, (
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_select_copy)(test_multiset_select_copy)(test_map_select_copy)(test_multimap_select_copy)
-        (test_set_no_select_copy)(test_multiset_no_select_copy)(test_map_no_select_copy)(test_multimap_no_select_copy)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
+UNORDERED_TEST(copy_construct_tests1,
+    ((test_set)(test_multiset)(test_map)(test_multimap))
 )
 
-UNORDERED_TEST(copy_construct_tests2, (
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_select_copy)(test_multiset_select_copy)(test_map_select_copy)(test_multimap_select_copy)
-        (test_set_no_select_copy)(test_multiset_no_select_copy)(test_map_no_select_copy)(test_multimap_no_select_copy)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
+UNORDERED_TEST(copy_construct_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap))
+    ((default_generator)(generate_collisions))
 )
 
 }

test/unordered/emplace_tests.cpp

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

test/unordered/equality_tests.cpp

@@ -4,10 +4,9 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include <boost/preprocessor/seq.hpp>
 #include <list>
 #include "../helpers/test.hpp"
@@ -25,11 +24,9 @@ namespace equality_tests
             return x % 1000 == y % 1000;
         }
 
-        std::size_t operator()(int x) const
+        int operator()(int x) const
         {
-            return alt_hash_ ?
-                static_cast<std::size_t>(x % 250) :
-                static_cast<std::size_t>((x + 5) % 250);
+            return alt_hash_ ? x % 250 : (x + 5) % 250;
         }
     };
 
@@ -139,25 +136,15 @@ namespace equality_tests
         UNORDERED_EQUALITY_MULTIMAP_TEST(
             ((1)(1))((1)(1)), !=, ((1)(1))((1)(2)))
         UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((1)(2))((1)(1)), ==, ((1)(1))((1)(2)))
-        UNORDERED_EQUALITY_MULTIMAP_TEST(
-            ((1)(2))((1)(1)), !=, ((1)(1))((1)(3)))
+            ((1)(2))((1)(1)), !=, ((1)(1))((1)(2)))
     }
 
     UNORDERED_AUTO_TEST(equality_predicate_test)
     {
         UNORDERED_EQUALITY_SET_TEST(
-            (1), !=, (1001))
+            (1), ==, (1001))
         UNORDERED_EQUALITY_MAP_TEST(
-            ((1)(2))((1001)(1)), !=, ((1001)(2))((1)(1)))
-    }
-
-    UNORDERED_AUTO_TEST(equality_multiple_group_test)
-    {
-        UNORDERED_EQUALITY_MULTISET_TEST(
-            (1)(1)(1)(1001)(2001)(2001)(2)(1002)(3)(1003)(2003), ==,
-            (3)(1003)(2003)(1002)(2)(2001)(2001)(1)(1001)(1)(1)
-        );
+            ((1)(2))((1001)(1)), ==, ((1001)(2))((1)(1)))
     }
 
     // Test that equality still works when the two containers have
@@ -178,6 +165,7 @@ namespace equality_tests
         set1.insert(20); set2.insert(10);
         BOOST_TEST(set1 == set2);
     }
+
 }
 
 RUN_TESTS()

test/unordered/equivalent_keys_tests.cpp

@@ -4,10 +4,9 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
 #include <algorithm>
 #include <map>

test/unordered/erase_equiv_tests.cpp

@@ -7,16 +7,14 @@
 // hairy with several tricky edge cases - so explicitly test each one.
 
 #include "../helpers/prefix.hpp"
-#include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
 
+#include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
 #include "../helpers/list.hpp"
-#include "../helpers/invariants.hpp"
-#include "../helpers/helpers.hpp"
 #include <set>
 #include <iostream>
 #include <iterator>
+#include <boost/next_prior.hpp>
 #include "../objects/test.hpp"
 
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
@@ -43,30 +41,21 @@ void write_container(Container const& x)
 // Make everything collide - for testing erase in a single bucket.
 struct collision_hash
 {
-    std::size_t operator()(int) const { return 0; }
+    int operator()(int) const { return 0; }
 };
 
 // For testing erase in 2 buckets.
 struct collision2_hash
 {
-    std::size_t operator()(int x) const { return static_cast<std::size_t>(x & 1); }
-};
-
-// For testing erase in lots of buckets.
-struct collision3_hash
-{
-    std::size_t operator()(int x) const { return static_cast<std::size_t>(x); }
+    int operator()(int x) const { return x & 1; }
 };
 
 typedef boost::unordered_multimap<int, int,
     collision_hash, std::equal_to<int>,
-    test::allocator1<std::pair<int const, int> > > collide_map;
+    test::allocator<std::pair<int const, int> > > collide_map;
 typedef boost::unordered_multimap<int, int,
     collision2_hash, std::equal_to<int>,
-    test::allocator2<std::pair<int const, int> > > collide_map2;
-typedef boost::unordered_multimap<int, int,
-    collision3_hash, std::equal_to<int>,
-    test::allocator2<std::pair<int const, int> > > collide_map3;
+    test::allocator<std::pair<int const, int> > > collide_map2;
 typedef collide_map::value_type collide_value;
 typedef test::list<collide_value> collide_list;
 
@@ -76,7 +65,6 @@ UNORDERED_AUTO_TEST(empty_range_tests)
     x.erase(x.begin(), x.end());
     x.erase(x.begin(), x.begin());
     x.erase(x.end(), x.end());
-    test::check_equivalent_keys(x);
 }
 
 UNORDERED_AUTO_TEST(single_item_tests)
@@ -87,13 +75,10 @@ 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);
-    test::check_equivalent_keys(x);
     x.erase(x.end(), x.end());
     BOOST_TEST(x.count(1) == 1 && x.size() == 1);
-    test::check_equivalent_keys(x);
     x.erase(x.begin(), x.end());
     BOOST_TEST(x.count(1) == 0 && x.size() == 0);
-    test::check_equivalent_keys(x);
 }
 
 UNORDERED_AUTO_TEST(two_equivalent_item_tests)
@@ -106,25 +91,22 @@ 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);
-        test::check_equivalent_keys(x);
     }
 
     {
         collide_map x(init.begin(), init.end());
-        int value = test::next(x.begin())->second;
-        x.erase(x.begin(), test::next(x.begin()));
+        int value = boost::next(x.begin())->second;
+        x.erase(x.begin(), boost::next(x.begin()));
         BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
             x.begin()->first == 1 && x.begin()->second == value);
-        test::check_equivalent_keys(x);
     }
 
     {
         collide_map x(init.begin(), init.end());
         int value = x.begin()->second;
-        x.erase(test::next(x.begin()), x.end());
+        x.erase(boost::next(x.begin()), x.end());
         BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
                 x.begin()->first == 1 && x.begin()->second == value);
-        test::check_equivalent_keys(x);
     }
 }
 
@@ -144,11 +126,8 @@ template <class Container>
 bool general_erase_range_test(Container& x, std::size_t start, std::size_t end)
 {
     collide_list l(x.begin(), x.end());
-
-    l.erase(test::next(l.begin(), start), test::next(l.begin(), end));
-    x.erase(test::next(x.begin(), start), test::next(x.begin(), end));
-
-    test::check_equivalent_keys(x);
+    l.erase(boost::next(l.begin(), start), boost::next(l.begin(), end));
+    x.erase(boost::next(x.begin(), start), boost::next(x.begin(), end));
     return compare(l, x);
 }
 
@@ -211,11 +190,4 @@ UNORDERED_AUTO_TEST(exhaustive_collide2_tests)
     std::cout<<"\n";
 }
 
-UNORDERED_AUTO_TEST(exhaustive_collide3_tests)
-{
-    std::cout<<"exhaustive_collide3_tests:\n";
-    exhaustive_erase_tests((collide_map3*) 0, 8, 4);
-    std::cout<<"\n";
-}
-
 RUN_TESTS()

test/unordered/erase_tests.cpp

@@ -4,39 +4,32 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
+#include <boost/next_prior.hpp>
 #include "../objects/test.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
 #include "../helpers/equivalent.hpp"
 #include "../helpers/helpers.hpp"
-#include "../helpers/invariants.hpp"
-#include <vector>
+
 #include <iostream>
-#include <cstdlib>
 
 namespace erase_tests
 {
 
-test::seed_t initialize_seed(85638);
+test::seed_t seed(85638);
 
 template <class Container>
-void erase_tests1(Container*, test::random_generator generator)
+void erase_tests1(Container*,
+    test::random_generator generator = test::default_generator)
 {
-    typedef BOOST_DEDUCED_TYPENAME Container::iterator iterator;
-    typedef BOOST_DEDUCED_TYPENAME Container::const_iterator c_iterator;
-
     std::cerr<<"Erase by key.\n";
     {
-        test::check_instances check_;
-
         test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
-        int iterations = 0;
         for(BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator
             it = v.begin(); it != v.end(); ++it)
         {
@@ -46,76 +39,63 @@ void erase_tests1(Container*, test::random_generator generator)
             BOOST_TEST(x.size() == old_size - count);
             BOOST_TEST(x.count(test::get_key<Container>(*it)) == 0);
             BOOST_TEST(x.find(test::get_key<Container>(*it)) == x.end());
-            if (++iterations % 20 == 0) test::check_equivalent_keys(x);
         }
     }
 
     std::cerr<<"erase(begin()).\n";
     {
-        test::check_instances check_;
-
         test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
-        int iterations = 0;
         while(size > 0 && !x.empty())
         {
             BOOST_DEDUCED_TYPENAME Container::key_type
                 key = test::get_key<Container>(*x.begin());
             std::size_t count = x.count(key);
-            iterator pos = x.erase(x.begin());
+            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);
-            if (++iterations % 20 == 0) test::check_equivalent_keys(x);
         }
         BOOST_TEST(x.empty());
     }
 
     std::cerr<<"erase(random position).\n";
     {
-        test::check_instances check_;
-
         test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
-        int iterations = 0;
         while(size > 0 && !x.empty())
         {
-            std::size_t index = test::random_value(x.size());
-            c_iterator prev, pos, next;
+            using namespace std;
+            int index = rand() % (int) x.size();
+            BOOST_DEDUCED_TYPENAME Container::const_iterator prev, pos, next;
             if(index == 0) {
                 prev = pos = x.begin();
             }
             else {
-                prev = test::next(x.begin(), index - 1);
-                pos = test::next(prev);
+                prev = boost::next(x.begin(), index - 1);
+                pos = boost::next(prev);
             }
-            next = test::next(pos);
+            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(count > 0);
             BOOST_TEST(next == x.erase(pos));
             --size;
             if(size > 0)
                 BOOST_TEST(index == 0 ? next == x.begin() :
-                        next == test::next(prev));
+                        next == boost::next(prev));
             BOOST_TEST(x.count(key) == count - 1);
-            if (x.count(key) != count - 1) {
-                std::cerr << count << " => " << x.count(key) << std::endl;
-            }
             BOOST_TEST(x.size() == size);
-            if (++iterations % 20 == 0) test::check_equivalent_keys(x);
         }
         BOOST_TEST(x.empty());
     }
 
     std::cerr<<"erase(ranges).\n";
     {
-        test::check_instances check_;
-
         test::random_values<Container> v(500, generator);
         Container x(v.begin(), v.end());
 
@@ -128,64 +108,19 @@ void erase_tests1(Container*, test::random_generator generator)
         BOOST_TEST(x.erase(x.end(), x.end()) == x.end());
         BOOST_TEST(x.erase(x.begin(), x.begin()) == x.begin());
         BOOST_TEST(x.size() == size);
-        test::check_equivalent_keys(x);
 
         BOOST_TEST(x.erase(x.begin(), x.end()) == x.end());
         BOOST_TEST(x.empty());
         BOOST_TEST(x.begin() == x.end());
-        test::check_equivalent_keys(x);
 
         BOOST_TEST(x.erase(x.begin(), x.end()) == x.begin());
-        test::check_equivalent_keys(x);
-    }
-
-    std::cerr<<"erase(random ranges).\n";
-    {
-        test::check_instances check_;
-        Container x;
-
-        for (int i = 0; i < 100; ++i) {
-            test::random_values<Container> v(1000, generator);
-            x.insert(v.begin(), v.end());
-
-            // Note that erase only invalidates the erased iterators.
-            std::vector<c_iterator> iterators;
-            for(c_iterator it = x.cbegin(); it != x.cend(); ++it) {
-                iterators.push_back(it);
-            }
-            iterators.push_back(x.cend());
-
-            while(iterators.size() > 1) {
-                std::size_t start = test::random_value(iterators.size());
-                std::size_t length = test::random_value(iterators.size() - start);
-                x.erase(iterators[start], iterators[start + length]);
-                iterators.erase(
-                        test::next(iterators.begin(), start),
-                        test::next(iterators.begin(), start + length));
-
-                BOOST_TEST(x.size() == iterators.size() - 1);
-                BOOST_DEDUCED_TYPENAME std::vector<c_iterator>::const_iterator
-                    i2 = iterators.begin();
-                for(c_iterator i1 = x.cbegin(); i1 != x.cend(); ++i1) {
-                    BOOST_TEST(i1 == *i2);
-                    ++i2;
-                }
-                BOOST_TEST(x.cend() == *i2);
-
-                test::check_equivalent_keys(x);
-            }
-            BOOST_TEST(x.empty());
-        }
     }
 
     std::cerr<<"quick_erase(begin()).\n";
     {
-        test::check_instances check_;
-
         test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
-        int iterations = 0;
         while(size > 0 && !x.empty())
         {
             BOOST_DEDUCED_TYPENAME Container::key_type
@@ -195,46 +130,38 @@ void erase_tests1(Container*, test::random_generator generator)
             --size;
             BOOST_TEST(x.count(key) == count - 1);
             BOOST_TEST(x.size() == size);
-            if (++iterations % 20 == 0) test::check_equivalent_keys(x);
         }
         BOOST_TEST(x.empty());
     }
 
     std::cerr<<"quick_erase(random position).\n";
     {
-        test::check_instances check_;
-
         test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
-        int iterations = 0;
         while(size > 0 && !x.empty())
         {
-            std::size_t index = test::random_value(x.size());
+            using namespace std;
+            int index = rand() % (int) x.size();
             BOOST_DEDUCED_TYPENAME Container::const_iterator prev, pos, next;
             if(index == 0) {
                 prev = pos = x.begin();
             }
             else {
-                prev = test::next(x.begin(), index - 1);
-                pos = test::next(prev);
+                prev = boost::next(x.begin(), index - 1);
+                pos = boost::next(prev);
             }
-            next = test::next(pos);
+            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(count > 0);
             x.quick_erase(pos);
             --size;
             if(size > 0)
                 BOOST_TEST(index == 0 ? next == x.begin() :
-                        next == test::next(prev));
+                        next == boost::next(prev));
             BOOST_TEST(x.count(key) == count - 1);
-            if (x.count(key) != count - 1) {
-                std::cerr << count << " => " << x.count(key) << std::endl;
-            }
             BOOST_TEST(x.size() == size);
-            if (++iterations % 20 == 0) test::check_equivalent_keys(x);
         }
         BOOST_TEST(x.empty());
     }
@@ -242,8 +169,6 @@ void erase_tests1(Container*, test::random_generator generator)
 
     std::cerr<<"clear().\n";
     {
-        test::check_instances check_;
-
         test::random_values<Container> v(500, generator);
         Container x(v.begin(), v.end());
         x.clear();
@@ -256,24 +181,23 @@ void erase_tests1(Container*, test::random_generator generator)
 
 boost::unordered_set<test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_set;
+    test::allocator<test::object> >* test_set;
 boost::unordered_multiset<test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_multiset;
+    test::allocator<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_map;
+    test::allocator<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_multimap;
+    test::allocator<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
-using test::limited_range;
 
 UNORDERED_TEST(erase_tests1,
     ((test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((default_generator)(generate_collisions))
 )
 
 }

test/unordered/find_tests.cpp

@@ -4,10 +4,9 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
 #include "../objects/test.hpp"
 #include "../helpers/random_values.hpp"
@@ -17,16 +16,14 @@
 namespace find_tests
 {
 
-test::seed_t initialize_seed(78937);
+test::seed_t seed(78937);
 
 template <class X>
-void find_tests1(X*, test::random_generator generator)
+void find_tests1(X*, test::random_generator generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
     {
-        test::check_instances check_;
-
         test::random_values<X> v(500, generator);
         X x(v.begin(), v.end());
         X const& x_const = x;
@@ -37,15 +34,13 @@ void find_tests1(X*, test::random_generator generator)
                 tracker.begin(); it1 != tracker.end(); ++it1)
         {
             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);
-            iterator pos = x.find(key);
-            BOOST_TEST(const_pos != x_const.end());
-            BOOST_TEST(const_pos != x_const.end() &&
-                    x_const.key_eq()(key, test::get_key<X>(*const_pos)));
-            BOOST_TEST(pos != x.end());
             BOOST_TEST(pos != x.end() &&
                     x.key_eq()(key, test::get_key<X>(*pos)));
+            BOOST_TEST(const_pos != x_const.end() &&
+                    x_const.key_eq()(key, test::get_key<X>(*const_pos)));
 
             BOOST_TEST(x.count(key) == tracker.count(key));
 
@@ -74,8 +69,6 @@ void find_tests1(X*, test::random_generator generator)
     }
 
     {
-        test::check_instances check_;
-
         X x;
 
         test::random_values<X> v2(5, generator);
@@ -117,8 +110,10 @@ struct compatible_predicate
 };
 
 template <class X>
-void find_compatible_keys_test(X*, test::random_generator generator)
+void find_compatible_keys_test(X*,
+    test::random_generator generator = test::default_generator)
 {
+    typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
         value_iterator;
     test::random_values<X> v(500, generator);
@@ -142,28 +137,27 @@ void find_compatible_keys_test(X*, test::random_generator generator)
 
 boost::unordered_set<test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_set;
+    test::allocator<test::object> >* test_set;
 boost::unordered_multiset<test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_multiset;
+    test::allocator<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_map;
+    test::allocator<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_multimap;
+    test::allocator<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
-using test::limited_range;
 
 UNORDERED_TEST(find_tests1,
     ((test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((default_generator)(generate_collisions))
 )
 UNORDERED_TEST(find_compatible_keys_test,
     ((test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((default_generator)(generate_collisions))
 )
 
 }

test/unordered/fwd_map_test.cpp

@@ -4,8 +4,8 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered/unordered_map_fwd.hpp>
-#include "../helpers/postfix.hpp"
 
 template <typename T>
 void call_swap(boost::unordered_map<T,T>& x,

test/unordered/fwd_set_test.cpp

@@ -4,8 +4,8 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered/unordered_set_fwd.hpp>
-#include "../helpers/postfix.hpp"
 
 struct true_type { char x[100]; };
 struct false_type { char x; };

test/unordered/incomplete_test.cpp

@@ -4,36 +4,35 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_map.hpp>
 #include <boost/unordered_set.hpp>
-#include "../helpers/postfix.hpp"
-
-#include <utility>
 
 namespace x
 {
     struct D { boost::unordered_map<D, D> x; };
 }
 
-namespace incomplete_test
+namespace test
 {
     // Declare, but don't define some types.
 
     struct value;
     struct hash;
     struct equals;
-    template <class T> struct allocator;
+    template <class T>
+    struct malloc_allocator;
 
     // Declare some instances
     
     typedef boost::unordered_map<value, value, hash, equals,
-        allocator<std::pair<value const, value> > > map;
+        malloc_allocator<std::pair<value const, value> > > map;
     typedef boost::unordered_multimap<value, value, hash, equals,
-        allocator<std::pair<value const, value> > > multimap;
+        malloc_allocator<std::pair<value const, value> > > multimap;
     typedef boost::unordered_set<value, hash, equals,
-        allocator<value> > set;
+        malloc_allocator<value> > set;
     typedef boost::unordered_multiset<value, hash, equals,
-        allocator<value> > multiset;
+        malloc_allocator<value> > multiset;
     
     // Now define the types which are stored as members, as they are needed for
     // declaring struct members.
@@ -48,17 +47,12 @@ namespace incomplete_test
         bool operator()(T const&, T const&) const { return true; }
     };
 
-    // This is a dubious way to implement an allocator, but good enough
-    // for this test.
-    template <typename T>
-    struct allocator : std::allocator<T> {
-        allocator() {}
+}
 
-        template <typename T2>
-        allocator(const allocator<T2>& other) :
-            std::allocator<T>(other) {}
-    };
+#include "../helpers/allocator.hpp"
 
+namespace test
+{
     // Declare some members of a structs.
     //
     // Incomplete hash, equals and allocator aren't here supported at the
@@ -66,19 +60,19 @@ namespace incomplete_test
     
     struct struct1 {
         boost::unordered_map<struct1, struct1, hash, equals,
-            allocator<std::pair<struct1 const, struct1> > > x;
+            malloc_allocator<std::pair<struct1 const, struct1> > > x;
     };
     struct struct2 {
         boost::unordered_multimap<struct2, struct2, hash, equals,
-            allocator<std::pair<struct2 const, struct2> > > x;
+            malloc_allocator<std::pair<struct2 const, struct2> > > x;
     };
     struct struct3 {
         boost::unordered_set<struct3, hash, equals,
-            allocator<struct3> > x;
+            malloc_allocator<struct3> > x;
     };
     struct struct4 {
         boost::unordered_multiset<struct4, hash, equals,
-            allocator<struct4> > x;
+            malloc_allocator<struct4> > x;
     };
     
     // Now define the value type.
@@ -87,15 +81,15 @@ namespace incomplete_test
 
     // Create some instances.
     
-    incomplete_test::map m1;
-    incomplete_test::multimap m2;
-    incomplete_test::set s1;
-    incomplete_test::multiset s2;
+    test::map m1;
+    test::multimap m2;
+    test::set s1;
+    test::multiset s2;
 
-    incomplete_test::struct1 c1;
-    incomplete_test::struct2 c2;
-    incomplete_test::struct3 c3;
-    incomplete_test::struct4 c4;
+    test::struct1 c1;
+    test::struct2 c2;
+    test::struct3 c3;
+    test::struct4 c4;
 
     // Now declare, but don't define, the operators required for comparing
     // elements.
@@ -117,7 +111,7 @@ namespace incomplete_test
     
     void use_types()
     {
-        incomplete_test::value x;
+        test::value x;
         m1[x] = x;
         m2.insert(std::make_pair(x, x));
         s1.insert(x);
@@ -149,5 +143,5 @@ int main() {
     // This could just be a compile test, but I like to be able to run these
     // things. It's probably irrational, but I find it reassuring.
 
-    incomplete_test::use_types();
+    test::use_types();
 }

test/unordered/insert_hint_tests.cpp

@@ -1,118 +0,0 @@
-
-// Copyright 2016 Daniel James.
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include "../helpers/prefix.hpp"
-#include <boost/unordered_set.hpp>
-#include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
-#include "../helpers/test.hpp"
-#include "../helpers/invariants.hpp"
-
-#include <map>
-#include <set>
-#include <iostream>
-
-namespace insert_hint
-{
-UNORDERED_AUTO_TEST(insert_hint_empty) {
-    typedef boost::unordered_multiset<int> container;
-    container x;
-    x.insert(x.cbegin(), 10);
-    BOOST_TEST_EQ(x.size(), 1u);
-    BOOST_TEST_EQ(x.count(10), 1u);
-    test::check_equivalent_keys(x);
-}
-
-UNORDERED_AUTO_TEST(insert_hint_empty2) {
-    typedef boost::unordered_multimap<std::string, int> container;
-    container x;
-    x.emplace_hint(x.cbegin(), "hello", 50);
-    BOOST_TEST_EQ(x.size(), 1u);
-    BOOST_TEST_EQ(x.count("hello"), 1u);
-    BOOST_TEST_EQ(x.find("hello")->second, 50);
-    test::check_equivalent_keys(x);
-}
-
-UNORDERED_AUTO_TEST(insert_hint_single) {
-    typedef boost::unordered_multiset<std::string> container;
-    container x;
-    x.insert("equal");
-    x.insert(x.cbegin(), "equal");
-    BOOST_TEST_EQ(x.size(), 2u);
-    BOOST_TEST_EQ(x.count("equal"), 2u);
-    test::check_equivalent_keys(x);
-}
-
-UNORDERED_AUTO_TEST(insert_hint_single2) {
-    typedef boost::unordered_multimap<int, std::string> container;
-    container x;
-    x.emplace(10, "one");
-    x.emplace_hint(x.cbegin(), 10, "two");
-    BOOST_TEST_EQ(x.size(), 2u);
-    BOOST_TEST_EQ(x.count(10), 2u);
-
-    container::iterator it = x.find(10);
-    std::string v0 = (it++)->second;
-    std::string v1 = (it++)->second;
-
-    BOOST_TEST(v0 == "one" || v0 == "two");
-    BOOST_TEST(v1 == "one" || v1 == "two");
-    BOOST_TEST(v0 != v1);
-
-    test::check_equivalent_keys(x);
-}
-
-UNORDERED_AUTO_TEST(insert_hint_multiple) {
-    for (unsigned int size = 0; size < 10; ++size) {
-        for (unsigned int offset = 0; offset <= size;  ++offset) {
-            typedef boost::unordered_multiset<std::string> container;
-            container x;
-
-            for (unsigned int i = 0; i < size; ++i) { x.insert("multiple"); }
-
-            BOOST_TEST_EQ(x.size(), size);
-
-            container::const_iterator position = x.cbegin();
-            for (unsigned int i = 0; i < offset; ++i) { ++position; }
-
-            x.insert(position, "multiple");
-
-            BOOST_TEST_EQ(x.size(), size + 1u);
-            BOOST_TEST_EQ(x.count("multiple"), size + 1u);
-            test::check_equivalent_keys(x);
-        }
-    }
-}
-
-UNORDERED_AUTO_TEST(insert_hint_unique) {
-    typedef boost::unordered_set<int> container;
-    container x;
-    x.insert(x.cbegin(), 10);
-    BOOST_TEST_EQ(x.size(), 1u);
-    BOOST_TEST_EQ(x.count(10), 1u);
-    test::check_equivalent_keys(x);
-}
-
-UNORDERED_AUTO_TEST(insert_hint_unique_single) {
-    typedef boost::unordered_set<int> container;
-    container x;
-    x.insert(10);
-
-    x.insert(x.cbegin(), 10);
-    BOOST_TEST_EQ(x.size(), 1u);
-    BOOST_TEST_EQ(x.count(10), 1u);
-    test::check_equivalent_keys(x);
-
-    x.insert(x.cbegin(), 20);
-    BOOST_TEST_EQ(x.size(), 2u);
-    BOOST_TEST_EQ(x.count(10), 1u);
-    BOOST_TEST_EQ(x.count(20), 1u);
-    test::check_equivalent_keys(x);
-}
-
-}
-
-RUN_TESTS()

test/unordered/insert_stable_tests.cpp

@@ -4,10 +4,9 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
 
 #include <iostream>
@@ -49,8 +48,6 @@ UNORDERED_AUTO_TEST(stable_insert_test1) {
     x.insert(insert_stable::member(1,2));
     x.insert(insert_stable::member(1,3));
 
-    BOOST_TEST(x.count(insert_stable::member(1,4)) == 3);
-
     boost::unordered_multiset<insert_stable::member>::const_iterator
         it = x.begin(), end = x.end();
     BOOST_TEST(it != end);
@@ -68,11 +65,10 @@ UNORDERED_AUTO_TEST(stable_insert_test2) {
         boost::unordered_multimap<insert_stable::member, int>::const_iterator
         iterator;
 
-    iterator it = x.emplace(insert_stable::member(1,1), 1);
-    it = x.emplace(insert_stable::member(1,2), 2);
-    it = x.emplace(insert_stable::member(1,3), 3);
-
-    BOOST_TEST(x.count(insert_stable::member(1,4)) == 3);
+    iterator it
+        = x.insert(x.end(), std::make_pair(insert_stable::member(1,1), 1));
+    it = x.insert(it, std::make_pair(insert_stable::member(1,2), 2));
+    it = x.insert(it, std::make_pair(insert_stable::member(1,3), 3));
 
     it = x.begin();
     iterator end = x.end();

test/unordered/insert_tests.cpp

@@ -4,30 +4,28 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
+#include <boost/next_prior.hpp>
 #include "../objects/test.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
 #include "../helpers/equivalent.hpp"
 #include "../helpers/invariants.hpp"
 #include "../helpers/input_iterator.hpp"
-#include "../helpers/helpers.hpp"
 
 #include <iostream>
 
 namespace insert_tests {
     
-test::seed_t initialize_seed(243432);
+test::seed_t seed(243432);
 
 template <class X>
-void unique_insert_tests1(X*, test::random_generator generator)
+void unique_insert_tests1(X*,
+    test::random_generator generator = test::default_generator)
 {
-    test::check_instances check_;
-
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
 
@@ -54,7 +52,7 @@ void unique_insert_tests1(X*, test::random_generator generator)
 
         tracker.compare_key(x, *it);
 
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
@@ -62,13 +60,11 @@ void unique_insert_tests1(X*, test::random_generator generator)
 }
 
 template <class X>
-void equivalent_insert_tests1(X*, test::random_generator generator)
+void equivalent_insert_tests1(X*,
+    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"insert(value) tests for containers with equivalent keys.\n";
 
-    test::check_instances check_;
-
-
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
@@ -87,7 +83,7 @@ void equivalent_insert_tests1(X*, test::random_generator generator)
 
         tracker.compare_key(x, *it);
 
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
@@ -95,7 +91,8 @@ void equivalent_insert_tests1(X*, test::random_generator generator)
 }
 
 template <class X>
-void insert_tests2(X*, test::random_generator generator)
+void insert_tests2(X*,
+    test::random_generator generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME test::ordered<X> tracker_type;
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
@@ -105,8 +102,6 @@ void insert_tests2(X*, test::random_generator generator)
     std::cerr<<"insert(begin(), value) tests.\n";
 
     {
-        test::check_instances check_;
-
         X x;
         tracker_type tracker = test::create_ordered(x);
 
@@ -123,19 +118,16 @@ void insert_tests2(X*, test::random_generator generator)
             BOOST_TEST(*r1 == *r2);
             tracker.compare_key(x, *it);
 
-            if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
-        tracker.compare(x);
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"insert(end(), value) tests.\n";
 
     {
-        test::check_instances check_;
-
         X x;
         X const& x_const = x;
         tracker_type tracker = test::create_ordered(x);
@@ -153,19 +145,16 @@ void insert_tests2(X*, test::random_generator generator)
             BOOST_TEST(*r1 == *r2);
             tracker.compare_key(x, *it);
 
-            if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
-        tracker.compare(x);
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"insert(pos, value) tests.\n";
 
     {
-        test::check_instances check_;
-
         X x;
         const_iterator pos = x.begin();
         tracker_type tracker = test::create_ordered(x);
@@ -183,19 +172,16 @@ void insert_tests2(X*, test::random_generator generator)
             BOOST_TEST(*pos == *r2);
             tracker.compare_key(x, *it);
 
-            if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
-        tracker.compare(x);
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"insert single item range tests.\n";
 
     {
-        test::check_instances check_;
-
         X x;
         tracker_type tracker = test::create_ordered(x);
 
@@ -207,23 +193,20 @@ void insert_tests2(X*, test::random_generator generator)
                 old_bucket_count = x.bucket_count();
             float b = x.max_load_factor();
 
-            x.insert(it, test::next(it));
+            x.insert(it, boost::next(it));
             tracker.insert(*it);
             tracker.compare_key(x, *it);
 
-            if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+            if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
-        tracker.compare(x);
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"insert range tests.\n";
 
     {
-        test::check_instances check_;
-
         X x;
 
         test::random_values<X> v(1000, generator);
@@ -233,29 +216,9 @@ void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr<<"insert range with rehash tests.\n";
-
-    {
-        test::check_instances check_;
-
-        X x;
-
-        test::random_values<X> v(1000, generator);
-
-        x.insert(*v.begin());
-        x.clear();
-
-        x.insert(v.begin(), v.end());
-
-        test::check_container(x, v);
-        test::check_equivalent_keys(x);
-    }
-
     std::cerr<<"insert input iterator range tests.\n";
 
     {
-        test::check_instances check_;
-
         X x;
 
         test::random_values<X> v(1000, generator);
@@ -270,8 +233,6 @@ void insert_tests2(X*, test::random_generator generator)
     std::cerr<<"insert copy iterator range tests.\n";
 
     {
-        test::check_instances check_;
-
         X x;
 
         test::random_values<X> v(1000, generator);
@@ -280,61 +241,13 @@ void insert_tests2(X*, test::random_generator generator)
 
         test::check_equivalent_keys(x);
     }
-
-    std::cerr<<"insert copy iterator range test 2.\n";
-
-    {
-        test::check_instances check_;
-
-        X x;
-
-        test::random_values<X> v1(500, generator);
-        test::random_values<X> v2(500, generator);
-        x.insert(test::copy_iterator(v1.begin()), test::copy_iterator(v1.end()));
-        x.insert(test::copy_iterator(v2.begin()), test::copy_iterator(v2.end()));
-
-        test::check_equivalent_keys(x);
-    }
-
-    std::cerr<<"insert various ranges.\n";
-
-    {
-        for (int i = 0; i < 100; ++i) {
-            X x;
-            test::ordered<X> tracker = test::create_ordered(x);
-
-            test::random_values<X> v(1000, generator);
-
-            for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
-                    it = v.begin(); it != v.end();)
-            {
-                BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                float b = x.max_load_factor();
-
-                BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
-                    next = it;
-                for (std::size_t j = test::random_value(20); j > 0; ++j) {
-                    ++next;
-                    if (next == v.end()) { break; }
-                }
-
-                x.insert(it, next);
-                tracker.insert(it, next);
-                it = next;
-
-                tracker.compare(x); // Slow, but I can't see any other way.
-
-                if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
-                    BOOST_TEST(x.bucket_count() == old_bucket_count);
-            }
-
-            test::check_equivalent_keys(x);
-        }
-    }
 }
 
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+
 template <class X>
-void unique_emplace_tests1(X*, test::random_generator generator)
+void unique_emplace_tests1(X*,
+    test::random_generator generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
@@ -362,16 +275,16 @@ void unique_emplace_tests1(X*, test::random_generator generator)
 
         tracker.compare_key(x, *it);
 
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
-    tracker.compare(x);
     test::check_equivalent_keys(x);
 }
 
 template <class X>
-void equivalent_emplace_tests1(X*, test::random_generator generator)
+void equivalent_emplace_tests1(X*,
+    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"emplace(value) tests for containers with equivalent keys.\n";
 
@@ -393,83 +306,17 @@ void equivalent_emplace_tests1(X*, test::random_generator generator)
 
         tracker.compare_key(x, *it);
 
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
-    tracker.compare(x);
     test::check_equivalent_keys(x);
 }
 
-template <class X>
-void move_emplace_tests(X*, test::random_generator generator)
-{
-    std::cerr<<"emplace(move(value)) tests for containers with unique keys.\n";
-
-    X x;
-    test::ordered<X> tracker = test::create_ordered(x);
-
-    test::random_values<X> v(1000, generator);
-
-    for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
-            it != v.end(); ++it)
-    {
-
-        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-        float b = x.max_load_factor();
-
-        typename X::value_type value = *it;
-        x.emplace(boost::move(value));
-        tracker.insert(*it);
-        tracker.compare_key(x, *it);
-
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
-            BOOST_TEST(x.bucket_count() == old_bucket_count);
-    }
-
-    tracker.compare(x);
-    test::check_equivalent_keys(x);
-}
-
-template <class X>
-void default_emplace_tests(X*, test::random_generator)
-{
-#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
-    std::cerr<<"emplace() tests.\n";
-    bool is_unique = test::has_unique_keys<X>::value;
-
-    X x;
-
-    x.emplace();
-    BOOST_TEST(x.size() == 1);
-    x.emplace();
-    BOOST_TEST(x.size() == (is_unique ? 1u : 2u));
-    x.emplace();
-    BOOST_TEST(x.size() == (is_unique ? 1u : 3u));
-    
-    typename X::value_type y;
-    BOOST_TEST(x.count(test::get_key<X>(y)) == (is_unique ? 1u : 3u));
-    BOOST_TEST(*x.equal_range(test::get_key<X>(y)).first == y);
-
-    x.emplace(y);
-    BOOST_TEST(x.size() == (is_unique ? 1u : 4u));
-    BOOST_TEST(x.count(test::get_key<X>(y)) == (is_unique ? 1u : 4u));
-    BOOST_TEST(*x.equal_range(test::get_key<X>(y)).first == y);
-    
-    x.clear();
-    BOOST_TEST(x.empty());
-    x.emplace(y);
-    BOOST_TEST(x.size() == 1);
-    x.emplace(y);
-    BOOST_TEST(x.size() == (is_unique ? 1u : 2u));
-    
-    BOOST_TEST(x.count(test::get_key<X>(y)) == (is_unique ? 1u : 2u));
-    BOOST_TEST(*x.equal_range(test::get_key<X>(y)).first == y);
 #endif
-}
 
 template <class X>
-void map_tests(X*, test::random_generator generator)
+void map_tests(X*, test::random_generator generator = test::default_generator)
 {
     std::cerr<<"map tests.\n";
 
@@ -488,11 +335,10 @@ void map_tests(X*, test::random_generator generator)
 
         tracker.compare_key(x, *it);
 
-        if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+        if(static_cast<double>(x.size()) < b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
-    tracker.compare(x);
     test::check_equivalent_keys(x);   
 }
 
@@ -500,12 +346,11 @@ void map_tests(X*, test::random_generator generator)
 // value type.
 
 template <class X>
-void map_insert_range_test1(X*, test::random_generator generator)
+void map_insert_range_test1(X*,
+    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"map_insert_range_test1\n";
 
-    test::check_instances check_;
-
     typedef test::list<
         std::pair<
             BOOST_DEDUCED_TYPENAME X::key_type,
@@ -521,12 +366,11 @@ void map_insert_range_test1(X*, test::random_generator generator)
 }
 
 template <class X>
-void map_insert_range_test2(X*, test::random_generator generator)
+void map_insert_range_test2(X*,
+    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"map_insert_range_test2\n";
 
-    test::check_instances check_;
-
     typedef test::list<
         std::pair<BOOST_DEDUCED_TYPENAME X::key_type const, test::implicitly_convertible>
     > list;
@@ -540,98 +384,66 @@ void map_insert_range_test2(X*, test::random_generator generator)
     test::check_equivalent_keys(x);
 }
 
-boost::unordered_set<test::movable,
-    test::hash, test::equal_to,
-    std::allocator<test::movable> >* test_set_std_alloc;
-boost::unordered_multimap<test::object, test::object,
-    test::hash, test::equal_to,
-    std::allocator<test::object> >* test_multimap_std_alloc;
-
 boost::unordered_set<test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::movable,
+    test::allocator<test::object> >* test_set;
+boost::unordered_multiset<test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::movable> >* test_multiset;
-boost::unordered_map<test::movable, test::movable,
+    test::allocator<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator2<test::movable> >* test_map;
+    test::allocator<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
     test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_multimap;
+    test::allocator<test::object> >* test_multimap;
 
 using test::default_generator;
 using test::generate_collisions;
-using test::limited_range;
 
 UNORDERED_TEST(unique_insert_tests1,
-    ((test_set_std_alloc)(test_set)(test_map))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((test_set)(test_map))
+    ((default_generator)(generate_collisions))
 )
 
 UNORDERED_TEST(equivalent_insert_tests1,
-    ((test_multimap_std_alloc)(test_multiset)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((test_multiset)(test_multimap))
+    ((default_generator)(generate_collisions))
 )
 
 UNORDERED_TEST(insert_tests2,
-    ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((test_set)(test_multiset)(test_map)(test_multimap))
+    ((default_generator)(generate_collisions))
 )
 
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
 UNORDERED_TEST(unique_emplace_tests1,
-    ((test_set_std_alloc)(test_set)(test_map))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((test_set)(test_map))
+    ((default_generator)(generate_collisions))
 )
 
 UNORDERED_TEST(equivalent_emplace_tests1,
-    ((test_multimap_std_alloc)(test_multiset)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
-
-UNORDERED_TEST(move_emplace_tests,
-    ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)
-        (test_multiset)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
-)
-
-UNORDERED_TEST(default_emplace_tests,
-    ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)
-        (test_multiset)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((test_multiset)(test_multimap))
+    ((default_generator)(generate_collisions))
 )
+#endif
 
 UNORDERED_TEST(map_tests,
     ((test_map))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((default_generator)(generate_collisions))
 )
 
 UNORDERED_TEST(map_insert_range_test1,
-    ((test_multimap_std_alloc)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((test_map)(test_multimap))
+    ((default_generator)(generate_collisions))
 )
 
 UNORDERED_TEST(map_insert_range_test2,
-    ((test_multimap_std_alloc)(test_map)(test_multimap))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((test_map)(test_multimap))
+    ((default_generator)(generate_collisions))
 )
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-
-struct initialize_from_two_ints
-{
-    int a, b;
-
-    friend std::size_t hash_value(initialize_from_two_ints const& x)
-    {
-        return static_cast<std::size_t>(x.a + x.b);
-    }
-
-    bool operator==(initialize_from_two_ints const& x) const
-    {
-        return a == x.a && b == x.b;
-    }
-};
+#if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST) && \
+    !defined(BOOST_NO_INITIALIZER_LISTS)
 
 UNORDERED_AUTO_TEST(insert_initializer_list_set)
 {
@@ -640,38 +452,8 @@ UNORDERED_AUTO_TEST(insert_initializer_list_set)
     BOOST_TEST_EQ(set.size(), 3u);
     BOOST_TEST(set.find(1) != set.end());
     BOOST_TEST(set.find(4) == set.end());
-
-    boost::unordered_set<initialize_from_two_ints> set2;
-
-#if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5))
-    set2.insert({{1, 2}});
-#else
-    set2.insert({1, 2});
-#endif
-    BOOST_TEST(set2.size() == 1);
-    BOOST_TEST(set2.find({1,2}) != set2.end());
-    BOOST_TEST(set2.find({2,1}) == set2.end());
-
-    set2.insert({{3,4},{5,6},{7,8}});
-    BOOST_TEST(set2.size() == 4);
-    BOOST_TEST(set2.find({1,2}) != set2.end());
-    BOOST_TEST(set2.find({3,4}) != set2.end());
-    BOOST_TEST(set2.find({5,6}) != set2.end());
-    BOOST_TEST(set2.find({7,8}) != set2.end());
-    BOOST_TEST(set2.find({8,7}) == set2.end());
-
-    set2.insert({{2, 1}, {3,4}});
-    BOOST_TEST(set2.size() == 5);
-    BOOST_TEST(set2.find({1,2}) != set2.end());
-    BOOST_TEST(set2.find({2,1}) != set2.end());
-    BOOST_TEST(set2.find({3,4}) != set2.end());
-    BOOST_TEST(set2.find({5,6}) != set2.end());
-    BOOST_TEST(set2.find({7,8}) != set2.end());
-    BOOST_TEST(set2.find({8,7}) == set2.end());
 }
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, == 1800)
-
 UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
 {
     boost::unordered_multiset<std::string> multiset;
@@ -688,8 +470,6 @@ UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
     BOOST_TEST_EQ(multiset.count("c"), 0u);
 }
 
-#endif
-
 UNORDERED_AUTO_TEST(insert_initializer_list_map)
 {
     boost::unordered_map<std::string, std::string> map;
@@ -711,124 +491,6 @@ UNORDERED_AUTO_TEST(insert_initializer_list_multimap)
 
 #endif
 
-struct overloaded_constructor
-{
-    overloaded_constructor(int x1_ = 1, int x2_ = 2, int x3_ = 3, int x4_ = 4)
-      : x1(x1_), x2(x2_), x3(x3_), x4(x4_) {}
-
-    int x1, x2, x3, x4;
-    
-    bool operator==(overloaded_constructor const& rhs) const
-    {
-        return x1 == rhs.x1 && x2 == rhs.x2 && x3 == rhs.x3 && x4 == rhs.x4;
-    }
-    
-    friend std::size_t hash_value(overloaded_constructor const& x)
-    {
-        std::size_t hash = 0;
-        boost::hash_combine(hash, x.x1);
-        boost::hash_combine(hash, x.x2);
-        boost::hash_combine(hash, x.x3);
-        boost::hash_combine(hash, x.x4);
-        return hash;
-    }
-};
-
-UNORDERED_AUTO_TEST(map_emplace_test)
-{
-    boost::unordered_map<int, overloaded_constructor> x;
-
-#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
-    x.emplace();
-    BOOST_TEST(x.find(0) != x.end() &&
-        x.find(0)->second == overloaded_constructor());
-#endif
-
-    x.emplace(2, 3);
-    BOOST_TEST(x.find(2) != x.end() &&
-        x.find(2)->second == overloaded_constructor(3));
-}
-
-UNORDERED_AUTO_TEST(set_emplace_test)
-{
-    boost::unordered_set<overloaded_constructor> x;
-    overloaded_constructor check;
-
-#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
-    x.emplace();
-    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-#endif
-
-    x.clear();
-    x.emplace(1);
-    check = overloaded_constructor(1);
-    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-
-    x.clear();
-    x.emplace(2, 3);
-    check = overloaded_constructor(2, 3);
-    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-
-    x.clear();
-    x.emplace(4, 5, 6);
-    check = overloaded_constructor(4, 5, 6);
-    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-
-    x.clear();
-    x.emplace(7, 8, 9, 10);
-    check = overloaded_constructor(7, 8, 9, 10);
-    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-}
-
-struct derived_from_piecewise_construct_t :
-    boost::unordered::piecewise_construct_t {};
-
-derived_from_piecewise_construct_t piecewise_rvalue() {
-    return derived_from_piecewise_construct_t();
-}
-
-struct convertible_to_piecewise {
-    operator boost::unordered::piecewise_construct_t() const {
-        return boost::unordered::piecewise_construct;
-    }
-};
-
-UNORDERED_AUTO_TEST(map_emplace_test2)
-{
-    boost::unordered_map<overloaded_constructor, overloaded_constructor> x;
-
-    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(), boost::make_tuple());
-    BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
-        x.find(overloaded_constructor())->second == overloaded_constructor());
-
-    x.emplace(convertible_to_piecewise(), boost::make_tuple(1), boost::make_tuple());
-    BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
-        x.find(overloaded_constructor(1))->second == overloaded_constructor());
-
-    x.emplace(piecewise_rvalue(), boost::make_tuple(2,3), boost::make_tuple(4,5,6));
-    BOOST_TEST(x.find(overloaded_constructor(2,3)) != x.end() &&
-        x.find(overloaded_constructor(2,3))->second == overloaded_constructor(4,5,6));
-
-    derived_from_piecewise_construct_t d;
-    x.emplace(d, boost::make_tuple(9,3,1), boost::make_tuple(10));
-    BOOST_TEST(x.find(overloaded_constructor(9,3,1)) != x.end() &&
-        x.find(overloaded_constructor(9,3,1))->second == overloaded_constructor(10));
-}
-
-UNORDERED_AUTO_TEST(set_emplace_test2)
-{
-    boost::unordered_set<std::pair<overloaded_constructor, overloaded_constructor> > x;
-    std::pair<overloaded_constructor, overloaded_constructor> check;
-
-    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(), boost::make_tuple());
-    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-
-    x.clear();
-    x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(1), boost::make_tuple(2,3));
-    check = std::make_pair(overloaded_constructor(1), overloaded_constructor(2, 3));;
-    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-}
-
 }
 
 RUN_TESTS()

test/unordered/link_test_1.cpp

@@ -4,9 +4,9 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
 
 void foo(boost::unordered_set<int>&,
         boost::unordered_map<int, int>&,

test/unordered/link_test_2.cpp

@@ -4,9 +4,9 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
 
 void foo(boost::unordered_set<int>& x1,
         boost::unordered_map<int, int>& x2,

test/unordered/load_factor_tests.cpp

@@ -4,10 +4,9 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
 #include <boost/limits.hpp>
 #include "../helpers/random_values.hpp"
@@ -20,10 +19,10 @@
 namespace load_factor_tests
 {
 
-test::seed_t initialize_seed(783656);
+test::seed_t seed(783656);
 
 template <class X>
-void set_load_factor_tests(X*)
+void set_load_factor_tests(X* = 0)
 {
     X x;
 
@@ -37,7 +36,8 @@ void set_load_factor_tests(X*)
 }
 
 template <class X>
-void insert_test(X*, float mlf, test::random_generator generator)
+void insert_test(X*, float mlf,
+    test::random_generator generator = test::default_generator)
 {
     X x;
     x.max_load_factor(mlf);
@@ -51,24 +51,22 @@ void insert_test(X*, float mlf, test::random_generator generator)
         BOOST_DEDUCED_TYPENAME X::size_type old_size = x.size(),
                  old_bucket_count = x.bucket_count();
         x.insert(*it);
-        if(static_cast<double>(old_size + 1) <= b * static_cast<double>(old_bucket_count))
+        if(static_cast<double>(old_size + 1) < b * static_cast<double>(old_bucket_count))
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 }
 
 template <class X>
-void load_factor_insert_tests(X* ptr, test::random_generator generator)
+void load_factor_insert_tests(X* ptr = 0)
 {
-    insert_test(ptr, 1.0f, generator);
-    insert_test(ptr, 0.1f, generator);
-    insert_test(ptr, 100.0f, generator);
+    insert_test(ptr, 1.0f);
+    insert_test(ptr, 0.1f);
+    insert_test(ptr, 100.0f);
 
-    insert_test(ptr, (std::numeric_limits<float>::min)(),
-        generator);
+    insert_test(ptr, (std::numeric_limits<float>::min)());
 
     if(std::numeric_limits<float>::has_infinity)
-        insert_test(ptr, std::numeric_limits<float>::infinity(),
-            generator);
+        insert_test(ptr, std::numeric_limits<float>::infinity());
 }
 
 boost::unordered_set<int>* int_set_ptr;
@@ -76,17 +74,12 @@ boost::unordered_multiset<int>* int_multiset_ptr;
 boost::unordered_map<int, int>* int_map_ptr;
 boost::unordered_multimap<int, int>* int_multimap_ptr;
 
-using test::default_generator;
-using test::generate_collisions;
-using test::limited_range;
-
 UNORDERED_TEST(set_load_factor_tests,
     ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
 )
 
 UNORDERED_TEST(load_factor_insert_tests,
     ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
 )
 
 }

test/unordered/minimal_allocator.cpp

@@ -1,95 +0,0 @@
-
-// Copyright 2011 Daniel James.
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/unordered/detail/allocate.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/static_assert.hpp>
-#include "../objects/test.hpp"
-
-template <class Tp> 
-struct SimpleAllocator
-{ 
-    typedef Tp value_type;
-
-    SimpleAllocator()
-    {
-    }
-
-    template <class T> SimpleAllocator(const SimpleAllocator<T>&)
-    {
-    }
-
-    Tp *allocate(std::size_t n)
-    {
-        return static_cast<Tp*>(::operator new(n * sizeof(Tp)));
-    }
-
-    void deallocate(Tp* p, std::size_t)
-    {
-        ::operator delete((void*) p);
-    }
-};
-
-template <typename T>
-void test_simple_allocator()
-{
-    test::check_instances check_;
-
-    typedef boost::unordered::detail::allocator_traits<
-        SimpleAllocator<T> > traits;
-
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::allocator_type, SimpleAllocator<T> >::value));
-
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::value_type, T>::value));
-
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::pointer, T* >::value));
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::const_pointer, T const*>::value));
-    //BOOST_STATIC_ASSERT((boost::is_same<typename traits::void_pointer, void* >::value));
-    //BOOST_STATIC_ASSERT((boost::is_same<typename traits::const_void_pointer, void const*>::value));
-
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::difference_type, std::ptrdiff_t>::value));
-
-#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::size_type,
-        std::make_unsigned<std::ptrdiff_t>::type>::value));
-#else
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::size_type, std::size_t>::value));
-#endif
-
-    BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
-    BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
-    BOOST_TEST(!traits::propagate_on_container_swap::value);
-
-    // rebind_alloc
-    // rebind_traits
-
-    SimpleAllocator<T> a;
-
-    T* ptr1 = traits::allocate(a, 1);
-    //T* ptr2 = traits::allocate(a, 1, static_cast<void const*>(ptr1));
-    
-    traits::construct(a, ptr1, T(10));
-    //traits::construct(a, ptr2, T(30), ptr1);
-
-    BOOST_TEST(*ptr1 == T(10));
-    //BOOST_TEST(*ptr2 == T(30));
-
-    traits::destroy(a, ptr1);
-    //traits::destroy(a, ptr2);
-
-    //traits::deallocate(a, ptr2, 1);
-    traits::deallocate(a, ptr1, 1);
-
-    traits::max_size(a);
-}
-
-int main()
-{
-    test_simple_allocator<int>();
-    test_simple_allocator<test::object>();
-
-    return boost::report_errors();
-}

test/unordered/move_tests.cpp

@@ -4,30 +4,19 @@
 // file LICENSE_1_0.txt or move at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
 #include "../objects/test.hpp"
-#include "../objects/cxx11_allocator.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
 #include "../helpers/equivalent.hpp"
 #include "../helpers/invariants.hpp"
 
-#if defined(BOOST_MSVC)
-#pragma warning(disable:4127) // conditional expression is constant
-#endif
-
 namespace move_tests
 {
-    test::seed_t initialize_seed(98624);
-#if defined(BOOST_UNORDERED_USE_MOVE) || !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#define BOOST_UNORDERED_TEST_MOVING 1
-#else
-#define BOOST_UNORDERED_TEST_MOVING 0
-#endif
+    test::seed_t seed(98624);
 
     template<class T>
     T empty(T*) {
@@ -57,15 +46,14 @@ namespace move_tests
     }
 
     template <class T>
-    void move_construct_tests1(T* ptr, test::random_generator const& generator)
+    void move_construct_tests1(T* ptr,
+        test::random_generator const& generator = test::default_generator)
     {
         BOOST_DEDUCED_TYPENAME T::hasher hf;
         BOOST_DEDUCED_TYPENAME T::key_equal eq;
         BOOST_DEDUCED_TYPENAME T::allocator_type al;
 
         {
-            test::check_instances check_;
-
             T y(empty(ptr));
             BOOST_TEST(y.empty());
             BOOST_TEST(test::equivalent(y.hash_function(), hf));
@@ -76,8 +64,6 @@ namespace move_tests
         }
 
         {
-            test::check_instances check_;
-
             test::random_values<T> v(1000, generator);
             test::object_count count;
             T y(create(v, count));
@@ -90,16 +76,15 @@ namespace move_tests
     }
 
     template <class T>
-    void move_assign_tests1(T*, test::random_generator const& generator)
+    void move_assign_tests1(T*,
+        test::random_generator const& generator = test::default_generator)
     {
         {
-            test::check_instances check_;
-
             test::random_values<T> v(500, generator);
             test::object_count count;
             T y;
             y = create(v, count);
-#if BOOST_UNORDERED_TEST_MOVING && defined(BOOST_HAS_NRVO)
+#if defined(BOOST_HAS_NRVO)
             BOOST_TEST(count == test::global_object_count);
 #endif
             test::check_container(y, v);
@@ -108,7 +93,8 @@ namespace move_tests
     }
 
     template <class T>
-    void move_construct_tests2(T*, test::random_generator const& generator)
+    void move_construct_tests2(T*,
+            test::random_generator const& generator = test::default_generator)
     {
         BOOST_DEDUCED_TYPENAME T::hasher hf(1);
         BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
@@ -118,8 +104,6 @@ namespace move_tests
         test::object_count count;
 
         {
-            test::check_instances check_;
-
             test::random_values<T> v(500, generator);
             T y(create(v, count, hf, eq, al, 0.5));
 #if defined(BOOST_HAS_NRVO)
@@ -134,8 +118,6 @@ namespace move_tests
         }
 
         {
-            test::check_instances check_;
-
             // TODO: To do this correctly requires the fancy new allocator
             // stuff.
             test::random_values<T> v(500, generator);
@@ -148,27 +130,16 @@ namespace move_tests
             BOOST_TEST(y.max_load_factor() == 2.0); // Not necessarily required.
             test::check_equivalent_keys(y);
         }
-
+/*
         {
-            test::check_instances check_;
-
             test::random_values<T> v(25, generator);
             T y(create(v, count, hf, eq, al, 1.0), al);
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
             BOOST_TEST(count == test::global_object_count);
-#elif defined(BOOST_HAS_NRVO)
-            BOOST_TEST(
-                static_cast<std::size_t>(test::global_object_count.constructions
-                    - count.constructions) <=
-                (test::is_set<T>::value ? 1 : 2) *
-                    (test::has_unique_keys<T>::value ? 25 : v.size()));
-            BOOST_TEST(count.instances == test::global_object_count.instances);
 #else
             BOOST_TEST(
-                static_cast<std::size_t>(test::global_object_count.constructions
-                    - count.constructions) <=
-                (test::is_set<T>::value ? 2 : 4) *
-                    (test::has_unique_keys<T>::value ? 25 : v.size()));
+                test::global_object_count.constructions - count.constructions <=
+                (test::is_map<T>::value ? 50 : 25));
             BOOST_TEST(count.instances == test::global_object_count.instances);
 #endif
             test::check_container(y, v);
@@ -178,228 +149,33 @@ namespace move_tests
             BOOST_TEST(y.max_load_factor() == 1.0); // Not necessarily required.
             test::check_equivalent_keys(y);
         }
-    }
-
-    template <class T>
-    void move_assign_tests2(T*, test::random_generator const& generator)
-    {
-        BOOST_DEDUCED_TYPENAME T::hasher hf(1);
-        BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
-        BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
-        BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
-        typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
-
-        {
-            test::random_values<T> v(500, generator);
-            test::random_values<T> v2(0, generator);
-            T y(v.begin(), v.end(), 0, hf, eq, al1);
-            test::object_count count;
-            y = create(v2, count, hf, eq, al2, 2.0);
-            BOOST_TEST(y.empty());
-            test::check_container(y, v2);
-            test::check_equivalent_keys(y);
-            BOOST_TEST(y.max_load_factor() == 2.0);
-
-#if defined(BOOST_HAS_NRVO)
-            if (BOOST_UNORDERED_TEST_MOVING ?
-                    (bool) allocator_type::is_propagate_on_move :
-                    (bool) allocator_type::is_propagate_on_assign)
-            {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
-            }
-            else {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
-            }
-#endif
-        }
-
-        {
-            test::random_values<T> v(500, generator);
-            test::object_count count;
-            T y(0, hf, eq, al1);
-            y = create(v, count, hf, eq, al2, 0.5);
-#if defined(BOOST_HAS_NRVO)
-            if (BOOST_UNORDERED_TEST_MOVING &&
-                    allocator_type::is_propagate_on_move)
-            {
-                BOOST_TEST(count == test::global_object_count);
-            }
-#endif
-            test::check_container(y, v);
-            test::check_equivalent_keys(y);
-            BOOST_TEST(y.max_load_factor() == 0.5);
-
-#if defined(BOOST_HAS_NRVO)
-            if (BOOST_UNORDERED_TEST_MOVING ?
-                    (bool) allocator_type::is_propagate_on_move :
-                    (bool) allocator_type::is_propagate_on_assign)
-            {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
-            }
-            else {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
-            }
-#endif
-        }
-
-        {
-            test::check_instances check_;
-
-            test::random_values<T> v(500, generator);
-            T y(0, hf, eq, al1);
-
-            T x(0, hf, eq, al2);
-            x.max_load_factor(0.25);
-            x.insert(v.begin(), v.end());
-
-            test::object_count count = test::global_object_count;
-            y = boost::move(x);
-            if (BOOST_UNORDERED_TEST_MOVING &&
-                    allocator_type::is_propagate_on_move)
-            {
-                BOOST_TEST(count == test::global_object_count);
-            }
-            test::check_container(y, v);
-            test::check_equivalent_keys(y);
-            BOOST_TEST(y.max_load_factor() == 0.25);
-
-            if (BOOST_UNORDERED_TEST_MOVING ?
-                    (bool) allocator_type::is_propagate_on_move :
-                    (bool) allocator_type::is_propagate_on_assign)
-            {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
-            }
-            else {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
-            }
-        }
-
-        {
-            test::check_instances check_;
-
-            test::random_values<T> v1(1000, generator);
-            test::random_values<T> v2(200, generator);
-
-            T x(0, hf, eq, al2);
-            x.max_load_factor(0.5);
-            x.insert(v2.begin(), v2.end());
-
-            test::object_count count1 = test::global_object_count;
-
-            T y(v1.begin(), v1.end(), 0, hf, eq, al1);
-            y = boost::move(x);
-
-            test::object_count count2 = test::global_object_count;
-
-            if (BOOST_UNORDERED_TEST_MOVING &&
-                    allocator_type::is_propagate_on_move)
-            {
-                BOOST_TEST(count1.instances ==
-                    test::global_object_count.instances);
-                BOOST_TEST(count2.constructions ==
-                    test::global_object_count.constructions);
-            }
-
-            test::check_container(y, v2);
-            test::check_equivalent_keys(y);
-            BOOST_TEST(y.max_load_factor() == 0.5);
-
-            if (BOOST_UNORDERED_TEST_MOVING ?
-                    (bool) allocator_type::is_propagate_on_move :
-                    (bool) allocator_type::is_propagate_on_assign)
-            {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al2));
-            }
-            else {
-                BOOST_TEST(test::equivalent(y.get_allocator(), al1));
-            }
-        }
-    }
-
-    boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        std::allocator<test::object> >* test_map_std_alloc;
+*/    }
 
     boost::unordered_set<test::object,
         test::hash, test::equal_to,
-        test::allocator2<test::object> >* test_set;
+        test::allocator<test::object> >* test_set;
     boost::unordered_multiset<test::object,
         test::hash, test::equal_to,
-        test::allocator1<test::object> >* test_multiset;
+        test::allocator<test::object> >* test_multiset;
     boost::unordered_map<test::object, test::object,
         test::hash, test::equal_to,
-        test::allocator1<test::object> >* test_map;
+        test::allocator<test::object> >* test_map;
     boost::unordered_multimap<test::object, test::object,
         test::hash, test::equal_to,
-        test::allocator2<test::object> >* test_multimap;
-
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_move> >*
-    test_set_prop_move;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_move> >*
-    test_multiset_prop_move;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_move> >*
-    test_map_prop_move;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_move> >*
-    test_multimap_prop_move;
-
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_move> >*
-    test_set_no_prop_move;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_move> >*
-    test_multiset_no_prop_move;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_move> >*
-    test_map_no_prop_move;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_move> >*
-    test_multimap_no_prop_move;
+        test::allocator<test::object> >* test_multimap;
 
     using test::default_generator;
     using test::generate_collisions;
-    using test::limited_range;
 
-    UNORDERED_TEST(move_construct_tests1, (
-            (test_map_std_alloc)
-            (test_set)(test_multiset)(test_map)(test_multimap)
-            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
-            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
-        )
-        ((default_generator)(generate_collisions)(limited_range))
+    UNORDERED_TEST(move_construct_tests1,
+        ((test_set)(test_multiset)(test_map)(test_multimap))
     )
-    UNORDERED_TEST(move_assign_tests1, (
-            (test_map_std_alloc)
-            (test_set)(test_multiset)(test_map)(test_multimap)
-            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
-            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
-        )
-        ((default_generator)(generate_collisions)(limited_range))
+    UNORDERED_TEST(move_assign_tests1,
+        ((test_set)(test_multiset)(test_map)(test_multimap))
     )
-    UNORDERED_TEST(move_construct_tests2, (
-            (test_set)(test_multiset)(test_map)(test_multimap)
-            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
-            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
-        )
-        ((default_generator)(generate_collisions)(limited_range))
-    )
-    UNORDERED_TEST(move_assign_tests2, (
-            (test_set)(test_multiset)(test_map)(test_multimap)
-            (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
-            (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
-        )
-        ((default_generator)(generate_collisions)(limited_range))
+    UNORDERED_TEST(move_construct_tests2,
+        ((test_set)(test_multiset)(test_map)(test_multimap))
+        ((default_generator)(generate_collisions))
     )
 }
 

test/unordered/noexcept_tests.cpp

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

test/unordered/rehash_tests.cpp

@@ -4,31 +4,28 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
-#include "../helpers/metafunctions.hpp"
-#include "../objects/test.hpp"
 
 namespace rehash_tests
 {
 
-test::seed_t initialize_seed(2974);
+test::seed_t seed(2974);
 
 template <class X>
 bool postcondition(X const& x, BOOST_DEDUCED_TYPENAME X::size_type n)
 {
-    return static_cast<double>(x.bucket_count()) >=
+    return static_cast<double>(x.bucket_count()) >
         static_cast<double>(x.size()) / x.max_load_factor() &&
         x.bucket_count() >= n;
 }
 
 template <class X>
-void rehash_empty_test1(X*)
+void rehash_empty_test1(X* = 0)
 {
     X x;
 
@@ -37,13 +34,11 @@ void rehash_empty_test1(X*)
 
     x.rehash(0);
     BOOST_TEST(postcondition(x, 0));
-
-    x.rehash(10000000);
-    BOOST_TEST(postcondition(x, 10000000));
 }
 
 template <class X>
-void rehash_empty_test2(X*, test::random_generator generator)
+void rehash_empty_test2(X* = 0,
+    test::random_generator generator = test::default_generator)
 {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
@@ -58,14 +53,11 @@ void rehash_empty_test2(X*, test::random_generator generator)
     tracker.compare(x);
 
     BOOST_TEST(postcondition(x, 10000));
-    
-    x.rehash(10000000);
-    tracker.compare(x);
-    BOOST_TEST(postcondition(x, 10000000));
 }
 
 template <class X>
-void rehash_empty_test3(X*, test::random_generator generator)
+void rehash_empty_test3(X* = 0,
+    test::random_generator generator = test::default_generator)
 {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
@@ -82,8 +74,10 @@ void rehash_empty_test3(X*, test::random_generator generator)
     BOOST_TEST(postcondition(x, 0));
 }
 
+
 template <class X>
-void rehash_test1(X*, test::random_generator generator)
+void rehash_test1(X* = 0,
+    test::random_generator generator = test::default_generator)
 {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
@@ -105,139 +99,22 @@ void rehash_test1(X*, test::random_generator generator)
     tracker.compare(x);
 }
 
-template <class X>
-void reserve_empty_test1(X*)
-{
-    X x;
-
-    x.reserve(10000);
-    BOOST_TEST(x.bucket_count() >= 10000);
-
-    x.reserve(0);
-
-    x.reserve(10000000);
-    BOOST_TEST(x.bucket_count() >= 10000000);
-}
-
-template <class X>
-void reserve_empty_test2(X*)
-{
-    X x;
-    x.max_load_factor(0.25);
-
-    x.reserve(10000);
-    BOOST_TEST(x.bucket_count() >= 40000);
-
-    x.reserve(0);
-
-    x.reserve(10000000);
-    BOOST_TEST(x.bucket_count() >= 40000000);
-}
-
-template <class X>
-void reserve_test1(X*, test::random_generator generator)
-{
-    for (int random_mlf = 0; random_mlf < 2; ++random_mlf)
-    {
-        for (std::size_t i = 1; i < 2000; i += i < 50 ? 1 : 13)
-        {
-            test::random_values<X> v(i, generator);
-
-            test::ordered<X> tracker;
-            tracker.insert_range(v.begin(), v.end());
-
-            X x;
-            x.max_load_factor(random_mlf ?
-                static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f : 1.0f);
-            x.reserve(test::has_unique_keys<X>::value ? i : v.size());
-
-            // Insert an element before the range insert, otherwise there are
-            // no iterators to invalidate in the range insert, and it can
-            // rehash.
-            typename test::random_values<X>::iterator it = v.begin();
-            x.insert(*it);
-            ++it;
-
-            std::size_t bucket_count = x.bucket_count();
-            x.insert(it, v.end());
-            BOOST_TEST(bucket_count == x.bucket_count());
-            tracker.compare(x);
-        }
-    }
-}
-
-template <class X>
-void reserve_test2(X*, test::random_generator generator)
-{
-    for (int random_mlf = 0; random_mlf < 2; ++random_mlf)
-    {
-        for (std::size_t i = 0; i < 2000; i += i < 50 ? 1 : 13)
-        {
-            test::random_values<X> v(i, generator);
-
-            test::ordered<X> tracker;
-            tracker.insert_range(v.begin(), v.end());
-
-            X x;
-            x.max_load_factor(random_mlf ?
-                static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f : 1.0f);
-
-            x.reserve(test::has_unique_keys<X>::value ? i : v.size());
-
-            std::size_t bucket_count = x.bucket_count();
-            for (typename test::random_values<X>::iterator it = v.begin();
-                    it != v.end(); ++it)
-            {
-                x.insert(*it);
-            }
-
-            BOOST_TEST(bucket_count == x.bucket_count());
-            tracker.compare(x);
-        }
-    }
-}
-
 boost::unordered_set<int>* int_set_ptr;
-boost::unordered_multiset<test::object,
-    test::hash, test::equal_to,
-    test::allocator2<test::object> >* test_multiset_ptr;
-boost::unordered_map<test::movable, test::movable,
-    test::hash, test::equal_to,
-    test::allocator2<test::movable> >* test_map_ptr;
+boost::unordered_multiset<int>* int_multiset_ptr;
+boost::unordered_map<int, int>* int_map_ptr;
 boost::unordered_multimap<int, int>* int_multimap_ptr;
 
-using test::default_generator;
-using test::generate_collisions;
-using test::limited_range;
-
 UNORDERED_TEST(rehash_empty_test1,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
 )
 UNORDERED_TEST(rehash_empty_test2,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
 )
 UNORDERED_TEST(rehash_empty_test3,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
 )
 UNORDERED_TEST(rehash_test1,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
-)
-UNORDERED_TEST(reserve_empty_test1,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-)
-UNORDERED_TEST(reserve_empty_test2,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-)
-UNORDERED_TEST(reserve_test1,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
-)
-UNORDERED_TEST(reserve_test2,
-    ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))
-    ((default_generator)(generate_collisions)(limited_range))
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
 )
 
 }

test/unordered/simple_tests.cpp

@@ -6,10 +6,9 @@
 // This test checks the runtime requirements of containers.
 
 #include "../helpers/prefix.hpp"
+
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
-
 #include "../helpers/test.hpp"
 #include <cstdlib>
 #include <algorithm>

test/unordered/swap_tests.cpp

@@ -4,28 +4,22 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/prefix.hpp"
-#include <boost/unordered_set.hpp>
-#include <boost/unordered_map.hpp>
-#include "../helpers/postfix.hpp"
 
 #include <boost/config.hpp>
 #include <algorithm>
 #include <iterator>
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
 #include "../helpers/test.hpp"
 #include "../objects/test.hpp"
-#include "../objects/cxx11_allocator.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
 #include "../helpers/invariants.hpp"
 
-#if defined(BOOST_MSVC)
-#pragma warning(disable:4127) // conditional expression is constant
-#endif
-
 namespace swap_tests
 {
 
-test::seed_t initialize_seed(783472);
+test::seed_t seed(783472);
 
 template <class X>
 void swap_test_impl(X& x1, X& x2)
@@ -40,25 +34,19 @@ void swap_test_impl(X& x1, X& x2)
 }
 
 template <class X>
-void swap_tests1(X*, test::random_generator generator)
+void swap_tests1(X*, test::random_generator generator = test::default_generator)
 {
     {
-        test::check_instances check_;
-
         X x;
         swap_test_impl(x, x);
     }
 
     {
-        test::check_instances check_;
-
         X x,y;
         swap_test_impl(x, y);
     }
 
     {
-        test::check_instances check_;
-
         test::random_values<X> v(1000, generator);
         X x, y(v.begin(), v.end());
         swap_test_impl(x, y);
@@ -66,8 +54,6 @@ void swap_tests1(X*, test::random_generator generator)
     }
 
     {
-        test::check_instances check_;
-
         test::random_values<X> vx(1000, generator), vy(1000, generator);
         X x(vx.begin(), vx.end()), y(vy.begin(), vy.end());
         swap_test_impl(x, y);
@@ -76,25 +62,22 @@ void swap_tests1(X*, test::random_generator generator)
 }
 
 template <class X>
-void swap_tests2(X* ptr, test::random_generator generator)
+void swap_tests2(X* ptr = 0,
+    test::random_generator generator = test::default_generator)
 {
-    swap_tests1(ptr, generator);
+    swap_tests1(ptr);
 
     typedef BOOST_DEDUCED_TYPENAME X::hasher hasher;
     typedef BOOST_DEDUCED_TYPENAME X::key_equal key_equal;
     typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
 
     {
-        test::check_instances check_;
-
         X x(0, hasher(1), key_equal(1));
         X y(0, hasher(2), key_equal(2));
         swap_test_impl(x, y);
     }
 
     {
-        test::check_instances check_;
-
         test::random_values<X> v(1000, generator);
         X x(v.begin(), v.end(), 0, hasher(1), key_equal(1));
         X y(0, hasher(2), key_equal(2));
@@ -102,8 +85,6 @@ void swap_tests2(X* ptr, test::random_generator generator)
     }
 
     {
-        test::check_instances check_;
-
         test::random_values<X> vx(100, generator), vy(50, generator);
         X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1));
         X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2));
@@ -111,125 +92,56 @@ void swap_tests2(X* ptr, test::random_generator generator)
         swap_test_impl(x, y);
     }
 
+#if BOOST_UNORDERED_SWAP_METHOD == 1
+    {
+        test::random_values<X> vx(100, generator), vy(50, generator);
+        X x(vx.begin(), vx.end(), 0, hasher(), key_equal(), allocator_type(1));
+        X y(vy.begin(), vy.end(), 0, hasher(), key_equal(), allocator_type(2));
+        try {
+            swap_test_impl(x, y);
+            BOOST_ERROR("Using swap method 1, "
+                "swapping with unequal allocators didn't throw.");
+        } catch (std::runtime_error) {}
+    }
+#else
     {
-        test::force_equal_allocator force_(
-            !allocator_type::is_propagate_on_swap);
-        test::check_instances check_;
-
         test::random_values<X> vx(50, generator), vy(100, generator);
         X x(vx.begin(), vx.end(), 0, hasher(), key_equal(), allocator_type(1));
         X y(vy.begin(), vy.end(), 0, hasher(), key_equal(), allocator_type(2));
-
-        if (allocator_type::is_propagate_on_swap ||
-            x.get_allocator() == y.get_allocator())
-        {
-            swap_test_impl(x, y);
-        }
+        swap_test_impl(x, y);
     }
 
     {
-        test::force_equal_allocator force_(
-            !allocator_type::is_propagate_on_swap);
-        test::check_instances check_;
-
         test::random_values<X> vx(100, generator), vy(100, generator);
         X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1),
             allocator_type(1));
         X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2),
             allocator_type(2));
-
-        if (allocator_type::is_propagate_on_swap ||
-            x.get_allocator() == y.get_allocator())
-        {
-            swap_test_impl(x, y);
-            swap_test_impl(x, y);
-        }
+        swap_test_impl(x, y);
+        swap_test_impl(x, y);
     }
+#endif
 }
 
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        std::allocator<test::object> >* test_map_std_alloc;
-
 boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::allocator1<test::object> >* test_set;
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_set;
 boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::allocator2<test::object> >* test_multiset;
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multiset;
 boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::allocator1<test::object> >* test_map;
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_map;
 boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::allocator2<test::object> >* test_multimap;
+    test::hash, test::equal_to,
+    test::allocator<test::object> >* test_multimap;
 
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_swap> >*
-    test_set_prop_swap;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_swap> >*
-    test_multiset_prop_swap;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_swap> >*
-    test_map_prop_swap;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::propagate_swap> >*
-    test_multimap_prop_swap;
-
-boost::unordered_set<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
-    test_set_no_prop_swap;
-boost::unordered_multiset<test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
-    test_multiset_no_prop_swap;
-boost::unordered_map<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
-    test_map_no_prop_swap;
-boost::unordered_multimap<test::object, test::object,
-        test::hash, test::equal_to,
-        test::cxx11_allocator<test::object, test::no_propagate_swap> >*
-    test_multimap_no_prop_swap;
-
-template <typename T>
-bool is_propagate(T*)
-{
-    return T::allocator_type::is_propagate_on_swap;
-}
-
-using test::default_generator;
-using test::generate_collisions;
-using test::limited_range;
-
-UNORDERED_AUTO_TEST(check_traits)
-{
-    BOOST_TEST(!is_propagate(test_set));
-    BOOST_TEST(is_propagate(test_set_prop_swap));
-    BOOST_TEST(!is_propagate(test_set_no_prop_swap));
-}
-
-UNORDERED_TEST(swap_tests1, (
-        (test_map_std_alloc)
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap)
-        (test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(test_multimap_no_prop_swap)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
+UNORDERED_TEST(swap_tests1,
+    ((test_set)(test_multiset)(test_map)(test_multimap))
 )
 
-UNORDERED_TEST(swap_tests2, (
-        (test_set)(test_multiset)(test_map)(test_multimap)
-        (test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap)
-        (test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(test_multimap_no_prop_swap)
-    )
-    ((default_generator)(generate_collisions)(limited_range))
+UNORDERED_TEST(swap_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap))
 )
 
 }