throw_exception/test/throw_exception_test5.cpp at 4c87fed0cf12c9d8d08788fe860a005fbff538fc · boostorg/throw_exception · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
// Copyright 2018, 2019 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

#ifdef BOOST_USE_MODULES

import std.compat;

int main()
{
    printf("This test depends on Boost.Exception and can't be run with C++20 modules yet\n");
}

#else

#if defined(__clang__)
# pragma clang diagnostic ignored "-Wunknown-pragmas"
# pragma clang diagnostic ignored "-Wunknown-warning-option"
# pragma clang diagnostic ignored "-Wpotentially-evaluated-expression"
# pragma clang diagnostic ignored "-Wdelete-non-abstract-non-virtual-dtor"
#endif

#include <boost/throw_exception.hpp>
#include <boost/exception/get_error_info.hpp>
#include <boost/exception/info.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/config/std/string.hpp>

typedef boost::error_info<struct tag_error_code, int> error_code;
typedef boost::error_info<struct tag_error_string, std::string> error_string;

class my_exception: public std::exception, public boost::exception
{
};

class my_exception2: public std::exception, public virtual boost::exception
{
};

int main()
{
    try
    {
        boost::throw_exception( my_exception() << error_code( 123 ) << error_string( "error%%string" ) );
    }
    catch( boost::exception const & x )
    {
        {
            int const * code = boost::get_error_info<error_code>( x );

            BOOST_TEST( code != 0 );
            BOOST_TEST_EQ( *code, 123 );
        }

        {
            std::string const * str = boost::get_error_info<error_string>( x );

            BOOST_TEST( str != 0 );
            BOOST_TEST_EQ( *str, "error%%string" );
        }
    }

    try
    {
        BOOST_THROW_EXCEPTION( my_exception() << error_code( 123 ) << error_string( "error%%string" ) );
    }
    catch( boost::exception const & x )
    {
        {
            int const * code = boost::get_error_info<error_code>( x );

            BOOST_TEST( code != 0 );
            BOOST_TEST_EQ( *code, 123 );
        }

        {
            std::string const * str = boost::get_error_info<error_string>( x );

            BOOST_TEST( str != 0 );
            BOOST_TEST_EQ( *str, "error%%string" );
        }
    }

    try
    {
        boost::throw_exception( my_exception2() << error_code( 123 ) << error_string( "error%%string" ) );
    }
    catch( boost::exception const & x )
    {
        {
            int const * code = boost::get_error_info<error_code>( x );

            BOOST_TEST( code != 0 );
            BOOST_TEST_EQ( *code, 123 );
        }

        {
            std::string const * str = boost::get_error_info<error_string>( x );

            BOOST_TEST( str != 0 );
            BOOST_TEST_EQ( *str, "error%%string" );
        }
    }

    try
    {
        BOOST_THROW_EXCEPTION( my_exception2() << error_code( 123 ) << error_string( "error%%string" ) );
    }
    catch( boost::exception const & x )
    {
        {
            int const * code = boost::get_error_info<error_code>( x );

            BOOST_TEST( code != 0 );
            BOOST_TEST_EQ( *code, 123 );
        }

        {
            std::string const * str = boost::get_error_info<error_string>( x );

            BOOST_TEST( str != 0 );
            BOOST_TEST_EQ( *str, "error%%string" );
        }
    }

    return boost::report_errors();
}

#endif