summaryrefslogtreecommitdiffstats
path: root/src/boost/libs/conversion/test
diff options
context:
space:
mode:
Diffstat (limited to 'src/boost/libs/conversion/test')
-rw-r--r--src/boost/libs/conversion/test/Jamfile.v229
-rw-r--r--src/boost/libs/conversion/test/cast_test.cpp82
-rw-r--r--src/boost/libs/conversion/test/implicit_cast.cpp38
-rw-r--r--src/boost/libs/conversion/test/implicit_cast_fail.cpp20
-rw-r--r--src/boost/libs/conversion/test/implicit_cast_fail2.cpp19
-rw-r--r--src/boost/libs/conversion/test/polymorphic_cast_test.cpp373
6 files changed, 561 insertions, 0 deletions
diff --git a/src/boost/libs/conversion/test/Jamfile.v2 b/src/boost/libs/conversion/test/Jamfile.v2
new file mode 100644
index 00000000..c513ee85
--- /dev/null
+++ b/src/boost/libs/conversion/test/Jamfile.v2
@@ -0,0 +1,29 @@
+# Copyright (C) 2001-2003 Douglas Gregor
+# Copyright (C) 2011-2014 Antony Polukhin
+#
+# 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)
+#
+
+import testing ;
+import feature ;
+
+project
+ : requirements
+ <toolset>gcc-4.7:<cxxflags>-ftrapv
+ <toolset>gcc-4.6:<cxxflags>-ftrapv
+ <toolset>clang:<cxxflags>-ftrapv
+ # default to all warnings on:
+ <warnings>all
+ # set warnings as errors for those compilers we know we get warning free:
+ <toolset>gcc:<cxxflags>-Wextra
+ <toolset>gcc:<cxxflags>-Wno-uninitialized
+ ;
+
+test-suite conversion
+ : [ run implicit_cast.cpp ]
+ [ compile-fail implicit_cast_fail.cpp ]
+ [ run cast_test.cpp ]
+ [ run polymorphic_cast_test.cpp ]
+ [ compile-fail implicit_cast_fail2.cpp ]
+ ;
diff --git a/src/boost/libs/conversion/test/cast_test.cpp b/src/boost/libs/conversion/test/cast_test.cpp
new file mode 100644
index 00000000..87473978
--- /dev/null
+++ b/src/boost/libs/conversion/test/cast_test.cpp
@@ -0,0 +1,82 @@
+// boost utility cast test program -----------------------------------------//
+
+// (C) Copyright Beman Dawes, Dave Abrahams 1999. 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 for most recent version including documentation.
+
+// Revision History
+// 28 Set 04 factored out numeric_cast<> test (Fernando Cacciola)
+// 20 Jan 01 removed use of <limits> for portability to raw GCC (David Abrahams)
+// 28 Jun 00 implicit_cast removed (Beman Dawes)
+// 30 Aug 99 value_cast replaced by numeric_cast
+// 3 Aug 99 Initial Version
+
+#include <iostream>
+#include <boost/polymorphic_cast.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost;
+using std::cout;
+
+namespace
+{
+ struct Base
+ {
+ virtual char kind() { return 'B'; }
+ };
+
+ struct Base2
+ {
+ virtual char kind2() { return '2'; }
+ };
+
+ struct Derived : public Base, Base2
+ {
+ virtual char kind() { return 'D'; }
+ };
+}
+
+
+int main( int argc, char * argv[] )
+{
+# ifdef NDEBUG
+ cout << "NDEBUG is defined\n";
+# else
+ cout << "NDEBUG is not defined\n";
+# endif
+
+ cout << "\nBeginning tests...\n";
+
+// test polymorphic_cast ---------------------------------------------------//
+
+ // tests which should succeed
+ Derived derived_instance;
+ Base * base = &derived_instance;
+ Derived * derived = polymorphic_downcast<Derived*>( base ); // downcast
+ BOOST_TEST( derived->kind() == 'D' );
+
+ derived = polymorphic_cast<Derived*>( base ); // downcast, throw on error
+ BOOST_TEST( derived->kind() == 'D' );
+
+ Base2 * base2 = polymorphic_cast<Base2*>( base ); // crosscast
+ BOOST_TEST( base2->kind2() == '2' );
+
+ // tests which should result in errors being detected
+ Base base_instance;
+ base = &base_instance;
+
+ if ( argc > 1 && *argv[1] == '1' )
+ { derived = polymorphic_downcast<Derived*>( base ); } // #1 assert failure
+
+ bool caught_exception = false;
+ try { derived = polymorphic_cast<Derived*>( base ); }
+ catch (const std::bad_cast&)
+ { cout<<"caught bad_cast\n"; caught_exception = true; }
+ BOOST_TEST( caught_exception );
+ // the following is just so generated code can be inspected
+ BOOST_TEST( derived->kind() != 'B' );
+
+ return boost::report_errors();
+} // main
diff --git a/src/boost/libs/conversion/test/implicit_cast.cpp b/src/boost/libs/conversion/test/implicit_cast.cpp
new file mode 100644
index 00000000..eaca42a8
--- /dev/null
+++ b/src/boost/libs/conversion/test/implicit_cast.cpp
@@ -0,0 +1,38 @@
+// Copyright David Abrahams 2003.
+// 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>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/type.hpp>
+using boost::implicit_cast;
+using boost::type;
+
+template <class T>
+type<T> check_return(T) { return type<T>(); }
+
+struct foo
+{
+ foo(char const*) {}
+ operator long() const { return 0; }
+};
+
+typedef type<long> long_type;
+typedef type<foo> foo_type;
+
+int main()
+{
+ type<long> x = check_return(boost::implicit_cast<long>(1));
+ BOOST_TEST(boost::implicit_cast<long>(1) == 1L);
+
+ type<foo> f = check_return(boost::implicit_cast<foo>("hello"));
+ type<long> z = check_return(boost::implicit_cast<long>(foo("hello")));
+
+ // warning suppression:
+ (void)x;
+ (void)f;
+ (void)z;
+
+ return boost::report_errors();
+}
diff --git a/src/boost/libs/conversion/test/implicit_cast_fail.cpp b/src/boost/libs/conversion/test/implicit_cast_fail.cpp
new file mode 100644
index 00000000..86ccbb25
--- /dev/null
+++ b/src/boost/libs/conversion/test/implicit_cast_fail.cpp
@@ -0,0 +1,20 @@
+// Copyright David Abrahams 2003.
+// 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>
+
+using boost::implicit_cast;
+
+struct foo
+{
+ explicit foo(char const*) {}
+};
+
+int main()
+{
+ foo x = implicit_cast<foo>("foobar");
+ (void)x; // warning suppression.
+ return 0;
+}
diff --git a/src/boost/libs/conversion/test/implicit_cast_fail2.cpp b/src/boost/libs/conversion/test/implicit_cast_fail2.cpp
new file mode 100644
index 00000000..97cc2d82
--- /dev/null
+++ b/src/boost/libs/conversion/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;
+}
diff --git a/src/boost/libs/conversion/test/polymorphic_cast_test.cpp b/src/boost/libs/conversion/test/polymorphic_cast_test.cpp
new file mode 100644
index 00000000..d0e527d2
--- /dev/null
+++ b/src/boost/libs/conversion/test/polymorphic_cast_test.cpp
@@ -0,0 +1,373 @@
+//
+// Test boost::polymorphic_cast, boost::polymorphic_downcast and
+// boost::polymorphic_pointer_cast, boost::polymorphic_pointer_downcast
+//
+// Copyright 1999 Beman Dawes
+// Copyright 1999 Dave Abrahams
+// Copyright 2014 Peter Dimov
+// Copyright 2014 Boris Rasin, Antony Polukhin
+//
+// 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/polymorphic_pointer_cast.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/intrusive_ptr.hpp>
+#include <boost/smart_ptr/intrusive_ref_counter.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <string>
+#include <memory>
+
+static bool expect_assertion = false;
+static int assertion_failed_count = 0;
+
+//assertion handler throws it to exit like assert, but to be able to catch it and stop
+//usage: BOOST_TEST_THROWS( function_with_assert(), expected_assertion );
+struct expected_assertion {};
+
+// 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;
+ throw expected_assertion();
+ }
+ else
+ {
+ BOOST_ERROR( "unexpected assertion" );
+
+ BOOST_LIGHTWEIGHT_TEST_OSTREAM
+ << file << "(" << line << "): assertion '" << expr << "' failed in function '"
+ << function << "'" << std::endl;
+ }
+}
+
+//
+
+struct Base : boost::intrusive_ref_counter<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_pointer_cast()
+{
+ Base * base = new Derived;
+
+ Derived * derived;
+
+ try
+ {
+ derived = boost::polymorphic_pointer_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_pointer_cast<Derived>( base ) threw std::bad_cast" );
+ }
+
+ Base2 * base2;
+
+ try
+ {
+ base2 = boost::polymorphic_pointer_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_pointer_cast<Base2>( base ) threw std::bad_cast" );
+ }
+
+ boost::shared_ptr<Base> sp_base( base );
+ boost::shared_ptr<Base2> sp_base2;
+ try
+ {
+ sp_base2 = boost::polymorphic_pointer_cast<Base2>( sp_base ); // crosscast
+
+ BOOST_TEST( sp_base2 != 0 );
+
+ if( sp_base2 != 0 )
+ {
+ BOOST_TEST_EQ( sp_base2->kind2(), "Base2" );
+ }
+ }
+ catch( std::bad_cast const& )
+ {
+ BOOST_ERROR( "boost::polymorphic_pointer_cast<Base2>( sp_base ) threw std::bad_cast" );
+ }
+
+ // we do not `delete base;` because sahred_ptr is holding 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_pointer_downcast_builtin()
+{
+ Base * base = new Derived;
+
+ Derived * derived = boost::polymorphic_pointer_downcast<Derived>( base );
+
+ BOOST_TEST( derived != 0 );
+
+ if( derived != 0 )
+ {
+ BOOST_TEST_EQ( derived->kind(), "Derived" );
+ }
+
+ // polymorphic_pointer_downcast can't do crosscasts
+
+ delete base;
+}
+
+static void test_polymorphic_pointer_downcast_boost_shared()
+{
+ boost::shared_ptr<Base> base (new Derived);
+
+ boost::shared_ptr<Derived> derived = boost::polymorphic_pointer_downcast<Derived>( base );
+
+ BOOST_TEST( derived != 0 );
+
+ if( derived != 0 )
+ {
+ BOOST_TEST_EQ( derived->kind(), "Derived" );
+ }
+}
+
+static void test_polymorphic_pointer_downcast_intrusive()
+{
+ boost::intrusive_ptr<Base> base (new Derived);
+
+ boost::intrusive_ptr<Derived> derived = boost::polymorphic_pointer_downcast<Derived>( base );
+
+ BOOST_TEST( derived != 0 );
+
+ if( derived != 0 )
+ {
+ BOOST_TEST_EQ( derived->kind(), "Derived" );
+ }
+}
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+
+static void test_polymorphic_pointer_downcast_std_shared()
+{
+ std::shared_ptr<Base> base (new Derived);
+
+ std::shared_ptr<Derived> derived = boost::polymorphic_pointer_downcast<Derived>( base );
+
+ BOOST_TEST( derived != 0 );
+
+ if( derived != 0 )
+ {
+ BOOST_TEST_EQ( derived->kind(), "Derived" );
+ }
+}
+
+#endif
+
+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_pointer_cast_fail()
+{
+ Base * base = new Base;
+ BOOST_TEST_THROWS( boost::polymorphic_pointer_cast<Derived>( base ), std::bad_cast );
+ delete base;
+
+ BOOST_TEST_THROWS( boost::polymorphic_pointer_cast<Derived>( boost::shared_ptr<Base>(new Base) ), std::bad_cast );
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+ BOOST_TEST_THROWS( boost::polymorphic_pointer_cast<Derived>( std::shared_ptr<Base>(new Base) ), std::bad_cast );
+#endif
+
+ BOOST_TEST_THROWS( boost::polymorphic_pointer_cast<Derived>( boost::intrusive_ptr<Base>(new Base) ), std::bad_cast );
+}
+
+static void test_polymorphic_downcast_fail()
+{
+ Base * base = new Base;
+
+ int old_count = assertion_failed_count;
+ expect_assertion = true;
+
+ BOOST_TEST_THROWS( boost::polymorphic_downcast<Derived*>( base ), expected_assertion ); // should assert
+
+ BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
+ expect_assertion = false;
+
+ delete base;
+}
+
+static void test_polymorphic_pointer_downcast_builtin_fail()
+{
+ Base * base = new Base;
+
+ int old_count = assertion_failed_count;
+ expect_assertion = true;
+
+ BOOST_TEST_THROWS( boost::polymorphic_pointer_downcast<Derived>( base ), expected_assertion ); // should assert
+
+ BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
+ expect_assertion = false;
+
+ delete base;
+}
+
+static void test_polymorphic_pointer_downcast_boost_shared_fail()
+{
+ boost::shared_ptr<Base> base (new Base);
+
+ int old_count = assertion_failed_count;
+ expect_assertion = true;
+
+ BOOST_TEST_THROWS( boost::polymorphic_pointer_downcast<Derived>( base ), expected_assertion ); // should assert
+
+ BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
+ expect_assertion = false;
+}
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+
+static void test_polymorphic_pointer_downcast_std_shared_fail()
+{
+ std::shared_ptr<Base> base (new Base);
+
+ int old_count = assertion_failed_count;
+ expect_assertion = true;
+
+ BOOST_TEST_THROWS( boost::polymorphic_pointer_downcast<Derived>( base ), expected_assertion ); // should assert
+
+ BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
+ expect_assertion = false;
+}
+
+#endif
+
+static void test_polymorphic_pointer_downcast_intrusive_fail()
+{
+ boost::intrusive_ptr<Base> base (new Base);
+
+ int old_count = assertion_failed_count;
+ expect_assertion = true;
+
+ BOOST_TEST_THROWS( boost::polymorphic_pointer_downcast<Derived>( base ), expected_assertion); // should assert
+
+ BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
+ expect_assertion = false;
+}
+
+int main()
+{
+ test_polymorphic_cast();
+ test_polymorphic_pointer_cast();
+ test_polymorphic_downcast();
+ test_polymorphic_pointer_downcast_builtin();
+ test_polymorphic_pointer_downcast_boost_shared();
+ test_polymorphic_pointer_downcast_intrusive();
+ test_polymorphic_cast_fail();
+ test_polymorphic_pointer_cast_fail();
+ test_polymorphic_downcast_fail();
+ test_polymorphic_pointer_downcast_builtin_fail();
+ test_polymorphic_pointer_downcast_boost_shared_fail();
+ test_polymorphic_pointer_downcast_intrusive_fail();
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+ test_polymorphic_pointer_downcast_std_shared();
+ test_polymorphic_pointer_downcast_std_shared_fail();
+#endif
+
+ return boost::report_errors();
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-21 15:47:46 +0000