[Boost-commit] svn:boost r74101 - in branches/release: boost/unordered boost/unordered/detail libs/unordered libs/unordered/test/helpers libs/unordered/test/objects libs/unordered/test/unordered

Subject: [Boost-commit] svn:boost r74101 - in branches/release: boost/unordered boost/unordered/detail libs/unordered libs/unordered/test/helpers libs/unordered/test/objects libs/unordered/test/unordered
From: dnljms_at_[hidden]
Date: 2011-08-28 07:26:41

Author: danieljames
Date: 2011-08-28 07:26:38 EDT (Sun, 28 Aug 2011)
New Revision: 74101
URL: http://svn.boost.org/trac/boost/changeset/74101

Log:
Unordered: Merge from trunk.

Portability fixes, and fix some issues with constructing std::pair.

Added:
   branches/release/libs/unordered/test/unordered/allocator_traits.cpp
      - copied unchanged from r74100, /trunk/libs/unordered/test/unordered/allocator_traits.cpp
Properties modified: 
   branches/release/boost/unordered/   (props changed)
   branches/release/libs/unordered/   (props changed)
Text files modified: 
   branches/release/boost/unordered/detail/allocator_helpers.hpp             |   121 +++++++++++++++++-------------          
   branches/release/boost/unordered/detail/buckets.hpp                       |   154 ++++++++++++++++++++++++++++++++------- 
   branches/release/boost/unordered/detail/table.hpp                         |     8 +                                       
   branches/release/libs/unordered/test/helpers/memory.hpp                   |     9 +                                       
   branches/release/libs/unordered/test/objects/cxx11_allocator.hpp          |    17 +++-                                    
   branches/release/libs/unordered/test/objects/test.hpp                     |     4                                         
   branches/release/libs/unordered/test/unordered/Jamfile.v2                 |     1                                         
   branches/release/libs/unordered/test/unordered/insert_tests.cpp           |    79 ++++++++++++++++++++                    
   branches/release/libs/unordered/test/unordered/unnecessary_copy_tests.cpp |     5 +                                       
   9 files changed, 304 insertions(+), 94 deletions(-)

Modified: branches/release/boost/unordered/detail/allocator_helpers.hpp
==============================================================================
--- branches/release/boost/unordered/detail/allocator_helpers.hpp	(original)
+++ branches/release/boost/unordered/detail/allocator_helpers.hpp	2011-08-28 07:26:38 EDT (Sun, 28 Aug 2011)
@@ -5,8 +5,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)
 //
-// Written by Daniel James using some code from Pablo Halpern's
-// allocator traits implementation.
+// Allocator traits written by Daniel James based on Pablo Halpern's
+// implementation.
 
 #ifndef BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
 #define BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
@@ -18,6 +18,7 @@
 #include <boost/config.hpp>
 #include <boost/detail/select_type.hpp>
 #include <boost/utility/enable_if.hpp>
+#include <boost/preprocessor/cat.hpp>
 
 #if (defined(BOOST_NO_STD_ALLOCATOR) || defined(BOOST_DINKUMWARE_STDLIB)) \
     && !defined(__BORLANDC__)
@@ -81,38 +82,39 @@
     };
 #   endif
 
-    struct convertible_from_anything
-    {
-        template<typename T> convertible_from_anything(T const&);
-    };
+    template <typename T> T& make();
+    struct choice9 { typedef char (&type)[9]; };
+    struct choice8 : choice9 { typedef char (&type)[8]; };
+    struct choice7 : choice8 { typedef char (&type)[7]; };
+    struct choice6 : choice7 { typedef char (&type)[6]; };
+    struct choice5 : choice6 { typedef char (&type)[5]; };
+    struct choice4 : choice5 { typedef char (&type)[4]; };
+    struct choice3 : choice4 { typedef char (&type)[3]; };
+    struct choice2 : choice3 { typedef char (&type)[2]; };
+    struct choice1 : choice2 { typedef char (&type)[1]; };
+    choice1 choose();
 
-    typedef char (&no_type)[1];
-    typedef char (&yes_type)[2];
-
-    template <typename T> struct sfinae {
-        typedef yes_type type;
-    };
-
-    // Infrastructure for providing a default type for Tp::tname if absent.
     #define BOOST_DEFAULT_TYPE_TMPLT(tname)                                 \
         template <typename Tp, typename Default>                            \
         struct default_type_ ## tname {                                     \
-            template <typename T>                                           \
-            static BOOST_DEDUCED_TYPENAME sfinae<                           \
-                BOOST_DEDUCED_TYPENAME T::tname>::type test(int);           \
-            template <typename T>                                           \
-            static no_type test(long);                                      \
                                                                             \
-            enum { value = sizeof(test<Tp>(0)) == sizeof(yes_type) };       \
+            template <typename X>                                           \
+            static choice1::type test(choice1,                              \
+                BOOST_DEDUCED_TYPENAME X::tname* = 0);                      \
+                                                                            \
+            template <typename X>                                           \
+            static choice2::type test(choice2, void* = 0);                  \
                                                                             \
             struct DefaultWrap { typedef Default tname; };                  \
                                                                             \
+            enum { value = (1 == sizeof(test<Tp>(choose()))) };             \
+                                                                            \
             typedef BOOST_DEDUCED_TYPENAME                                  \
                 boost::detail::if_true<value>::                             \
                 BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap>                 \
                 ::type::tname type;                                         \
         }
-    
+
     #define BOOST_DEFAULT_TYPE(T,tname, arg)                                \
         BOOST_DEDUCED_TYPENAME default_type_ ## tname<T, arg>::type
 
@@ -127,47 +129,62 @@
     BOOST_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
 
 #if !defined(BOOST_NO_SFINAE_EXPR) || BOOST_WORKAROUND(BOOST_MSVC, >= 1500)
-    // Specialization is only needed for Visual C++. Without it SFINAE doesn't
-    // kick in.
-    template <unsigned int>
-    struct expr_sfinae;
-    
-    template <>
-    struct expr_sfinae<sizeof(yes_type)> {
-        typedef yes_type type;
-    };
-    
+
+    template <typename T, unsigned int> struct expr_test;
+    template <typename T> struct expr_test<T, sizeof(char)> : T {};
+    template <typename U> static char for_expr_test(U const&);
+
+#define BOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression)         \
+        template <typename U>                                               \
+        static typename expr_test<                                          \
+            BOOST_PP_CAT(choice, result),                                   \
+            sizeof(for_expr_test(((expression), 0)))>::type test(           \
+            BOOST_PP_CAT(choice, count))
+
+#define BOOST_UNORDERED_DEFAULT_EXPRESSION(count, result)                   \
+        template <typename U>                                               \
+        static BOOST_PP_CAT(choice, result)::type test(                     \
+            BOOST_PP_CAT(choice, count))
+
     template <typename T>
     struct has_select_on_container_copy_construction
     {
-        // This needs to be a template for Visual C++.
-        template <typename T2>
-        static yes_type to_yes_type(const T2&);
-
-        template <typename T2>
-        static typename expr_sfinae<sizeof(to_yes_type(
-            ((T2 const*)0)->select_on_container_copy_construction()
-        ))>::type check(T2*);
-
-        static no_type check(void*);
+        BOOST_UNORDERED_CHECK_EXPRESSION(1, 1, make<U const>().select_on_container_copy_construction());
+        BOOST_UNORDERED_DEFAULT_EXPRESSION(2, 2);
         
-        enum { value = sizeof(check((T*) 0)) == sizeof(yes_type) };
+        enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) };
     };
+
 #else
+
+   template <typename T> struct identity { typedef T type; };
+
+#define BOOST_UNORDERED_CHECK_MEMBER(count, result, name, member)           \
+                                                                            \
+    typedef typename identity<member>::type BOOST_PP_CAT(check, count);     \
+                                                                            \
+    template <BOOST_PP_CAT(check, count) e>                                 \
+    struct BOOST_PP_CAT(test, count) {                                      \
+        typedef void* type;                                                 \
+    };                                                                      \
+                                                                            \
+    template <class U> static BOOST_PP_CAT(choice, result)::type            \
+        test(BOOST_PP_CAT(choice, count),                                   \
+            typename BOOST_PP_CAT(test, count)<                             \
+                &U::name>::type = 0)
+
+#define BOOST_UNORDERED_DEFAULT_MEMBER(count, result)                       \
+    template <class U> static BOOST_PP_CAT(choice, result)::type            \
+        test(BOOST_PP_CAT(choice, count), void* = 0)
+
+
     template <typename T>
     struct has_select_on_container_copy_construction
     {
-        typedef T (T::*SelectFunc)() const;
-
-        template <SelectFunc e> struct sfinae { typedef yes_type type; };
-
-        template <class U>  
-        static typename sfinae<&U::select_on_container_copy_construction>::type
-            test(int);  
-        template <class U>  
-        static no_type test(...);  
+        BOOST_UNORDERED_CHECK_MEMBER(1, 1, select_on_container_copy_construction, T (T::*)() const);
+        BOOST_UNORDERED_DEFAULT_MEMBER(2, 2);
  
-        enum { value = sizeof(test<T>(1)) == sizeof(yes_type) };
+        enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) };
     };
 
 #endif

Modified: branches/release/boost/unordered/detail/buckets.hpp
==============================================================================
--- branches/release/boost/unordered/detail/buckets.hpp	(original)
+++ branches/release/boost/unordered/detail/buckets.hpp	2011-08-28 07:26:38 EDT (Sun, 28 Aug 2011)
@@ -517,44 +517,139 @@
     ////////////////////////////////////////////////////////////////////////////
     // Node Constructors
 
+    template <typename T, typename Arg1 = void>
+    struct emulated_pair_constructor
+    {
+        enum { value = false };
+    };
+    
+    template <typename A, typename B>
+    struct emulated_pair_constructor<std::pair<A, B>, void>
+    {
+        enum { value = true };
+    };
+    
+    template <typename A, typename B, typename Value>
+    struct emulated_pair_constructor<std::pair<A, B>, Value>
+    {
+        static choice1::type check(choice1, std::pair<A, B> const&);
+        static choice2::type check(choice2, A const&);
+    
+        enum { value = sizeof(check(choose(), make<Value>())) - 1 };
+    };
+
+    template <class T>
+    inline void construct_impl(void* address)
+    {
+        new(address) T();
+    }
+
 #if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
 
-    template <class T, class... Args>
-    inline void construct_impl(T*, void* address, Args&&... args)
+    template <class T, class Arg1>
+    inline void construct_impl(
+            typename boost::disable_if<emulated_pair_constructor<T, Arg1>,
+                void*>::type address,
+            Arg1&& a1)
+    {
+        new(address) T(std::forward<Arg1>(a1));
+    }
+
+    template <class T, class Arg1>
+    inline void construct_impl(
+            typename boost::enable_if<emulated_pair_constructor<T, Arg1>,
+                void*>::type address,
+            Arg1&& a1)
+    {
+        new(address) T(std::forward<Arg1>(a1), typename T::second_type());
+    }
+
+    template <class T, class Arg1, class Arg2>
+    inline void construct_impl(void* address, Arg1&& a1, Arg2&& a2)
     {
-        new(address) T(std::forward<Args>(args)...);
+        new(address) T(std::forward<Arg1>(a1), std::forward<Arg2>(a2));
+    }
+
+    template <class T, class Arg1, class Arg2, class... Args>
+    inline typename boost::disable_if<emulated_pair_constructor<T>, void>::type
+    construct_impl(void* address, Arg1&& arg1, Arg2&& arg2, Args&&... args)
+    {
+        new(address) T(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2),
+            std::forward<Args>(args)...);
+    }
+
+    template <class T, class Arg1, class Arg2, class... Args>
+    inline typename boost::enable_if<emulated_pair_constructor<T>, void>::type
+    construct_impl(void* address, Arg1&& arg1, Arg2&& arg2, Args&&... args)
+    {
+        new(address) T(std::forward<Arg1>(arg1),
+            typename T::second_type(
+                std::forward<Arg2>(arg2), std::forward<Args>(args)...));
     }
 
 #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)));               \
+    template <class T, class Arg1>
+    inline BOOST_DEDUCED_TYPENAME boost::disable_if<emulated_pair_constructor<T, Arg1>, void>::type
+        construct_impl(void* address, BOOST_FWD_REF(Arg1) a1)
+    {
+        new(address) T(boost::forward<Arg1>(a1));
+    }
+
+    template <class T, class Arg1>
+    inline BOOST_DEDUCED_TYPENAME boost::enable_if<emulated_pair_constructor<T, Arg1>, void>::type
+        construct_impl(void* address, BOOST_FWD_REF(Arg1) a1)
+    {
+        new(address) T(
+            boost::forward<Arg1>(a1),
+            BOOST_DEDUCED_TYPENAME T::second_type()
+        );
     }
 
-    BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+    template <class T, class Arg1, class Arg2>
+    inline void construct_impl(void* address,
+            BOOST_FWD_REF(Arg1) a1, BOOST_FWD_REF(Arg2) a2)
+    {
+        new(address) T(boost::forward<Arg1>(a1), boost::forward<Arg2>(a2));
+    }
+    
+#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _)                    \
+    template <                                                              \
+        class T,                                                            \
+        BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)                        \
+    >                                                                       \
+    inline void construct_impl(                                             \
+        BOOST_DEDUCED_TYPENAME                                              \
+        boost::disable_if<emulated_pair_constructor<T>, void*>::type        \
+        address,                                                            \
+        BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)                      \
+    )                                                                       \
+    {                                                                       \
+        new(address) T(                                                     \
+            BOOST_UNORDERED_CALL_PARAMS(z, num_params));                    \
+    }
+
+    BOOST_PP_REPEAT_FROM_TO(3, BOOST_UNORDERED_EMPLACE_LIMIT,
         BOOST_UNORDERED_CONSTRUCT_IMPL, _)
 
+#define BOOST_UNORDERED_CONSTRUCT_PAIR_IMPL(z, num_params, _)               \
+    template <class T, class Key,                                           \
+        BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)                        \
+    >                                                                       \
+    inline void construct_impl(                                             \
+        BOOST_DEDUCED_TYPENAME                                              \
+        boost::enable_if<emulated_pair_constructor<T>, void*>::type         \
+        address,                                                            \
+        Key const& k, BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params))       \
+    {                                                                       \
+        new(address) T(k,                                                   \
+            BOOST_DEDUCED_TYPENAME                                          \
+            T::second_type(BOOST_UNORDERED_CALL_PARAMS(z, num_params)));    \
+    }
+
+    BOOST_PP_REPEAT_FROM_TO(2, BOOST_UNORDERED_EMPLACE_LIMIT,
+        BOOST_UNORDERED_CONSTRUCT_PAIR_IMPL, _)
+
 #undef BOOST_UNORDERED_CONSTRUCT_IMPL
 #endif
 
@@ -594,7 +689,7 @@
         void construct(Args&&... args)
         {
             construct_preamble();
-            construct_impl((value_type*) 0, node_->address(),
+            construct_impl<value_type>(node_->address(),
                 std::forward<Args>(args)...);
             value_constructed_ = true;
         }
@@ -609,8 +704,7 @@
         )                                                                      \
         {                                                                      \
             construct_preamble();                                              \
-            construct_impl(                                                    \
-                (value_type*) 0, node_->address(),                             \
+            construct_impl<value_type>(node_->address(),                       \
                 BOOST_UNORDERED_CALL_PARAMS(z, num_params)                     \
             );                                                                 \
             value_constructed_ = true;                                         \

Modified: branches/release/boost/unordered/detail/table.hpp
==============================================================================
--- branches/release/boost/unordered/detail/table.hpp	(original)
+++ branches/release/boost/unordered/detail/table.hpp	2011-08-28 07:26:38 EDT (Sun, 28 Aug 2011)
@@ -167,7 +167,9 @@
             //
             // Or from rehash post-condition:
             // count > size / mlf_
-            return next_prime(double_to_size_t(floor(size / (double) mlf_)) + 1);
+            return next_prime(double_to_size_t(floor(
+                static_cast<double>(size) /
+                static_cast<double>(mlf_))) + 1);
         }
 
         ////////////////////////////////////////////////////////////////////////
@@ -451,7 +453,9 @@
         else {
             // no throw:
             min_buckets = next_prime((std::max)(min_buckets,
-                    double_to_size_t(floor(this->size_ / (double) mlf_)) + 1));
+                double_to_size_t(floor(
+                    static_cast<double>(this->size_) /
+                    static_cast<double>(mlf_))) + 1));
             if(min_buckets != this->bucket_count_) {
                 this->rehash_impl(min_buckets);
                 this->max_load_ = calculate_max_load();

Modified: branches/release/libs/unordered/test/helpers/memory.hpp
==============================================================================
--- branches/release/libs/unordered/test/helpers/memory.hpp	(original)
+++ branches/release/libs/unordered/test/helpers/memory.hpp	2011-08-28 07:26:38 EDT (Sun, 28 Aug 2011)
@@ -194,8 +194,13 @@
         enum { value = false };
     };
 
-    template <typename Alloc>
-    int selected_count(Alloc const&)
+    struct convert_from_anything
+    {
+        template <typename T>
+        convert_from_anything(T const&) {}
+    };
+
+    int selected_count(convert_from_anything)
     {
         return 0;
     }

Modified: branches/release/libs/unordered/test/objects/cxx11_allocator.hpp
==============================================================================
--- branches/release/libs/unordered/test/objects/cxx11_allocator.hpp	(original)
+++ branches/release/libs/unordered/test/objects/cxx11_allocator.hpp	2011-08-28 07:26:38 EDT (Sun, 28 Aug 2011)
@@ -186,9 +186,14 @@
     };
 
     template <typename T, typename Flags = propagate_swap,
-        bool SelectCopy = Flags::is_select_on_copy ? true : false>
-    struct cxx11_allocator :
-        public cxx11_allocator_base<T>,
+        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>,
@@ -228,8 +233,10 @@
     };
 
     template <typename T, typename Flags>
-    struct cxx11_allocator<T, Flags, true> : 
-        public cxx11_allocator_base<T>,
+    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>,

Modified: branches/release/libs/unordered/test/objects/test.hpp
==============================================================================
--- branches/release/libs/unordered/test/objects/test.hpp	(original)
+++ branches/release/libs/unordered/test/objects/test.hpp	2011-08-28 07:26:38 EDT (Sun, 28 Aug 2011)
@@ -26,7 +26,7 @@
     object generate(object const*);
     implicitly_convertible generate(implicitly_convertible const*);
     
-    class object : globally_counted_object
+    class object : private globally_counted_object
     {
         friend class hash;
         friend class equal_to;
@@ -64,7 +64,7 @@
         }
     };
 
-    class implicitly_convertible : globally_counted_object
+    class implicitly_convertible : private globally_counted_object
     {
         int tag1_, tag2_;
     public:

Modified: branches/release/libs/unordered/test/unordered/Jamfile.v2
==============================================================================
--- branches/release/libs/unordered/test/unordered/Jamfile.v2	(original)
+++ branches/release/libs/unordered/test/unordered/Jamfile.v2	2011-08-28 07:26:38 EDT (Sun, 28 Aug 2011)
@@ -22,6 +22,7 @@
     :
         [ run fwd_set_test.cpp ]
         [ run fwd_map_test.cpp ]
+        [ run allocator_traits.cpp ]
         [ run compile_set.cpp ]
         [ run compile_map.cpp ]
         [ run link_test_1.cpp link_test_2.cpp ]

Modified: branches/release/libs/unordered/test/unordered/insert_tests.cpp
==============================================================================
--- branches/release/libs/unordered/test/unordered/insert_tests.cpp	(original)
+++ branches/release/libs/unordered/test/unordered/insert_tests.cpp	2011-08-28 07:26:38 EDT (Sun, 28 Aug 2011)
@@ -514,6 +514,85 @@
 
 #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;
+    }
+};
+
+// This will actually be deprecated pretty soon.
+
+UNORDERED_AUTO_TEST(map_emplace_test)
+{
+    boost::unordered_map<int, overloaded_constructor> x;
+
+    x.emplace();
+    BOOST_TEST(x.find(0) != x.end() &&
+        x.find(0)->second == overloaded_constructor());
+
+    x.emplace(1);
+    BOOST_TEST(x.find(1) != x.end() &&
+        x.find(1)->second == overloaded_constructor());
+
+    x.emplace(2, 3);
+    BOOST_TEST(x.find(2) != x.end() &&
+        x.find(2)->second == overloaded_constructor(3));
+
+    x.emplace(4, 5, 6);
+    BOOST_TEST(x.find(4) != x.end() &&
+        x.find(4)->second == overloaded_constructor(5, 6));
+
+    x.emplace(7, 8, 9, 10);
+    BOOST_TEST(x.find(7) != x.end() &&
+        x.find(7)->second == overloaded_constructor(8, 9, 10));
+}
+
+UNORDERED_AUTO_TEST(set_emplace_test)
+{
+    boost::unordered_set<overloaded_constructor> x;
+    overloaded_constructor check;
+
+    x.emplace();
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
+
+    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);
+}
+
 }
 
 RUN_TESTS()

Modified: branches/release/libs/unordered/test/unordered/unnecessary_copy_tests.cpp
==============================================================================
--- branches/release/libs/unordered/test/unordered/unnecessary_copy_tests.cpp	(original)
+++ branches/release/libs/unordered/test/unordered/unnecessary_copy_tests.cpp	2011-08-28 07:26:38 EDT (Sun, 28 Aug 2011)
@@ -341,7 +341,10 @@
         x.emplace(source<std::pair<count_copies, count_copies> >());
         COPY_COUNT(2); MOVE_COUNT(source_pair_cost);
 
-#if !defined(__GNUC__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)
+#if (defined(__GNUC__) && __GNUC__ > 4) || \
+    (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ > 2) || \
+    (defined(BOOST_MSVC) && BOOST_MSVC >= 1600 ) || \
+    (!defined(__GNUC__) && !defined(BOOST_MSVC))
         count_copies part;
         reset();
         std::pair<count_copies const&, count_copies const&> a_ref(part, part);