Merge pull request #4 from boostorg/pull-request/cast-prune-dependencies

Prune conversion dependencies

include/boost/implicit_cast.hpp

@@ -5,17 +5,24 @@
 #ifndef IMPLICIT_CAST_DWA200356_HPP
 # define IMPLICIT_CAST_DWA200356_HPP
 
-# include <boost/mpl/identity.hpp>
-
 namespace boost {
 
+namespace detail {
+
+template<class T> struct icast_identity
+{
+    typedef T type;
+};
+
+} // namespace detail
+
 // implementation originally suggested by C. Green in
 // http://lists.boost.org/MailArchives/boost/msg00886.php
 
 // The use of identity creates a non-deduced form, so that the
 // explicit template argument must be supplied
 template <typename T>
-inline T implicit_cast (typename mpl::identity<T>::type x) {
+inline T implicit_cast (typename boost::detail::icast_identity<T>::type x) {
     return x;
 }
 

include/boost/polymorphic_cast.hpp

@@ -48,9 +48,6 @@
 # include <boost/config.hpp>
 # include <boost/assert.hpp>
 # include <typeinfo>
-# include <boost/type.hpp>
-# include <boost/limits.hpp>
-# include <boost/detail/select_type.hpp>
 
 namespace boost
 {

test/Jamfile.v2

@@ -27,5 +27,6 @@ test-suite conversion
     [ compile-fail implicit_cast_fail.cpp ]
     [ run cast_test.cpp ]
     [ run numeric_cast_test.cpp ]
+    [ run polymorphic_cast_test.cpp ]
+    [ compile-fail implicit_cast_fail2.cpp ]
   ;
-

test/cast_test.cpp

@@ -14,14 +14,8 @@
 //    3 Aug 99  Initial Version
 
 #include <iostream>
-#include <climits>
-#include <cfloat>   // for DBL_MAX (Peter Schmid)
 #include <boost/polymorphic_cast.hpp>
 
-#  if SCHAR_MAX == LONG_MAX
-#      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
-#  endif
-
 using namespace boost;
 using std::cout;
 

test/implicit_cast_fail.cpp

@@ -4,10 +4,6 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/implicit_cast.hpp>
-#include <boost/type.hpp>
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
 
 using boost::implicit_cast;
 
@@ -16,11 +12,9 @@ struct foo
     explicit foo(char const*) {}
 };
 
-int test_main(int, char*[])
+int main()
 {
     foo x = implicit_cast<foo>("foobar");
     (void)x;            // warning suppression.
-    BOOST_CHECK(false); // suppressing warning about 'boost::unit_test::{anonymous}::unit_test_log' defined but not used
     return 0;
 }
-

test/implicit_cast_fail2.cpp

@@ -0,0 +1,19 @@
+//
+// Test that implicit_cast requires a template argument
+//
+// Copyright 2014 Peter Dimov
+//
+// 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/implicit_cast.hpp>
+
+int main()
+{
+    int x = boost::implicit_cast( 1 );
+    (void)x;
+
+    return 0;
+}

test/polymorphic_cast_test.cpp

@@ -0,0 +1,150 @@
+//
+// Test boost::polymorphic_cast, boost::polymorphic_downcast
+//
+// Copyright 1999 Beman Dawes
+// Copyright 1999 Dave Abrahams
+// Copyright 2014 Peter Dimov
+//
+// 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
+//
+
+#define BOOST_ENABLE_ASSERT_HANDLER
+#include <boost/polymorphic_cast.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <string>
+
+static bool expect_assertion = false;
+static int assertion_failed_count = 0;
+
+// BOOST_ASSERT custom handler
+void boost::assertion_failed( char const * expr, char const * function, char const * file, long line )
+{
+    if( expect_assertion )
+    {
+        ++assertion_failed_count;
+    }
+    else
+    {
+        BOOST_ERROR( "unexpected assertion" );
+
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+          << file << "(" << line << "): assertion '" << expr << "' failed in function '"
+          << function << "'" << std::endl;
+    }
+}
+
+//
+
+struct Base
+{
+    virtual ~Base() {}
+    virtual std::string kind() { return "Base"; }
+};
+
+struct Base2
+{
+    virtual ~Base2() {}
+    virtual std::string kind2() { return "Base2"; }
+};
+
+struct Derived : public Base, Base2
+{
+    virtual std::string kind() { return "Derived"; }
+};
+
+static void test_polymorphic_cast()
+{
+    Base * base = new Derived;
+
+    Derived * derived;
+    
+    try
+    {
+        derived = boost::polymorphic_cast<Derived*>( base );
+
+        BOOST_TEST( derived != 0 );
+
+        if( derived != 0 )
+        {
+            BOOST_TEST_EQ( derived->kind(), "Derived" );
+        }
+    }
+    catch( std::bad_cast const& )
+    {
+        BOOST_ERROR( "boost::polymorphic_cast<Derived*>( base ) threw std::bad_cast" );
+    }
+
+    Base2 * base2;
+
+    try
+    {
+        base2 = boost::polymorphic_cast<Base2*>( base ); // crosscast
+
+        BOOST_TEST( base2 != 0 );
+
+        if( base2 != 0 )
+        {
+            BOOST_TEST_EQ( base2->kind2(), "Base2" );
+        }
+    }
+    catch( std::bad_cast const& )
+    {
+        BOOST_ERROR( "boost::polymorphic_cast<Base2*>( base ) threw std::bad_cast" );
+    }
+
+    delete base;
+}
+
+static void test_polymorphic_downcast()
+{
+    Base * base = new Derived;
+
+    Derived * derived = boost::polymorphic_downcast<Derived*>( base );
+
+    BOOST_TEST( derived != 0 );
+
+    if( derived != 0 )
+    {
+        BOOST_TEST_EQ( derived->kind(), "Derived" );
+    }
+
+    // polymorphic_downcast can't do crosscasts
+
+    delete base;
+}
+
+static void test_polymorphic_cast_fail()
+{
+    Base * base = new Base;
+
+    BOOST_TEST_THROWS( boost::polymorphic_cast<Derived*>( base ), std::bad_cast );
+
+    delete base;
+}
+
+static void test_polymorphic_downcast_fail()
+{
+    Base * base = new Base;
+
+    int old_count = assertion_failed_count;
+    expect_assertion = true;
+
+    boost::polymorphic_downcast<Derived*>( base ); // should assert
+
+    BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
+    expect_assertion = false;
+
+    delete base;
+}
+
+int main()
+{
+    test_polymorphic_cast();
+    test_polymorphic_downcast();
+    test_polymorphic_cast_fail();
+    test_polymorphic_downcast_fail();
+
+    return boost::report_errors();
+}