Adding upstream version 14.2.21.upstream/14.2.21 upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
author: Daniel Baumann <daniel.baumann@progress-linux.org> 2024-04-27 18:24:20 +0000
committer: Daniel Baumann <daniel.baumann@progress-linux.org> 2024-04-27 18:24:20 +0000
commit: 483eb2f56657e8e7f419ab1a4fab8dce9ade8609 (patch)
tree: e5d88d25d870d5dedacb6bbdbe2a966086a0a5cf /src/boost/libs/conversion
parent: Initial commit. (diff)
download: ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.tar.xz
ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.zip
10 files changed, 651 insertions, 0 deletions
diff --git a/src/boost/libs/conversion/CMakeLists.txt b/src/boost/libs/conversion/CMakeLists.txt
new file mode 100644
index 00000000..b333aab0
--- /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 00000000..2cd1b9d4
--- /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 00000000..0f61fb0c
--- /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>
+    &copy; 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 00000000..3c7c7262
--- /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 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();
+}
author	Daniel Baumann <daniel.baumann@progress-linux.org>	2024-04-27 18:24:20 +0000
committer	Daniel Baumann <daniel.baumann@progress-linux.org>	2024-04-27 18:24:20 +0000
commit	483eb2f56657e8e7f419ab1a4fab8dce9ade8609 (patch)
tree	e5d88d25d870d5dedacb6bbdbe2a966086a0a5cf /src/boost/libs/conversion
parent	Initial commit. (diff)
download	ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.tar.xz ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.zip