1 | // Copyright 2017, 2021, 2022 Peter Dimov. |
2 | // Distributed under the Boost Software License, Version 1.0. |
3 | // https://www.boost.org/LICENSE_1_0.txt |
4 | |
5 | #include <boost/system/result.hpp> |
6 | #include <boost/core/lightweight_test.hpp> |
7 | #include <string> |
8 | #include <cerrno> |
9 | |
10 | using namespace boost::system; |
11 | |
12 | struct X |
13 | { |
14 | static int instances; |
15 | |
16 | int v_; |
17 | |
18 | X(): v_() { ++instances; } |
19 | |
20 | explicit X( int v ): v_( v ) { ++instances; } |
21 | |
22 | X( int v1, int v2 ): v_( v1+v2 ) { ++instances; } |
23 | X( int v1, int v2, int v3 ): v_( v1+v2+v3 ) { ++instances; } |
24 | |
25 | X( X const& r ): v_( r.v_ ) { ++instances; } |
26 | |
27 | X& operator=( X const& ) = delete; |
28 | |
29 | ~X() { --instances; } |
30 | }; |
31 | |
32 | int X::instances = 0; |
33 | |
34 | int main() |
35 | { |
36 | { |
37 | auto ec = make_error_code( e: errc::invalid_argument ); |
38 | |
39 | using R = result<int>; |
40 | R r( R::in_place_error, ec ); |
41 | |
42 | BOOST_TEST( !r.has_value() ); |
43 | BOOST_TEST( r.has_error() ); |
44 | |
45 | BOOST_TEST_EQ( r.error(), ec ); |
46 | } |
47 | |
48 | { |
49 | using R = result<int>; |
50 | R r( R::in_place_error, EINVAL, generic_category() ); |
51 | |
52 | BOOST_TEST( !r.has_value() ); |
53 | BOOST_TEST( r.has_error() ); |
54 | |
55 | BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) ); |
56 | } |
57 | |
58 | { |
59 | auto ec = make_error_code( e: errc::invalid_argument ); |
60 | |
61 | using R = result<error_code>; |
62 | R r( R::in_place_error, ec ); |
63 | |
64 | BOOST_TEST( !r.has_value() ); |
65 | BOOST_TEST( r.has_error() ); |
66 | |
67 | BOOST_TEST_EQ( r.error(), ec ); |
68 | } |
69 | |
70 | { |
71 | using R = result<error_code>; |
72 | R r( R::in_place_error, EINVAL, generic_category() ); |
73 | |
74 | BOOST_TEST( !r.has_value() ); |
75 | BOOST_TEST( r.has_error() ); |
76 | |
77 | BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) ); |
78 | } |
79 | |
80 | BOOST_TEST_EQ( X::instances, 0 ); |
81 | |
82 | { |
83 | using R = result<std::string, X>; |
84 | R r( R::in_place_error, 1 ); |
85 | |
86 | BOOST_TEST( !r.has_value() ); |
87 | BOOST_TEST( r.has_error() ); |
88 | |
89 | BOOST_TEST_EQ( r.error().v_, 1 ); |
90 | |
91 | BOOST_TEST_EQ( X::instances, 1 ); |
92 | } |
93 | |
94 | BOOST_TEST_EQ( X::instances, 0 ); |
95 | |
96 | { |
97 | using R = result<int, X>; |
98 | R r( R::in_place_error, 1, 2 ); |
99 | |
100 | BOOST_TEST( !r.has_value() ); |
101 | BOOST_TEST( r.has_error() ); |
102 | |
103 | BOOST_TEST_EQ( r.error().v_, 1+2 ); |
104 | |
105 | BOOST_TEST_EQ( X::instances, 1 ); |
106 | } |
107 | |
108 | BOOST_TEST_EQ( X::instances, 0 ); |
109 | |
110 | { |
111 | using R = result<int, X>; |
112 | R r( R::in_place_error, 1, 2, 3 ); |
113 | |
114 | BOOST_TEST( !r.has_value() ); |
115 | BOOST_TEST( r.has_error() ); |
116 | |
117 | BOOST_TEST_EQ( r.error().v_, 1+2+3 ); |
118 | |
119 | BOOST_TEST_EQ( X::instances, 1 ); |
120 | } |
121 | |
122 | BOOST_TEST_EQ( X::instances, 0 ); |
123 | |
124 | { |
125 | using R = result<X, X>; |
126 | R r( R::in_place_error, 1 ); |
127 | |
128 | BOOST_TEST( !r.has_value() ); |
129 | BOOST_TEST( r.has_error() ); |
130 | |
131 | BOOST_TEST_EQ( r.error().v_, 1 ); |
132 | |
133 | BOOST_TEST_EQ( X::instances, 1 ); |
134 | } |
135 | |
136 | BOOST_TEST_EQ( X::instances, 0 ); |
137 | |
138 | { |
139 | auto ec = make_error_code( e: errc::invalid_argument ); |
140 | |
141 | using R = result<void>; |
142 | R r( R::in_place_error, ec ); |
143 | |
144 | BOOST_TEST( !r.has_value() ); |
145 | BOOST_TEST( r.has_error() ); |
146 | |
147 | BOOST_TEST_EQ( r.error(), ec ); |
148 | } |
149 | |
150 | { |
151 | using R = result<void>; |
152 | R r( R::in_place_error, EINVAL, generic_category() ); |
153 | |
154 | BOOST_TEST( !r.has_value() ); |
155 | BOOST_TEST( r.has_error() ); |
156 | |
157 | BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) ); |
158 | } |
159 | |
160 | { |
161 | auto ec = make_error_code( e: errc::invalid_argument ); |
162 | |
163 | using R = result<int&>; |
164 | R r( R::in_place_error, ec ); |
165 | |
166 | BOOST_TEST( !r.has_value() ); |
167 | BOOST_TEST( r.has_error() ); |
168 | |
169 | BOOST_TEST_EQ( r.error(), ec ); |
170 | } |
171 | |
172 | { |
173 | using R = result<int&>; |
174 | R r( R::in_place_error, EINVAL, generic_category() ); |
175 | |
176 | BOOST_TEST( !r.has_value() ); |
177 | BOOST_TEST( r.has_error() ); |
178 | |
179 | BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) ); |
180 | } |
181 | |
182 | return boost::report_errors(); |
183 | } |
184 | |