1 | // Copyright 2017, 2021 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 <boost/core/lightweight_test_trait.hpp> |
8 | |
9 | using namespace boost::system; |
10 | |
11 | struct X |
12 | { |
13 | static int instances; |
14 | |
15 | int v_; |
16 | |
17 | X(): v_() { ++instances; } |
18 | |
19 | explicit X( int v ): v_( v ) { ++instances; } |
20 | |
21 | X( int v1, int v2 ): v_( v1+v2 ) { ++instances; } |
22 | X( int v1, int v2, int v3 ): v_( v1+v2+v3 ) { ++instances; } |
23 | |
24 | X( X const& r ): v_( r.v_ ) { ++instances; } |
25 | |
26 | X& operator=( X const& ) = delete; |
27 | |
28 | ~X() { --instances; } |
29 | }; |
30 | |
31 | bool operator==( X const & x1, X const & x2 ) |
32 | { |
33 | return x1.v_ == x2.v_; |
34 | } |
35 | |
36 | std::ostream& operator<<( std::ostream& os, X const & x ) |
37 | { |
38 | os << "X:" << x.v_; |
39 | return os; |
40 | } |
41 | |
42 | int X::instances = 0; |
43 | |
44 | int main() |
45 | { |
46 | { |
47 | result<int> r; |
48 | result<int> r2( r ); |
49 | |
50 | BOOST_TEST_EQ( r, r2 ); |
51 | } |
52 | |
53 | { |
54 | result<int> const r; |
55 | result<int> r2( r ); |
56 | |
57 | BOOST_TEST_EQ( r, r2 ); |
58 | } |
59 | |
60 | BOOST_TEST_EQ( X::instances, 0 ); |
61 | |
62 | { |
63 | result<X> r; |
64 | result<X> r2( r ); |
65 | |
66 | BOOST_TEST_EQ( r, r2 ); |
67 | BOOST_TEST_EQ( X::instances, 2 ); |
68 | } |
69 | |
70 | BOOST_TEST_EQ( X::instances, 0 ); |
71 | |
72 | { |
73 | result<int> r( 1 ); |
74 | result<int> r2( r ); |
75 | |
76 | BOOST_TEST_EQ( r, r2 ); |
77 | } |
78 | |
79 | { |
80 | result<int> const r( 1 ); |
81 | result<int> r2( r ); |
82 | |
83 | BOOST_TEST_EQ( r, r2 ); |
84 | } |
85 | |
86 | BOOST_TEST_EQ( X::instances, 0 ); |
87 | |
88 | { |
89 | result<X> r( 1 ); |
90 | result<X> r2( r ); |
91 | |
92 | BOOST_TEST_EQ( r, r2 ); |
93 | BOOST_TEST_EQ( X::instances, 2 ); |
94 | } |
95 | |
96 | BOOST_TEST_EQ( X::instances, 0 ); |
97 | |
98 | { |
99 | result<X> const r( 1 ); |
100 | result<X> r2( r ); |
101 | |
102 | BOOST_TEST_EQ( r, r2 ); |
103 | BOOST_TEST_EQ( X::instances, 2 ); |
104 | } |
105 | |
106 | BOOST_TEST_EQ( X::instances, 0 ); |
107 | |
108 | { |
109 | auto ec = make_error_code( e: errc::invalid_argument ); |
110 | |
111 | result<int> r( ec ); |
112 | result<int> r2( r ); |
113 | |
114 | BOOST_TEST_EQ( r, r2 ); |
115 | } |
116 | |
117 | { |
118 | auto ec = make_error_code( e: errc::invalid_argument ); |
119 | |
120 | result<int> const r( ec ); |
121 | result<int> r2( r ); |
122 | |
123 | BOOST_TEST_EQ( r, r2 ); |
124 | } |
125 | |
126 | BOOST_TEST_EQ( X::instances, 0 ); |
127 | |
128 | { |
129 | result<std::string, X> r( 1 ); |
130 | result<std::string, X> r2( r ); |
131 | |
132 | BOOST_TEST_EQ( r, r2 ); |
133 | BOOST_TEST_EQ( X::instances, 2 ); |
134 | } |
135 | |
136 | BOOST_TEST_EQ( X::instances, 0 ); |
137 | |
138 | { |
139 | result<std::string, X> const r( 1 ); |
140 | result<std::string, X> r2( r ); |
141 | |
142 | BOOST_TEST_EQ( r, r2 ); |
143 | BOOST_TEST_EQ( X::instances, 2 ); |
144 | } |
145 | |
146 | BOOST_TEST_EQ( X::instances, 0 ); |
147 | |
148 | // |
149 | |
150 | { |
151 | result<void> r; |
152 | result<void> r2( r ); |
153 | |
154 | BOOST_TEST_EQ( r, r2 ); |
155 | } |
156 | |
157 | { |
158 | result<void> const r; |
159 | result<void> r2( r ); |
160 | |
161 | BOOST_TEST_EQ( r, r2 ); |
162 | } |
163 | |
164 | { |
165 | auto ec = make_error_code( e: errc::invalid_argument ); |
166 | |
167 | result<void> r( ec ); |
168 | result<void> r2( r ); |
169 | |
170 | BOOST_TEST_EQ( r, r2 ); |
171 | } |
172 | |
173 | { |
174 | auto ec = make_error_code( e: errc::invalid_argument ); |
175 | |
176 | result<void> const r( ec ); |
177 | result<void> r2( r ); |
178 | |
179 | BOOST_TEST_EQ( r, r2 ); |
180 | } |
181 | |
182 | // |
183 | |
184 | { |
185 | int x1 = 1; |
186 | |
187 | result<int&> r1( x1 ); |
188 | result<int&> r2( r1 ); |
189 | |
190 | BOOST_TEST_EQ( r1, r2 ); |
191 | BOOST_TEST_EQ( &*r2, &x1 ); |
192 | } |
193 | |
194 | { |
195 | int x1 = 1; |
196 | |
197 | result<int&> const r1( x1 ); |
198 | result<int&> r2( r1 ); |
199 | |
200 | BOOST_TEST_EQ( r1, r2 ); |
201 | BOOST_TEST_EQ( &*r2, &x1 ); |
202 | } |
203 | |
204 | { |
205 | int const x1 = 1; |
206 | |
207 | result<int const&> r1( x1 ); |
208 | result<int const&> r2( r1 ); |
209 | |
210 | BOOST_TEST_EQ( r1, r2 ); |
211 | BOOST_TEST_EQ( &*r2, &x1 ); |
212 | } |
213 | |
214 | { |
215 | int const x1 = 1; |
216 | |
217 | result<int const&> const r1( x1 ); |
218 | result<int const&> r2( r1 ); |
219 | |
220 | BOOST_TEST_EQ( r1, r2 ); |
221 | BOOST_TEST_EQ( &*r2, &x1 ); |
222 | } |
223 | |
224 | BOOST_TEST_EQ( X::instances, 0 ); |
225 | |
226 | { |
227 | X x1( 1 ); |
228 | |
229 | result<X&> r1( x1 ); |
230 | result<X&> r2( r1 ); |
231 | |
232 | BOOST_TEST_EQ( r1, r2 ); |
233 | BOOST_TEST_EQ( &*r2, &x1 ); |
234 | BOOST_TEST_EQ( X::instances, 1 ); |
235 | } |
236 | |
237 | BOOST_TEST_EQ( X::instances, 0 ); |
238 | |
239 | { |
240 | X x1( 1 ); |
241 | |
242 | result<X&> const r1( x1 ); |
243 | result<X&> r2( r1 ); |
244 | |
245 | BOOST_TEST_EQ( r1, r2 ); |
246 | BOOST_TEST_EQ( &*r2, &x1 ); |
247 | BOOST_TEST_EQ( X::instances, 1 ); |
248 | } |
249 | |
250 | BOOST_TEST_EQ( X::instances, 0 ); |
251 | |
252 | { |
253 | X const x1( 1 ); |
254 | |
255 | result<X const&> r1( x1 ); |
256 | result<X const&> r2( r1 ); |
257 | |
258 | BOOST_TEST_EQ( r1, r2 ); |
259 | BOOST_TEST_EQ( &*r2, &x1 ); |
260 | BOOST_TEST_EQ( X::instances, 1 ); |
261 | } |
262 | |
263 | BOOST_TEST_EQ( X::instances, 0 ); |
264 | |
265 | { |
266 | X const x1( 1 ); |
267 | |
268 | result<X const&> const r1( x1 ); |
269 | result<X const&> r2( r1 ); |
270 | |
271 | BOOST_TEST_EQ( r1, r2 ); |
272 | BOOST_TEST_EQ( &*r2, &x1 ); |
273 | BOOST_TEST_EQ( X::instances, 1 ); |
274 | } |
275 | |
276 | BOOST_TEST_EQ( X::instances, 0 ); |
277 | |
278 | { |
279 | auto ec = make_error_code( e: errc::invalid_argument ); |
280 | |
281 | result<int&> r1( ec ); |
282 | result<int&> r2( r1 ); |
283 | |
284 | BOOST_TEST_EQ( r1, r2 ); |
285 | } |
286 | |
287 | { |
288 | auto ec = make_error_code( e: errc::invalid_argument ); |
289 | |
290 | result<int&> const r1( ec ); |
291 | result<int&> r2( r1 ); |
292 | |
293 | BOOST_TEST_EQ( r1, r2 ); |
294 | } |
295 | |
296 | // |
297 | |
298 | return boost::report_errors(); |
299 | } |
300 | |