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
9using namespace boost::system;
10
11struct 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 X( X&& r ): v_( r.v_ ) { r.v_ = 0; ++instances; }
26
27 X& operator=( X const& ) = delete;
28
29 ~X() { --instances; }
30};
31
32bool operator==( X const & x1, X const & x2 )
33{
34 return x1.v_ == x2.v_;
35}
36
37std::ostream& operator<<( std::ostream& os, X const & x )
38{
39 os << "X:" << x.v_;
40 return os;
41}
42
43int X::instances = 0;
44
45int main()
46{
47 {
48 result<int> r;
49 result<int> r2( std::move( r ) );
50
51 BOOST_TEST( r2.has_value() );
52 BOOST_TEST( !r2.has_error() );
53
54 BOOST_TEST_EQ( r2.value(), 0 );
55 }
56
57 {
58 result<int> r2( result<int>{} );
59
60 BOOST_TEST( r2.has_value() );
61 BOOST_TEST( !r2.has_error() );
62
63 BOOST_TEST_EQ( r2.value(), 0 );
64 }
65
66 BOOST_TEST_EQ( X::instances, 0 );
67
68 {
69 result<X> r;
70 result<X> r2( std::move( r ) );
71
72 BOOST_TEST( r2.has_value() );
73 BOOST_TEST( !r2.has_error() );
74
75 BOOST_TEST_EQ( r2.value(), X() );
76
77 BOOST_TEST_EQ( X::instances, 2 );
78 }
79
80 BOOST_TEST_EQ( X::instances, 0 );
81
82 {
83 result<X> r2( result<X>{} );
84
85 BOOST_TEST( r2.has_value() );
86 BOOST_TEST( !r2.has_error() );
87
88 BOOST_TEST_EQ( r2.value(), X() );
89
90 BOOST_TEST_EQ( X::instances, 1 );
91 }
92
93 BOOST_TEST_EQ( X::instances, 0 );
94
95 {
96 result<int> r( 1 );
97 result<int> r2( std::move( r ) );
98
99 BOOST_TEST( r.has_value() );
100 BOOST_TEST( !r.has_error() );
101
102 BOOST_TEST_EQ( r.value(), 1 );
103
104 BOOST_TEST( r2.has_value() );
105 BOOST_TEST( !r2.has_error() );
106
107 BOOST_TEST_EQ( r2.value(), 1 );
108 }
109
110 {
111 result<int> r2( result<int>( 1 ) );
112
113 BOOST_TEST( r2.has_value() );
114 BOOST_TEST( !r2.has_error() );
115
116 BOOST_TEST_EQ( r2.value(), 1 );
117 }
118
119 BOOST_TEST_EQ( X::instances, 0 );
120
121 {
122 result<X> r( 1 );
123 result<X> r2( std::move( r ) );
124
125 BOOST_TEST( r.has_value() );
126 BOOST_TEST( !r.has_error() );
127
128 BOOST_TEST_EQ( r.value().v_, 0 );
129
130 BOOST_TEST( r2.has_value() );
131 BOOST_TEST( !r2.has_error() );
132
133 BOOST_TEST_EQ( r2.value().v_, 1 );
134
135 BOOST_TEST_EQ( X::instances, 2 );
136 }
137
138 BOOST_TEST_EQ( X::instances, 0 );
139
140 {
141 result<X> r2( result<X>( 1 ) );
142
143 BOOST_TEST( r2.has_value() );
144 BOOST_TEST( !r2.has_error() );
145
146 BOOST_TEST_EQ( r2.value().v_, 1 );
147
148 BOOST_TEST_EQ( X::instances, 1 );
149 }
150
151 BOOST_TEST_EQ( X::instances, 0 );
152
153 {
154 auto ec = make_error_code( e: errc::invalid_argument );
155
156 result<int> r( ec );
157 result<int> r2( std::move( r ) );
158
159 BOOST_TEST( !r2.has_value() );
160 BOOST_TEST( r2.has_error() );
161
162 BOOST_TEST_EQ( r2.error(), ec );
163 }
164
165 {
166 auto ec = make_error_code( e: errc::invalid_argument );
167
168 result<int> r2( result<int>{ ec } );
169
170 BOOST_TEST( !r2.has_value() );
171 BOOST_TEST( r2.has_error() );
172
173 BOOST_TEST_EQ( r2.error(), ec );
174 }
175
176 BOOST_TEST_EQ( X::instances, 0 );
177
178 {
179 result<std::string, X> r( 1 );
180 result<std::string, X> r2( std::move( r ) );
181
182 BOOST_TEST( !r.has_value() );
183 BOOST_TEST( r.has_error() );
184
185 BOOST_TEST_EQ( r.error().v_, 0 );
186
187 BOOST_TEST( !r2.has_value() );
188 BOOST_TEST( r2.has_error() );
189
190 BOOST_TEST_EQ( r2.error().v_, 1 );
191
192 BOOST_TEST_EQ( X::instances, 2 );
193 }
194
195 BOOST_TEST_EQ( X::instances, 0 );
196
197 {
198 result<std::string, X> r2( result<std::string, X>( 1 ) );
199
200 BOOST_TEST( !r2.has_value() );
201 BOOST_TEST( r2.has_error() );
202
203 BOOST_TEST_EQ( r2.error().v_, 1 );
204
205 BOOST_TEST_EQ( X::instances, 1 );
206 }
207
208 BOOST_TEST_EQ( X::instances, 0 );
209
210 //
211
212 {
213 result<void> r;
214 result<void> r2( std::move( r ) );
215
216 BOOST_TEST( r2.has_value() );
217 BOOST_TEST( !r2.has_error() );
218 }
219
220 {
221 result<void> r2( result<void>{} );
222
223 BOOST_TEST( r2.has_value() );
224 BOOST_TEST( !r2.has_error() );
225 }
226
227 {
228 auto ec = make_error_code( e: errc::invalid_argument );
229
230 result<void> r( ec );
231 result<void> r2( std::move( r ) );
232
233 BOOST_TEST( !r2.has_value() );
234 BOOST_TEST( r2.has_error() );
235
236 BOOST_TEST_EQ( r2.error(), ec );
237 }
238
239 {
240 auto ec = make_error_code( e: errc::invalid_argument );
241
242 result<void> r2( result<void>{ ec } );
243
244 BOOST_TEST( !r2.has_value() );
245 BOOST_TEST( r2.has_error() );
246
247 BOOST_TEST_EQ( r2.error(), ec );
248 }
249
250 //
251
252 {
253 int x1 = 1;
254
255 result<int&> r1( x1 );
256 result<int&> r2( std::move( r1 ) );
257
258 BOOST_TEST( r1.has_value() );
259 BOOST_TEST( !r1.has_error() );
260
261 BOOST_TEST_EQ( r1.value(), 1 );
262 BOOST_TEST_EQ( &*r1, &x1 );
263
264 BOOST_TEST( r2.has_value() );
265 BOOST_TEST( !r2.has_error() );
266
267 BOOST_TEST_EQ( r2.value(), 1 );
268 BOOST_TEST_EQ( &*r2, &x1 );
269 }
270
271 {
272 int const x1 = 1;
273
274 result<int const&> r1( x1 );
275 result<int const&> r2( std::move( r1 ) );
276
277 BOOST_TEST( r1.has_value() );
278 BOOST_TEST( !r1.has_error() );
279
280 BOOST_TEST_EQ( r1.value(), 1 );
281 BOOST_TEST_EQ( &*r1, &x1 );
282
283 BOOST_TEST( r2.has_value() );
284 BOOST_TEST( !r2.has_error() );
285
286 BOOST_TEST_EQ( r2.value(), 1 );
287 BOOST_TEST_EQ( &*r2, &x1 );
288 }
289
290 {
291 int x1 = 1;
292
293 result<int&> r2(( result<int&>( x1 ) ));
294
295 BOOST_TEST( r2.has_value() );
296 BOOST_TEST( !r2.has_error() );
297
298 BOOST_TEST_EQ( r2.value(), 1 );
299 BOOST_TEST_EQ( &*r2, &x1 );
300 }
301
302 {
303 int const x1 = 1;
304
305 result<int const&> r2(( result<int const&>( x1 ) ));
306
307 BOOST_TEST( r2.has_value() );
308 BOOST_TEST( !r2.has_error() );
309
310 BOOST_TEST_EQ( r2.value(), 1 );
311 BOOST_TEST_EQ( &*r2, &x1 );
312 }
313
314 {
315 X x1( 1 );
316
317 result<X&> r1( x1 );
318 result<X&> r2( std::move( r1 ) );
319
320 BOOST_TEST( r1.has_value() );
321 BOOST_TEST( !r1.has_error() );
322
323 BOOST_TEST_EQ( r1.value().v_, 1 );
324 BOOST_TEST_EQ( &*r1, &x1 );
325
326 BOOST_TEST( r2.has_value() );
327 BOOST_TEST( !r2.has_error() );
328
329 BOOST_TEST_EQ( r2.value().v_, 1 );
330 BOOST_TEST_EQ( &*r2, &x1 );
331
332 BOOST_TEST_EQ( X::instances, 1 );
333 }
334
335 BOOST_TEST_EQ( X::instances, 0 );
336
337 {
338 X x1( 1 );
339
340 result<X&> r2(( result<X&>( x1 ) ));
341
342 BOOST_TEST( r2.has_value() );
343 BOOST_TEST( !r2.has_error() );
344
345 BOOST_TEST_EQ( r2.value().v_, 1 );
346 BOOST_TEST_EQ( &*r2, &x1 );
347
348 BOOST_TEST_EQ( X::instances, 1 );
349 }
350
351 BOOST_TEST_EQ( X::instances, 0 );
352
353 {
354 X const x1( 1 );
355
356 result<X const&> r1( x1 );
357 result<X const&> r2( std::move( r1 ) );
358
359 BOOST_TEST( r1.has_value() );
360 BOOST_TEST( !r1.has_error() );
361
362 BOOST_TEST_EQ( r1.value().v_, 1 );
363 BOOST_TEST_EQ( &*r1, &x1 );
364
365 BOOST_TEST( r2.has_value() );
366 BOOST_TEST( !r2.has_error() );
367
368 BOOST_TEST_EQ( r2.value().v_, 1 );
369 BOOST_TEST_EQ( &*r2, &x1 );
370
371 BOOST_TEST_EQ( X::instances, 1 );
372 }
373
374 BOOST_TEST_EQ( X::instances, 0 );
375
376 {
377 X const x1( 1 );
378
379 result<X const&> r2(( result<X const&>( x1 ) ));
380
381 BOOST_TEST( r2.has_value() );
382 BOOST_TEST( !r2.has_error() );
383
384 BOOST_TEST_EQ( r2.value().v_, 1 );
385 BOOST_TEST_EQ( &*r2, &x1 );
386
387 BOOST_TEST_EQ( X::instances, 1 );
388 }
389
390 BOOST_TEST_EQ( X::instances, 0 );
391
392 //
393
394 return boost::report_errors();
395}
396

source code of boost/libs/system/test/result_move_construct.cpp