diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
commit | 19fcec84d8d7d21e796c7624e521b60d28ee21ed (patch) | |
tree | 42d26aa27d1e3f7c0b8bd3fd14e7d7082f5008dc /src/boost/libs/conversion | |
parent | Initial commit. (diff) | |
download | ceph-6d07fdb6bb33b1af39833b850bb6cf8af79fe293.tar.xz ceph-6d07fdb6bb33b1af39833b850bb6cf8af79fe293.zip |
Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/boost/libs/conversion')
-rw-r--r-- | src/boost/libs/conversion/CMakeLists.txt | 24 | ||||
-rw-r--r-- | src/boost/libs/conversion/README.md | 16 | ||||
-rw-r--r-- | src/boost/libs/conversion/index.html | 35 | ||||
-rw-r--r-- | src/boost/libs/conversion/meta/libraries.json | 15 | ||||
-rw-r--r-- | src/boost/libs/conversion/test/Jamfile.v2 | 29 | ||||
-rw-r--r-- | src/boost/libs/conversion/test/cast_test.cpp | 82 | ||||
-rw-r--r-- | src/boost/libs/conversion/test/implicit_cast.cpp | 38 | ||||
-rw-r--r-- | src/boost/libs/conversion/test/implicit_cast_fail.cpp | 20 | ||||
-rw-r--r-- | src/boost/libs/conversion/test/implicit_cast_fail2.cpp | 19 | ||||
-rw-r--r-- | src/boost/libs/conversion/test/polymorphic_cast_test.cpp | 391 |
10 files changed, 669 insertions, 0 deletions
diff --git a/src/boost/libs/conversion/CMakeLists.txt b/src/boost/libs/conversion/CMakeLists.txt new file mode 100644 index 000000000..b333aab03 --- /dev/null +++ b/src/boost/libs/conversion/CMakeLists.txt @@ -0,0 +1,24 @@ +# Copyright 2019 Mike Dev +# Distributed under the Boost Software License, Version 1.0. +# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt +# +# NOTE: CMake support for Boost.Conversion is currently experimental at best +# and the interface is likely to change in the future + +cmake_minimum_required( VERSION 3.5 ) +project( BoostConversion LANGUAGES CXX ) + +add_library( boost_conversion INTERFACE ) +add_library( Boost::conversion ALIAS boost_conversion ) + +target_include_directories( boost_conversion INTERFACE include ) + +target_link_libraries( boost_conversion + INTERFACE + Boost::assert + Boost::config + Boost::smart_ptr + Boost::throw_exception + Boost::type_traits + Boost::typeof +) diff --git a/src/boost/libs/conversion/README.md b/src/boost/libs/conversion/README.md new file mode 100644 index 000000000..2cd1b9d49 --- /dev/null +++ b/src/boost/libs/conversion/README.md @@ -0,0 +1,16 @@ +# [Boost.Conversion](http://boost.org/libs/conversion) +Boost.Conversion is one of the [Boost C++ Libraries](http://github.com/boostorg). This library improves program safety and clarity by performing otherwise messy conversions. + +### Test results + +@ | Build | Tests coverage | More info +----------------|-------------- | -------------- |----------- +Develop branch: | [![Build Status](https://travis-ci.org/apolukhin/conversion.svg?branch=develop)](https://travis-ci.org/apolukhin/conversion) [![Build status](https://ci.appveyor.com/api/projects/status/yep84179w535pppg/branch/develop?svg=true)](https://ci.appveyor.com/project/apolukhin/conversion/branch/develop) | [![Coverage Status](https://coveralls.io/repos/apolukhin/conversion/badge.png?branch=develop)](https://coveralls.io/r/apolukhin/conversion?branch=develop) | [details...](http://www.boost.org/development/tests/develop/developer/conversion.html) +Master branch: | [![Build Status](https://travis-ci.org/apolukhin/conversion.svg?branch=master)](https://travis-ci.org/apolukhin/conversion) [![Build status](https://ci.appveyor.com/api/projects/status/yep84179w535pppg/branch/master?svg=true)](https://ci.appveyor.com/project/apolukhin/conversion/branch/master) | [![Coverage Status](https://coveralls.io/repos/apolukhin/conversion/badge.png?branch=master)](https://coveralls.io/r/apolukhin/conversion?branch=master) | [details...](http://www.boost.org/development/tests/master/developer/conversion.html) + + +[Open Issues](https://svn.boost.org/trac/boost/query?status=!closed&component=conversion&or&status=!closed&component=lexical_cast) + +### License + +Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt). diff --git a/src/boost/libs/conversion/index.html b/src/boost/libs/conversion/index.html new file mode 100644 index 000000000..0f61fb0ca --- /dev/null +++ b/src/boost/libs/conversion/index.html @@ -0,0 +1,35 @@ +<!DOCTYPE html> +<!-- + Copyright (c) 2016 Mikhail Maximov + vigorous.activity at gmail dot com + + Distributed under the Boost Software License, + Version 1.0. (See accompanying file LICENSE_1_0.txt + or copy at http://boost.org/LICENSE_1_0.txt) +--> +<html> +<head> +<meta charset="utf-8"> +<meta http-equiv="refresh" content="0; url=../../doc/html/conversion.html"> +<title>Boost.Conversion</title> +<style> + body { + background: #fff; + color: #000; + } + a { + color: #00f; + text-decoration: none; + } +</style> +</head> +<body> + <p> + Automatic redirection failed, please go to + <a href="../../doc/html/conversion.html">../../doc/html/conversion.html</a> + </p> + <p> + © 2014 Antony Polukhin + </p> +</body> +</html>
\ No newline at end of file diff --git a/src/boost/libs/conversion/meta/libraries.json b/src/boost/libs/conversion/meta/libraries.json new file mode 100644 index 000000000..3c7c72620 --- /dev/null +++ b/src/boost/libs/conversion/meta/libraries.json @@ -0,0 +1,15 @@ +{ + "key": "conversion", + "name": "Conversion", + "authors": [ + "Dave Abrahams", + "Kevlin Henney" + ], + "description": "Polymorphic casts.", + "category": [ + "Miscellaneous" + ], + "maintainers": [ + "Antony Polukhin <antoshkka -at- gmail.com>" + ] +} diff --git a/src/boost/libs/conversion/test/Jamfile.v2 b/src/boost/libs/conversion/test/Jamfile.v2 new file mode 100644 index 000000000..c513ee850 --- /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 000000000..87473978a --- /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 000000000..eaca42a83 --- /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 000000000..86ccbb25c --- /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 000000000..97cc2d826 --- /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 000000000..5bb0699c8 --- /dev/null +++ b/src/boost/libs/conversion/test/polymorphic_cast_test.cpp @@ -0,0 +1,391 @@ +// +// 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_pointer = new Derived; + + // test raw pointer cast + Derived *derived_pointer = boost::polymorphic_downcast<Derived *>(base_pointer); + + BOOST_TEST(derived_pointer != 0); + + if (derived_pointer != 0) + { + BOOST_TEST_EQ(derived_pointer->kind(), "Derived"); + } + + // test reference cast + Derived& derived_ref = boost::polymorphic_downcast<Derived&>(*base_pointer); + BOOST_TEST_EQ(derived_ref.kind(), "Derived"); + + delete base_pointer; +} + +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_pointer = new Base; + + { + // test raw pointer cast + + int old_count = assertion_failed_count; + expect_assertion = true; + + BOOST_TEST_THROWS(boost::polymorphic_downcast<Derived *>(base_pointer), expected_assertion); // should assert + + BOOST_TEST_EQ(assertion_failed_count, old_count + 1); + expect_assertion = false; + } + { + // test reference cast + + int old_count = assertion_failed_count; + expect_assertion = true; + + BOOST_TEST_THROWS(boost::polymorphic_downcast<Derived &>(*base_pointer), expected_assertion); // should assert + + BOOST_TEST_EQ(assertion_failed_count, old_count + 1); + expect_assertion = false; + } + + delete base_pointer; +} + +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(); +} |