pointer_casts with move semantics for unique_ptr

test/cpp11_pointer_cast_test.cpp

@@ -1,5 +1,5 @@
 //
-//  cpp11_pointer_cast_test.cpp - a test for boost/pointer_cast.hpp with std::shared_ptr
+//  cpp11_pointer_cast_test.cpp - a test for boost/pointer_cast.hpp with std::shared_ptr and std::unique_ptr
 //
 //  Copyright (c) 2016 Karolin Varner
 //
@@ -8,12 +8,28 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include <boost/config.hpp>
 #include <boost/pointer_cast.hpp>
+
+#include <boost/config.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/get_pointer.hpp>
+#include <boost/shared_ptr.hpp>
 
 #include <memory>
+#include <utility>
+#include <functional>
+
+#if defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) \
+ || defined( BOOST_NO_CXX11_HDR_FUNCTIONAL ) \
+ || defined( BOOST_NO_CXX11_HDR_UTILITY ) \
+ || defined( BOOST_NO_CXX11_LAMBDAS ) \
+ || defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+// We expect all the features or none of the features to be
+// available, since we should be on C++11
+int main() { return 0; }
+
+#else
 
 namespace
 {
@@ -43,7 +59,7 @@ public:
 };
 
 class derived
-   : public base, public base2 
+   : public base, public base2
 {
     int filler [5];
 };
@@ -66,7 +82,7 @@ bool check_dynamic_pointer_cast(const BasePtr &ptr)
    //Correct cast with dynamic_pointer_cast
    boost::get_pointer(boost::dynamic_pointer_cast<derived>(ptr)) ==
       //Correct cast with dynamic_cast
-      dynamic_cast<derived*>(boost::get_pointer(ptr)) 
+      dynamic_cast<derived*>(boost::get_pointer(ptr))
    &&
    //Incorrect cast with dynamic_pointer_cast
    boost::get_pointer(boost::dynamic_pointer_cast<derived_derived>(ptr)) ==
@@ -91,7 +107,7 @@ bool check_static_pointer_cast(const BasePtr &ptr)
 template <class BasePtr>
 bool check_const_pointer_cast(const BasePtr &ptr)
 {
-   return   
+   return
    //Unconst and const again using const_pointer_cast
    boost::get_pointer(
       boost::const_pointer_cast<const base>
@@ -101,7 +117,7 @@ bool check_const_pointer_cast(const BasePtr &ptr)
 }
 
 template <class BasePtr>
-void check_all_casts(const BasePtr &ptr)
+void check_all_copy_casts(const BasePtr &ptr)
 {
 #if !defined( BOOST_NO_RTTI )
    BOOST_TEST( check_dynamic_pointer_cast( ptr ) );
@@ -110,15 +126,99 @@ void check_all_casts(const BasePtr &ptr)
    BOOST_TEST( check_const_pointer_cast( ptr ) );
 }
 
+
+#if !defined( BOOST_NO_RTTI )
+
+template <class BasePtr>
+bool check_dynamic_moving_pointer_cast(std::function<BasePtr()> f)
+{
+   BasePtr smart1 = f(), smart2 = f();
+   derived* expect1 = dynamic_cast<derived*>(boost::get_pointer(smart1));
+   derived_derived* expect2 = dynamic_cast<derived_derived*>(boost::get_pointer(smart2));
+   //Check that dynamic_pointer_cast versus dynamic_cast
+   return
+   //Correct cast with dynamic_pointer_cast
+   boost::get_pointer(boost::dynamic_pointer_cast<derived>( std::move(smart1) )) == expect1
+   &&
+   //Incorrect cast with dynamic_pointer_cast
+   boost::get_pointer(boost::dynamic_pointer_cast<derived_derived>( std::move(smart2) )) == expect2;
+}
+
+#endif
+
+template <class BasePtr>
+bool check_static_moving_pointer_cast(std::function<BasePtr()> f)
+{
+   BasePtr smart = f();
+   base2 *expect = static_cast<base2*>(static_cast<derived*>(boost::get_pointer(smart)));
+
+   return
+   //Cast base -> derived -> base2 using static_pointer_cast
+   boost::get_pointer(
+            boost::static_pointer_cast<base2>(
+               boost::static_pointer_cast<derived>( std::move(smart) ))) ==
+   //Now the same with static_cast
+   expect;
+}
+
+template <class BasePtr>
+bool check_const_moving_pointer_cast(std::function<BasePtr()> f)
+{
+   BasePtr smart = f();
+   const base *expect = const_cast<const base*>(const_cast<base*>(boost::get_pointer(smart)));
+   return
+   //Unconst and const again using const_pointer_cast
+   boost::get_pointer(
+      boost::const_pointer_cast<const base>
+         (boost::const_pointer_cast<base>( std::move(smart) ))) ==
+   //Now the same with const_cast
+   expect;
+}
+
+template <class BasePtr>
+void check_all_moving_casts(std::function<BasePtr()> f) {
+#if !defined( BOOST_NO_RTTI )
+   BOOST_TEST( check_dynamic_moving_pointer_cast( f ) );
+#endif
+   BOOST_TEST( check_static_moving_pointer_cast( f ) );
+   BOOST_TEST( check_const_moving_pointer_cast( f ) );
+}
+
 }
 
 int main()
 {
-#if !defined( BOOST_NO_CXX11_SMART_PTR )
+
    std::shared_ptr<base> std_shared(new derived);
-   check_all_casts(std_shared);
-#endif
+   boost::shared_ptr<base> boost_shared(new derived);
+   base *plain = boost_shared.get();
 
-   return boost::report_errors();
+   // plain & boost::shared_ptr moving pointer_cast checks; there
+   // is no specific handleing for those types at the moment; this
+   // test just makes sure they won't break when std::move() is used
+   // in generic code
+
+   check_all_moving_casts<boost::shared_ptr<base>>([&boost_shared]() {
+       return boost_shared;
+   });
+
+   check_all_moving_casts<base*>([plain]() {
+       return plain;
+   });
+
+   // std::shared_ptr casts
+
+   check_all_copy_casts(std_shared);
+   check_all_moving_casts<std::shared_ptr<base>>([&std_shared]() {
+       return std_shared;
+   });
+
+   // std::unique_ptr casts
+
+   check_all_moving_casts<std::unique_ptr<base>>([]() {
+       return std::unique_ptr<base>(new derived);
+   });
+
+    return boost::report_errors();
 }
-
+#endif