Imported from /home/lorry/working-area/delta_boost-tarball/boost_1_58_0.tar.bz2.HEADboost_1_58_0master

4 files changed, 181 insertions, 19 deletions

diff --git a/libs/move/test/adl_move_swap.cpp b/libs/move/test/adl_move_swap.cpp
new file mode 100644
index 000000000..9aeae4374
--- /dev/null
+++ b/libs/move/test/adl_move_swap.cpp
@@ -0,0 +1,169 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014.
+// 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)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/adl_move_swap.hpp>
+#include <boost/move/core.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+class swap_stats
+{
+   public:
+   static void reset_stats()
+   {
+      member_swap_calls = 0;
+      friend_swap_calls = 0;
+      move_cnstor_calls = 0;
+      move_assign_calls = 0;
+      copy_cnstor_calls = 0;
+      copy_assign_calls = 0;
+   }
+
+   static unsigned int member_swap_calls;
+   static unsigned int friend_swap_calls;
+   static unsigned int move_cnstor_calls;
+   static unsigned int move_assign_calls;
+   static unsigned int copy_cnstor_calls;
+   static unsigned int copy_assign_calls;
+};
+
+unsigned int swap_stats::member_swap_calls = 0;
+unsigned int swap_stats::friend_swap_calls = 0;
+unsigned int swap_stats::move_cnstor_calls = 0;
+unsigned int swap_stats::move_assign_calls = 0;
+unsigned int swap_stats::copy_cnstor_calls = 0;
+unsigned int swap_stats::copy_assign_calls = 0;
+
+class movable : public swap_stats
+{
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(movable)
+   public:
+   movable()                                 {}
+   movable(BOOST_RV_REF(movable))            { ++move_cnstor_calls; }
+   movable & operator=(BOOST_RV_REF(movable)){ ++move_assign_calls; return *this; }
+   friend void swap(movable &, movable &)    { ++friend_swap_calls; }
+};
+
+class movable_swap_member : public swap_stats
+{
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(movable_swap_member)
+   public:
+   movable_swap_member()                                             {}
+   movable_swap_member(BOOST_RV_REF(movable_swap_member))            { ++move_cnstor_calls; }
+   movable_swap_member & operator=(BOOST_RV_REF(movable_swap_member)){ ++move_assign_calls; return *this; }
+   void swap(movable_swap_member &)                                  { ++member_swap_calls; }
+   friend void swap(movable_swap_member &, movable_swap_member &)    { ++friend_swap_calls; }
+};
+
+class copyable : public swap_stats
+{
+   public:
+   copyable()                                {}
+   copyable(const copyable &)                { ++copy_cnstor_calls; }
+   copyable & operator=(const copyable&)     { ++copy_assign_calls; return *this; }
+   void swap(copyable &)                     { ++member_swap_calls; }
+   friend void swap(copyable &, copyable &)  { ++friend_swap_calls; }
+};
+
+class no_swap : public swap_stats
+{
+   private: unsigned m_state;
+   public:
+   explicit no_swap(unsigned i): m_state(i){}
+   no_swap(const no_swap &x)               { m_state = x.m_state; ++copy_cnstor_calls; }
+   no_swap & operator=(const no_swap& x)   { m_state = x.m_state; ++copy_assign_calls; return *this; }
+   void swap(no_swap &)                    { ++member_swap_calls; }
+   friend bool operator==(const no_swap &x, const no_swap &y) {  return x.m_state == y.m_state; }
+   friend bool operator!=(const no_swap &x, const no_swap &y) {  return !(x==y); }
+};
+
+
+int main()
+{
+   {  //movable
+      movable x, y;
+      swap_stats::reset_stats();
+      ::boost::adl_move_swap(x, y);
+      #if defined(BOOST_NO_RVALUE_REFERENCES)
+      //In non rvalue reference compilers,
+      //movable classes with no swap() member uses
+      //boost::move() to implement swap.
+      BOOST_TEST(swap_stats::friend_swap_calls == 0);
+      BOOST_TEST(swap_stats::member_swap_calls == 0);
+      BOOST_TEST(swap_stats::member_swap_calls == 0);
+      BOOST_TEST(swap_stats::move_cnstor_calls == 1);
+      BOOST_TEST(swap_stats::move_assign_calls == 2);
+      BOOST_TEST(swap_stats::copy_cnstor_calls == 0);
+      BOOST_TEST(swap_stats::copy_assign_calls == 0);
+      #else
+      //In compilers with rvalue references, this should call friend swap via ADL
+      BOOST_TEST(swap_stats::friend_swap_calls == 1);
+      BOOST_TEST(swap_stats::member_swap_calls == 0);
+      BOOST_TEST(swap_stats::member_swap_calls == 0);
+      BOOST_TEST(swap_stats::move_cnstor_calls == 0);
+      BOOST_TEST(swap_stats::move_assign_calls == 0);
+      BOOST_TEST(swap_stats::copy_cnstor_calls == 0);
+      BOOST_TEST(swap_stats::copy_assign_calls == 0);
+      #endif
+   }
+   {  //movable_swap_member
+      movable_swap_member x, y;
+      swap_stats::reset_stats();
+      ::boost::adl_move_swap(x, y);
+      #if defined(BOOST_NO_RVALUE_REFERENCES)
+      //In non rvalue reference compilers,
+      //movable classes with no swap() member uses
+      //boost::move() to implement swap.
+      BOOST_TEST(swap_stats::friend_swap_calls == 0);
+      BOOST_TEST(swap_stats::member_swap_calls == 1);
+      BOOST_TEST(swap_stats::move_cnstor_calls == 0);
+      BOOST_TEST(swap_stats::move_assign_calls == 0);
+      BOOST_TEST(swap_stats::copy_cnstor_calls == 0);
+      BOOST_TEST(swap_stats::copy_assign_calls == 0);
+      #else
+      //In compilers with rvalue references, this should call friend swap via ADL
+      BOOST_TEST(swap_stats::friend_swap_calls == 1);
+      BOOST_TEST(swap_stats::member_swap_calls == 0);
+      BOOST_TEST(swap_stats::move_cnstor_calls == 0);
+      BOOST_TEST(swap_stats::move_assign_calls == 0);
+      BOOST_TEST(swap_stats::copy_cnstor_calls == 0);
+      BOOST_TEST(swap_stats::copy_assign_calls == 0);
+      #endif
+   }
+   {  //copyable
+      copyable x, y;
+      swap_stats::reset_stats();
+      ::boost::adl_move_swap(x, y);
+      //This should call friend swap via ADL
+      BOOST_TEST(swap_stats::friend_swap_calls == 1);
+      BOOST_TEST(swap_stats::member_swap_calls == 0);
+      BOOST_TEST(swap_stats::move_cnstor_calls == 0);
+      BOOST_TEST(swap_stats::move_assign_calls == 0);
+      BOOST_TEST(swap_stats::copy_cnstor_calls == 0);
+      BOOST_TEST(swap_stats::copy_assign_calls == 0);
+   }
+   {  //no_swap
+      no_swap x(1), y(2), x_back(x), y_back(y);
+      swap_stats::reset_stats();
+      ::boost::adl_move_swap(x, y);
+      //This should call std::swap which uses copies
+      BOOST_TEST(swap_stats::friend_swap_calls == 0);
+      BOOST_TEST(swap_stats::member_swap_calls == 0);
+      BOOST_TEST(swap_stats::move_cnstor_calls == 0);
+      BOOST_TEST(swap_stats::move_assign_calls == 0);
+      BOOST_TEST(swap_stats::copy_cnstor_calls == 1);
+      BOOST_TEST(swap_stats::copy_assign_calls == 2);
+      BOOST_TEST(x == y_back);
+      BOOST_TEST(y == x_back);
+      BOOST_TEST(x != y);
+   }
+   return ::boost::report_errors();
+}
+#include <boost/move/detail/config_end.hpp>
diff --git a/libs/move/test/back_move_inserter.cpp b/libs/move/test/back_move_inserter.cpp
index eeddd6b50..6fc4829c8 100644
--- a/libs/move/test/back_move_inserter.cpp
+++ b/libs/move/test/back_move_inserter.cpp
@@ -9,7 +9,10 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 #include <boost/move/detail/config_begin.hpp>
+// move
+#include <boost/move/algorithm.hpp>
 #include <boost/move/iterator.hpp>
+// container
 #include <boost/container/deque.hpp>
 #include <boost/container/list.hpp>
 #include <boost/container/stable_vector.hpp>
diff --git a/libs/move/test/move_iterator.cpp b/libs/move/test/move_iterator.cpp
index 37c39f3bc..fded99a8b 100644
--- a/libs/move/test/move_iterator.cpp
+++ b/libs/move/test/move_iterator.cpp
@@ -11,6 +11,7 @@
 #include <boost/move/detail/config_begin.hpp>
 #include <boost/move/iterator.hpp>
 #include <boost/container/vector.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include "../example/movable.hpp"
 
 int main()
@@ -20,36 +21,24 @@ int main()
    bc::vector<movable> v(10);
 
    //Test default constructed value
-   if(v[0].moved()){
-      return 1;
-   }
+   BOOST_TEST(!v[0].moved());
 
    //Move values
    bc::vector<movable> v2
       (boost::make_move_iterator(v.begin()), boost::make_move_iterator(v.end()));
 
    //Test values have been moved
-   if(!v[0].moved()){
-      return 1;
-   }
-
-   if(v2.size() != 10){
-      return 1;
-   }
+   BOOST_TEST(v[0].moved());
+   BOOST_TEST(v2.size() == 10);
 
    //Move again
    v.assign(boost::make_move_iterator(v2.begin()), boost::make_move_iterator(v2.end()));
 
    //Test values have been moved
-   if(!v2[0].moved()){
-      return 1;
-   }
-
-   if(v[0].moved()){
-      return 1;
-   }
+   BOOST_TEST(v2[0].moved());
+   BOOST_TEST(!v[0].moved());
 
-   return 0;
+   return ::boost::report_errors();
 }
 
 #include <boost/move/detail/config_end.hpp>
diff --git a/libs/move/test/unique_ptr_modifiers.cpp b/libs/move/test/unique_ptr_modifiers.cpp
index b67d4f558..3de952d20 100644
--- a/libs/move/test/unique_ptr_modifiers.cpp
+++ b/libs/move/test/unique_ptr_modifiers.cpp
@@ -13,6 +13,7 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/unique_ptr.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/move/adl_move_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 
 //////////////////////////////////////////////
@@ -284,7 +285,7 @@ void test()
    BOOST_TEST(s2.get() == p2);
    BOOST_TEST(*s2 == A(2));
    BOOST_TEST(s2.get_deleter().state() == 2);
-   swap(s1, s2);
+   boost::adl_move_swap(s1, s2);
    BOOST_TEST(s1.get() == p2);
    BOOST_TEST(*s1 == A(2));
    BOOST_TEST(s1.get_deleter().state() == 2);