From 958b1d468f1211173652bc2a1e9439c674b05b1a Mon Sep 17 00:00:00 2001
From: Daniel James <daniel@calamity.org.uk>
Date: Sun, 8 Jul 2012 11:55:10 +0000
Subject: [PATCH] Unordered: Reduce the amount of meta-stuff in the tests.

Some of this was there for older compilers, some is just premature
generalization. There's still too much metaprogramming, but these are things
that are relatively easy to remove.

[SVN r79356]
---
 test/helpers/check_return_type.hpp   |  8 +--
 test/helpers/memory.hpp              |  2 -
 test/helpers/metafunctions.hpp       | 59 +++--------------
 test/helpers/random_values.hpp       | 10 +--
 test/helpers/strong.hpp              |  1 -
 test/helpers/tracker.hpp             | 96 +++++++++++-----------------
 test/unordered/allocator_traits.cpp  | 50 +++++++--------
 test/unordered/compile_tests.hpp     | 79 +++++++++++------------
 test/unordered/minimal_allocator.cpp | 22 +++----
 test/unordered/move_tests.cpp        |  4 +-
 10 files changed, 134 insertions(+), 197 deletions(-)

diff --git a/test/helpers/check_return_type.hpp b/test/helpers/check_return_type.hpp
index bfcaab41..b73f9869 100644
--- a/test/helpers/check_return_type.hpp
+++ b/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/mpl/assert.hpp>
+#include <boost/static_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_MPL_ASSERT((boost::is_same<T1, T2>));
+            BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
         }
 
         template <class T2>
         static void equals_ref(T2&)
         {
-            BOOST_MPL_ASSERT((boost::is_same<T1, T2>));
+            BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
         }
 
         template <class T2>
         static void convertible(T2)
         {
-            BOOST_MPL_ASSERT((boost::is_convertible<T2, T1>));
+            BOOST_STATIC_ASSERT((boost::is_convertible<T2, T1>::value));
         }
     };
 }
diff --git a/test/helpers/memory.hpp b/test/helpers/memory.hpp
index b3638d47..a30d7522 100644
--- a/test/helpers/memory.hpp
+++ b/test/helpers/memory.hpp
@@ -8,10 +8,8 @@
 
 #include <memory>
 #include <map>
-#include <boost/mpl/apply.hpp>
 #include <boost/assert.hpp>
 #include <boost/unordered/detail/allocate.hpp>
-#include <boost/mpl/aux_/config/eti.hpp>
 #include "../helpers/test.hpp"
 
 namespace test
diff --git a/test/helpers/metafunctions.hpp b/test/helpers/metafunctions.hpp
index 8c8afaaa..139fe0a2 100644
--- a/test/helpers/metafunctions.hpp
+++ b/test/helpers/metafunctions.hpp
@@ -8,72 +8,33 @@
 
 #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
     {
-        BOOST_STATIC_CONSTANT(bool, value = 
-            sizeof(has_unique_key_impl((Container const*)0))
-                == sizeof(yes_type));
+        BOOST_STATIC_CONSTANT(bool, value = false);
     };
 
-    template <class Container>
-    struct has_equivalent_keys
+    template <class V, class H, class P, class A>
+    struct has_unique_keys<boost::unordered_set<V, H, P, A> >
     {
-        BOOST_STATIC_CONSTANT(bool, value = 
-            sizeof(has_unique_key_impl((Container const*)0))
-                == sizeof(no_type));
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+
+    template <class K, class M, class H, class P, class A>
+    struct has_unique_keys<boost::unordered_map<K, M, H, P, A> >
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
     };
 }
 
diff --git a/test/helpers/random_values.hpp b/test/helpers/random_values.hpp
index 85d22c7a..18e0eae9 100644
--- a/test/helpers/random_values.hpp
+++ b/test/helpers/random_values.hpp
@@ -8,7 +8,7 @@
 
 #include "./list.hpp"
 #include <algorithm>
-#include <boost/mpl/if.hpp>
+#include <boost/detail/select_type.hpp>
 #include "./generators.hpp"
 #include "./metafunctions.hpp"
 
@@ -81,10 +81,12 @@ namespace test
 
     template <class X>
     struct unordered_generator_base
-        : public boost::mpl::if_<
-            test::is_set<X>,
+        : public boost::detail::if_true<
+            test::is_set<X>::value
+        >::BOOST_NESTED_TEMPLATE then<
             test::unordered_generator_set<X>,
-            test::unordered_generator_map<X> >
+            test::unordered_generator_map<X>
+        >
     {
     };
 
diff --git a/test/helpers/strong.hpp b/test/helpers/strong.hpp
index f525faf7..02fe267a 100644
--- a/test/helpers/strong.hpp
+++ b/test/helpers/strong.hpp
@@ -8,7 +8,6 @@
 
 #include <boost/config.hpp>
 #include <iterator>
-#include "./metafunctions.hpp"
 #include "./equivalent.hpp"
 #include "./list.hpp"
 #include "./exception_test.hpp"
diff --git a/test/helpers/tracker.hpp b/test/helpers/tracker.hpp
index fdb30815..52d9fa45 100644
--- a/test/helpers/tracker.hpp
+++ b/test/helpers/tracker.hpp
@@ -13,9 +13,6 @@
 #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"
@@ -25,21 +22,17 @@
 
 namespace test
 {
-    template <class X>
-    struct equals_to_compare2
-        : public boost::mpl::identity<
-            std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type> >
+    template <typename X>
+    struct equals_to_compare
     {
+        typedef std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type>
+            type;
     };
 
-    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>
-        >
+    template <>
+    struct equals_to_compare<test::equal_to>
     {
+        typedef test::less type;
     };
 
     template <class X1, class X2>
@@ -67,51 +60,40 @@ namespace test
                     values2.begin(), test::equivalent));
     }
 
-    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;
 
-    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 <class V, class H, class P, class A>
+    struct ordered_base<boost::unordered_set<V, H, P, A> >
+    {
+        typedef std::set<V,
+            BOOST_DEDUCED_TYPENAME equals_to_compare<P>::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 V, class H, class P, class A>
+    struct ordered_base<boost::unordered_multiset<V, H, P, A> >
+    {
+        typedef std::multiset<V,
+            BOOST_DEDUCED_TYPENAME equals_to_compare<P>::type>
+            type;
+    };
+
+    template <class K, class M, class H, class P, class A>
+    struct ordered_base<boost::unordered_map<K, M, H, P, A> >
+    {
+        typedef std::map<K, M,
+            BOOST_DEDUCED_TYPENAME equals_to_compare<P>::type>
+            type;
+    };
+
+    template <class K, class M, class H, class P, class A>
+    struct ordered_base<boost::unordered_multimap<K, M, H, P, A> >
+    {
+        typedef std::multimap<K, M,
+            BOOST_DEDUCED_TYPENAME equals_to_compare<P>::type>
+            type;
+    };
 
     template <class X>
     class ordered : public ordered_base<X>::type
diff --git a/test/unordered/allocator_traits.cpp b/test/unordered/allocator_traits.cpp
index 679ce96f..264c70d0 100644
--- a/test/unordered/allocator_traits.cpp
+++ b/test/unordered/allocator_traits.cpp
@@ -6,7 +6,7 @@
 #include <boost/unordered/detail/allocate.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/limits.hpp>
 
 // Boilerplate
@@ -91,15 +91,15 @@ 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_MPL_ASSERT((boost::is_same<traits::size_type,
-        std::make_unsigned<std::ptrdiff_t>::type>));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
+        std::make_unsigned<std::ptrdiff_t>::type>::value));
 #else
-    BOOST_MPL_ASSERT((boost::is_same<traits::size_type, std::size_t>));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
 #endif
-    BOOST_MPL_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::pointer, int*>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::const_pointer, int const*>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::value_type, int>));
+    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);
@@ -129,15 +129,15 @@ void test_allocator1()
     typedef allocator1<int> allocator;
     typedef boost::unordered::detail::allocator_traits<allocator> traits;
 #if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
-    BOOST_MPL_ASSERT((boost::is_same<traits::size_type,
-        std::make_unsigned<std::ptrdiff_t>::type>));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
+        std::make_unsigned<std::ptrdiff_t>::type>::value));
 #else
-    BOOST_MPL_ASSERT((boost::is_same<traits::size_type, std::size_t>));
+    BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
 #endif
-    BOOST_MPL_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::pointer, int*>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::const_pointer, int const*>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::value_type, int>));
+    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);
@@ -174,11 +174,11 @@ void test_allocator2()
 {
     typedef allocator2<int> allocator;
     typedef boost::unordered::detail::allocator_traits<allocator> traits;
-    BOOST_MPL_ASSERT((boost::is_same<traits::size_type, std::size_t>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::pointer, int*>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::const_pointer, int const*>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::value_type, int>));
+    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);
@@ -233,11 +233,11 @@ void test_allocator3()
 {
     typedef allocator3<int> allocator;
     typedef boost::unordered::detail::allocator_traits<allocator> traits;
-    BOOST_MPL_ASSERT((boost::is_same<traits::size_type, unsigned short>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::difference_type, std::ptrdiff_t>));
-    BOOST_MPL_ASSERT((boost::is_same<traits::pointer, ptr<int> >));
-    BOOST_MPL_ASSERT((boost::is_same<traits::const_pointer, ptr<int const> >));
-    BOOST_MPL_ASSERT((boost::is_same<traits::value_type, int>));
+    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);
diff --git a/test/unordered/compile_tests.hpp b/test/unordered/compile_tests.hpp
index 255d841f..804b7ed4 100644
--- a/test/unordered/compile_tests.hpp
+++ b/test/unordered/compile_tests.hpp
@@ -16,8 +16,7 @@
 #pragma warning(pop)
 #endif
 
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/bool.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/iterator/iterator_traits.hpp>
@@ -55,42 +54,38 @@ void container_test(X& r, T const&)
 
     // value_type
 
-    BOOST_MPL_ASSERT((boost::is_same<T, value_type>));
+    BOOST_STATIC_ASSERT((boost::is_same<T, value_type>::value));
     boost::function_requires<boost::CopyConstructibleConcept<X> >();
 
     // reference_type / const_reference_type
 
-    BOOST_MPL_ASSERT((boost::is_same<T&, reference>));
-    BOOST_MPL_ASSERT((boost::is_same<T const&, const_reference>));
+    BOOST_STATIC_ASSERT((boost::is_same<T&, reference>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<T const&, const_reference>::value));
 
     // iterator
 
     boost::function_requires<boost::InputIteratorConcept<iterator> >();
-    BOOST_MPL_ASSERT((boost::is_same<T, iterator_value_type>));
-    BOOST_MPL_ASSERT((boost::is_convertible<iterator, const_iterator>));
+    BOOST_STATIC_ASSERT((boost::is_same<T, iterator_value_type>::value));
+    BOOST_STATIC_ASSERT((boost::is_convertible<iterator, const_iterator>::value));
 
     // const_iterator
 
     boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
-    BOOST_MPL_ASSERT((boost::is_same<T, const_iterator_value_type>));
+    BOOST_STATIC_ASSERT((boost::is_same<T, const_iterator_value_type>::value));
 
     // difference_type
 
-    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>));
+    BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_signed);
+    BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_integer);
+    BOOST_STATIC_ASSERT((boost::is_same<difference_type,
+                iterator_difference_type>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<difference_type,
+                const_iterator_difference_type>::value));
 
     // size_type
 
-    BOOST_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>));
+    BOOST_STATIC_ASSERT(!std::numeric_limits<size_type>::is_signed);
+    BOOST_STATIC_ASSERT(std::numeric_limits<size_type>::is_integer);
 
     // size_type can represent any non-negative value type of difference_type
     // I'm not sure about either of these tests...
@@ -184,7 +179,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_MPL_ASSERT((boost::is_same<value_type, key_type>));
+    BOOST_STATIC_ASSERT((boost::is_same<value_type, key_type>::value));
 }
 
 template <class X, class Key, class T>
@@ -193,8 +188,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_MPL_ASSERT((
-        boost::is_same<value_type, std::pair<key_type const, T> >));
+    BOOST_STATIC_ASSERT((
+        boost::is_same<value_type, std::pair<key_type const, T> >::value));
 
     r.insert(std::pair<Key const, T>(k, v));
 
@@ -313,36 +308,36 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
         boost::iterator_reference<const_local_iterator>::type
         const_local_iterator_reference;
 
-    BOOST_MPL_ASSERT((boost::is_same<Key, key_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<Hash, hasher>));
+    BOOST_STATIC_ASSERT((boost::is_same<Hash, hasher>::value));
     test::check_return_type<std::size_t>::equals(hf(k));
 
-    BOOST_MPL_ASSERT((boost::is_same<Pred, key_equal>));
+    BOOST_STATIC_ASSERT((boost::is_same<Pred, key_equal>::value));
     test::check_return_type<bool>::convertible(eq(k, k));
 
     boost::function_requires<boost::InputIteratorConcept<local_iterator> >();
-    BOOST_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_STATIC_ASSERT((boost::is_same<local_iterator_category,
+        iterator_category>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_difference,
+        iterator_difference>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_pointer,
+        iterator_pointer>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<local_iterator_reference,
+        iterator_reference>::value));
 
     boost::function_requires<
         boost::InputIteratorConcept<const_local_iterator> >();
-    BOOST_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>));
+    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(10, hf, eq);
     X a(10, hf, eq);
diff --git a/test/unordered/minimal_allocator.cpp b/test/unordered/minimal_allocator.cpp
index 6f43039a..26d1323a 100644
--- a/test/unordered/minimal_allocator.cpp
+++ b/test/unordered/minimal_allocator.cpp
@@ -6,7 +6,7 @@
 #include <boost/unordered/detail/allocate.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
 #include "../objects/test.hpp"
 
 template <class Tp> 
@@ -41,22 +41,22 @@ void test_simple_allocator()
     typedef boost::unordered::detail::allocator_traits<
         SimpleAllocator<T> > traits;
 
-    BOOST_MPL_ASSERT((boost::is_same<typename traits::allocator_type, SimpleAllocator<T> >));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::allocator_type, SimpleAllocator<T> >::value));
 
-    BOOST_MPL_ASSERT((boost::is_same<typename traits::value_type, T>));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::value_type, T>::value));
 
-    BOOST_MPL_ASSERT((boost::is_same<typename traits::pointer, T* >));
-    BOOST_MPL_ASSERT((boost::is_same<typename traits::const_pointer, T const*>));
-    //BOOST_MPL_ASSERT((boost::is_same<typename traits::void_pointer, void* >));
-    //BOOST_MPL_ASSERT((boost::is_same<typename traits::const_void_pointer, void const*>));
+    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_MPL_ASSERT((boost::is_same<typename traits::difference_type, std::ptrdiff_t>));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::difference_type, std::ptrdiff_t>::value));
 
 #if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
-    BOOST_MPL_ASSERT((boost::is_same<typename traits::size_type,
-        std::make_unsigned<std::ptrdiff_t>::type>));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::size_type,
+        std::make_unsigned<std::ptrdiff_t>::type>::value));
 #else
-    BOOST_MPL_ASSERT((boost::is_same<typename traits::size_type, std::size_t>));
+    BOOST_STATIC_ASSERT((boost::is_same<typename traits::size_type, std::size_t>::value));
 #endif
 
     BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
diff --git a/test/unordered/move_tests.cpp b/test/unordered/move_tests.cpp
index 85159926..164eb88d 100644
--- a/test/unordered/move_tests.cpp
+++ b/test/unordered/move_tests.cpp
@@ -162,12 +162,12 @@ namespace move_tests
 #elif defined(BOOST_HAS_NRVO)
             BOOST_TEST(
                 test::global_object_count.constructions - count.constructions <=
-                (test::is_map<T>::value ? 50 : 25));
+                (test::is_set<T>::value ? 25 : 50));
             BOOST_TEST(count.instances == test::global_object_count.instances);
 #else
             BOOST_TEST(
                 test::global_object_count.constructions - count.constructions <=
-                (test::is_map<T>::value ? 100 : 50));
+                (test::is_set<T>::value ? 50 : 100));
             BOOST_TEST(count.instances == test::global_object_count.instances);
 #endif
             test::check_container(y, v);