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 <boost/core/lightweight_test_trait.hpp>
8#include <boost/config.hpp>
9#include <system_error>
10
11using namespace boost::system;
12
13struct X
14{
15 int v_;
16
17 explicit X( int v ): v_( v ) {}
18
19 X( X const& ) = delete;
20 X& operator=( X const& ) = delete;
21};
22
23struct Y
24{
25};
26
27struct E
28{
29};
30
31BOOST_NORETURN void throw_exception_from_error( Y const &, boost::source_location const& )
32{
33 throw E();
34}
35
36struct E2
37{
38};
39
40int main()
41{
42 {
43 result<int> r;
44
45 BOOST_TEST( r.has_value() );
46 BOOST_TEST( !r.has_error() );
47
48 BOOST_TEST( r );
49 BOOST_TEST_NOT( !r );
50
51 BOOST_TEST_EQ( r.value(), 0 );
52 BOOST_TEST_EQ( *r, 0 );
53
54 BOOST_TEST_EQ( r.operator->(), &*r );
55 }
56
57 {
58 result<int> const r;
59
60 BOOST_TEST( r.has_value() );
61 BOOST_TEST( !r.has_error() );
62
63 BOOST_TEST( r );
64 BOOST_TEST_NOT( !r );
65
66 BOOST_TEST_EQ( r.value(), 0 );
67 BOOST_TEST_EQ( *r, 0 );
68
69 BOOST_TEST_EQ( r.operator->(), &*r );
70 }
71
72 {
73 BOOST_TEST( result<int>().has_value() );
74 BOOST_TEST( !result<int>().has_error() );
75
76 BOOST_TEST( result<int>() );
77 BOOST_TEST_NOT( !result<int>() );
78
79 BOOST_TEST_EQ( result<int>().value(), 0 );
80 BOOST_TEST_EQ( *result<int>(), 0 );
81
82 BOOST_TEST( result<int>().operator->() != 0 );
83 }
84
85 {
86 result<int> r( 1 );
87
88 BOOST_TEST( r.has_value() );
89 BOOST_TEST( !r.has_error() );
90
91 BOOST_TEST( r );
92 BOOST_TEST_NOT( !r );
93
94 BOOST_TEST_EQ( r.value(), 1 );
95 BOOST_TEST_EQ( *r, 1 );
96
97 BOOST_TEST_EQ( r.operator->(), &*r );
98 }
99
100 {
101 result<int> const r( 1 );
102
103 BOOST_TEST( r.has_value() );
104 BOOST_TEST( !r.has_error() );
105
106 BOOST_TEST( r );
107 BOOST_TEST_NOT( !r );
108
109 BOOST_TEST_EQ( r.value(), 1 );
110 BOOST_TEST_EQ( *r, 1 );
111
112 BOOST_TEST_EQ( r.operator->(), &*r );
113 }
114
115 {
116 BOOST_TEST( result<int>( 1 ).has_value() );
117 BOOST_TEST( !result<int>( 1 ).has_error() );
118
119 BOOST_TEST( result<int>( 1 ) );
120 BOOST_TEST_NOT( !result<int>( 1 ) );
121
122 BOOST_TEST_EQ( result<int>( 1 ).value(), 1 );
123 BOOST_TEST_EQ( *result<int>( 1 ), 1 );
124
125 BOOST_TEST( result<int>( 1 ).operator->() != 0 );
126 }
127
128 {
129 auto ec = make_error_code( e: errc::invalid_argument );
130
131 result<int> r( ec );
132
133 BOOST_TEST( !r.has_value() );
134 BOOST_TEST( r.has_error() );
135
136 BOOST_TEST_NOT( r );
137 BOOST_TEST( !r );
138
139 BOOST_TEST_THROWS( r.value(), system_error );
140
141 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
142 }
143
144 {
145 auto ec = make_error_code( e: errc::invalid_argument );
146
147 result<int> const r( ec );
148
149 BOOST_TEST( !r.has_value() );
150 BOOST_TEST( r.has_error() );
151
152 BOOST_TEST_NOT( r );
153 BOOST_TEST( !r );
154
155 BOOST_TEST_THROWS( r.value(), system_error );
156
157 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
158 }
159
160 {
161 auto ec = make_error_code( e: errc::invalid_argument );
162
163 BOOST_TEST( !result<int>( ec ).has_value() );
164 BOOST_TEST( result<int>( ec ).has_error() );
165
166 BOOST_TEST_NOT( result<int>( ec ) );
167 BOOST_TEST( !result<int>( ec ) );
168
169 BOOST_TEST_THROWS( result<int>( ec ).value(), system_error );
170
171 BOOST_TEST_EQ( result<int>( ec ).operator->(), static_cast<int*>(0) );
172 }
173
174 {
175 auto ec = make_error_code( e: std::errc::invalid_argument );
176
177 result<int, std::error_code> const r( ec );
178
179 BOOST_TEST( !r.has_value() );
180 BOOST_TEST( r.has_error() );
181
182 BOOST_TEST_NOT( r );
183 BOOST_TEST( !r );
184
185 BOOST_TEST_THROWS( r.value(), std::system_error );
186
187 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
188 }
189
190 {
191 result<int, errc::errc_t> const r( in_place_error, errc::invalid_argument );
192
193 BOOST_TEST( !r.has_value() );
194 BOOST_TEST( r.has_error() );
195
196 BOOST_TEST_NOT( r );
197 BOOST_TEST( !r );
198
199 BOOST_TEST_THROWS( r.value(), system_error );
200
201 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
202 }
203
204 {
205 result<int, std::errc> const r( std::errc::invalid_argument );
206
207 BOOST_TEST( !r.has_value() );
208 BOOST_TEST( r.has_error() );
209
210 BOOST_TEST_NOT( r );
211 BOOST_TEST( !r );
212
213 BOOST_TEST_THROWS( r.value(), std::system_error );
214
215 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
216 }
217
218 {
219 result<int, std::exception_ptr> const r( std::make_exception_ptr( ex: E2() ) );
220
221 BOOST_TEST( !r.has_value() );
222 BOOST_TEST( r.has_error() );
223
224 BOOST_TEST_NOT( r );
225 BOOST_TEST( !r );
226
227#if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
228#else
229 BOOST_TEST_THROWS( r.value(), E2 );
230#endif
231
232 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
233 }
234
235 {
236 result<int, std::exception_ptr> const r( in_place_error );
237
238 BOOST_TEST( !r.has_value() );
239 BOOST_TEST( r.has_error() );
240
241 BOOST_TEST_NOT( r );
242 BOOST_TEST( !r );
243
244 BOOST_TEST_THROWS( r.value(), std::bad_exception );
245
246 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
247 }
248
249 {
250 result<X> r( 1 );
251
252 BOOST_TEST( r.has_value() );
253 BOOST_TEST( !r.has_error() );
254
255 BOOST_TEST( r );
256 BOOST_TEST_NOT( !r );
257
258 BOOST_TEST_EQ( r.value().v_, 1 );
259 BOOST_TEST_EQ( (*r).v_, 1 );
260 BOOST_TEST_EQ( r->v_, 1 );
261
262 BOOST_TEST_EQ( r.operator->(), &*r );
263 }
264
265 {
266 result<X> const r( 1 );
267
268 BOOST_TEST( r.has_value() );
269 BOOST_TEST( !r.has_error() );
270
271 BOOST_TEST( r );
272 BOOST_TEST_NOT( !r );
273
274 BOOST_TEST_EQ( r.value().v_, 1 );
275 BOOST_TEST_EQ( (*r).v_, 1 );
276 BOOST_TEST_EQ( r->v_, 1 );
277
278 BOOST_TEST_EQ( r.operator->(), &*r );
279 }
280
281 {
282 BOOST_TEST( result<X>( 1 ).has_value() );
283 BOOST_TEST( !result<X>( 1 ).has_error() );
284
285 BOOST_TEST( result<X>( 1 ) );
286 BOOST_TEST_NOT( !result<X>( 1 ) );
287
288 BOOST_TEST_EQ( result<X>( 1 ).value().v_, 1 );
289 BOOST_TEST_EQ( (*result<X>( 1 )).v_, 1 );
290 BOOST_TEST_EQ( result<X>( 1 )->v_, 1 );
291 }
292
293 {
294 auto ec = Y();
295
296 result<X, Y> r( ec );
297
298 BOOST_TEST( !r.has_value() );
299 BOOST_TEST( r.has_error() );
300
301 BOOST_TEST_NOT( r );
302 BOOST_TEST( !r );
303
304 BOOST_TEST_THROWS( r.value(), E );
305
306 BOOST_TEST_EQ( r.operator->(), static_cast<X*>(0) );
307 }
308
309 {
310 auto ec = Y();
311
312 result<X, Y> const r( ec );
313
314 BOOST_TEST( !r.has_value() );
315 BOOST_TEST( r.has_error() );
316
317 BOOST_TEST_NOT( r );
318 BOOST_TEST( !r );
319
320 BOOST_TEST_THROWS( r.value(), E );
321
322 BOOST_TEST_EQ( r.operator->(), static_cast<X*>(0) );
323 }
324
325 {
326 auto ec = Y();
327
328 BOOST_TEST(( !result<X, Y>( ec ).has_value() ));
329 BOOST_TEST(( result<X, Y>( ec ).has_error() ));
330
331 BOOST_TEST_NOT(( result<X, Y>( ec ) ));
332 BOOST_TEST(( !result<X, Y>( ec ) ));
333
334 BOOST_TEST_THROWS( (result<X, Y>( ec ).value()), E );
335
336 BOOST_TEST_EQ( (result<X, Y>( ec ).operator->()), static_cast<X*>(0) );
337 }
338
339 //
340
341 {
342 result<void> r;
343
344 BOOST_TEST( r.has_value() );
345 BOOST_TEST( !r.has_error() );
346
347 BOOST_TEST( r );
348 BOOST_TEST_NOT( !r );
349
350 BOOST_TEST_NO_THROW( r.value() );
351
352 BOOST_TEST( r.operator->() != 0 );
353 }
354
355 {
356 result<void> const r;
357
358 BOOST_TEST( r.has_value() );
359 BOOST_TEST( !r.has_error() );
360
361 BOOST_TEST( r );
362 BOOST_TEST_NOT( !r );
363
364 BOOST_TEST_NO_THROW( r.value() );
365
366 BOOST_TEST( r.operator->() != 0 );
367 }
368
369 {
370 BOOST_TEST( result<void>().has_value() );
371 BOOST_TEST( !result<void>().has_error() );
372
373 BOOST_TEST( result<void>() );
374 BOOST_TEST_NOT( !result<void>() );
375
376 BOOST_TEST_NO_THROW( result<void>().value() );
377
378 BOOST_TEST( result<void>().operator->() != 0 );
379 }
380
381 {
382 auto ec = make_error_code( e: errc::invalid_argument );
383
384 result<void> r( ec );
385
386 BOOST_TEST( !r.has_value() );
387 BOOST_TEST( r.has_error() );
388
389 BOOST_TEST_NOT( r );
390 BOOST_TEST( !r );
391
392 BOOST_TEST_THROWS( r.value(), system_error );
393
394 BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
395 }
396
397 {
398 auto ec = make_error_code( e: errc::invalid_argument );
399
400 result<void> const r( ec );
401
402 BOOST_TEST( !r.has_value() );
403 BOOST_TEST( r.has_error() );
404
405 BOOST_TEST_NOT( r );
406 BOOST_TEST( !r );
407
408 BOOST_TEST_THROWS( r.value(), system_error );
409
410 BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
411 }
412
413 {
414 auto ec = make_error_code( e: errc::invalid_argument );
415
416 BOOST_TEST( !result<void>( ec ).has_value() );
417 BOOST_TEST( result<void>( ec ).has_error() );
418
419 BOOST_TEST_NOT( result<void>( ec ) );
420 BOOST_TEST( !result<void>( ec ) );
421
422 BOOST_TEST_THROWS( result<void>( ec ).value(), system_error );
423
424 BOOST_TEST_EQ( result<void>( ec ).operator->(), static_cast<void*>(0) );
425 }
426
427 {
428 auto ec = make_error_code( e: std::errc::invalid_argument );
429
430 result<void, std::error_code> const r( ec );
431
432 BOOST_TEST( !r.has_value() );
433 BOOST_TEST( r.has_error() );
434
435 BOOST_TEST_NOT( r );
436 BOOST_TEST( !r );
437
438 BOOST_TEST_THROWS( r.value(), std::system_error );
439
440 BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
441 }
442
443 {
444 result<void, errc::errc_t> const r( in_place_error, errc::invalid_argument );
445
446 BOOST_TEST( !r.has_value() );
447 BOOST_TEST( r.has_error() );
448
449 BOOST_TEST_NOT( r );
450 BOOST_TEST( !r );
451
452 BOOST_TEST_THROWS( r.value(), system_error );
453
454 BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
455 }
456
457 {
458 result<void, std::errc> const r( std::errc::invalid_argument );
459
460 BOOST_TEST( !r.has_value() );
461 BOOST_TEST( r.has_error() );
462
463 BOOST_TEST_NOT( r );
464 BOOST_TEST( !r );
465
466 BOOST_TEST_THROWS( r.value(), std::system_error );
467
468 BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
469 }
470
471 {
472 result<void, std::exception_ptr> const r( std::make_exception_ptr( ex: E2() ) );
473
474 BOOST_TEST( !r.has_value() );
475 BOOST_TEST( r.has_error() );
476
477 BOOST_TEST_NOT( r );
478 BOOST_TEST( !r );
479
480#if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
481#else
482 BOOST_TEST_THROWS( r.value(), E2 );
483#endif
484
485 BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
486 }
487
488 {
489 result<void, std::exception_ptr> const r( in_place_error );
490
491 BOOST_TEST( !r.has_value() );
492 BOOST_TEST( r.has_error() );
493
494 BOOST_TEST_NOT( r );
495 BOOST_TEST( !r );
496
497 BOOST_TEST_THROWS( r.value(), std::bad_exception );
498
499 BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
500 }
501
502 //
503
504 {
505 int x1 = 1;
506
507 result<int&> r( x1 );
508
509 BOOST_TEST( r.has_value() );
510 BOOST_TEST( !r.has_error() );
511
512 BOOST_TEST( r );
513 BOOST_TEST_NOT( !r );
514
515 BOOST_TEST_EQ( r.value(), 1 );
516 BOOST_TEST_EQ( *r, 1 );
517
518 BOOST_TEST_EQ( r.operator->(), &*r );
519 }
520
521 {
522 int x1 = 1;
523
524 result<int&> const r( x1 );
525
526 BOOST_TEST( r.has_value() );
527 BOOST_TEST( !r.has_error() );
528
529 BOOST_TEST( r );
530 BOOST_TEST_NOT( !r );
531
532 BOOST_TEST_EQ( r.value(), 1 );
533 BOOST_TEST_EQ( *r, 1 );
534
535 BOOST_TEST_EQ( r.operator->(), &*r );
536 }
537
538 {
539 int x1 = 1;
540
541 BOOST_TEST( result<int&>( x1 ).has_value() );
542 BOOST_TEST( !result<int&>( x1 ).has_error() );
543
544 BOOST_TEST( result<int&>( x1 ) );
545 BOOST_TEST_NOT( !result<int&>( x1 ) );
546
547 BOOST_TEST_EQ( result<int&>( x1 ).value(), 1 );
548 BOOST_TEST_EQ( *result<int&>( x1 ), 1 );
549
550 BOOST_TEST_EQ( result<int&>( x1 ).operator->(), &x1 );
551 }
552
553 {
554 auto ec = make_error_code( e: errc::invalid_argument );
555
556 result<int&> r( ec );
557
558 BOOST_TEST( !r.has_value() );
559 BOOST_TEST( r.has_error() );
560
561 BOOST_TEST_NOT( r );
562 BOOST_TEST( !r );
563
564 BOOST_TEST_THROWS( r.value(), system_error );
565
566 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
567 }
568
569 {
570 auto ec = make_error_code( e: errc::invalid_argument );
571
572 result<int&> const r( ec );
573
574 BOOST_TEST( !r.has_value() );
575 BOOST_TEST( r.has_error() );
576
577 BOOST_TEST_NOT( r );
578 BOOST_TEST( !r );
579
580 BOOST_TEST_THROWS( r.value(), system_error );
581
582 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
583 }
584
585 {
586 auto ec = make_error_code( e: errc::invalid_argument );
587
588 BOOST_TEST( !result<int&>( ec ).has_value() );
589 BOOST_TEST( result<int&>( ec ).has_error() );
590
591 BOOST_TEST_NOT( result<int&>( ec ) );
592 BOOST_TEST( !result<int&>( ec ) );
593
594 BOOST_TEST_THROWS( result<int&>( ec ).value(), system_error );
595
596 BOOST_TEST_EQ( result<int&>( ec ).operator->(), static_cast<int*>(0) );
597 }
598
599 {
600 auto ec = make_error_code( e: std::errc::invalid_argument );
601
602 result<int&, std::error_code> const r( ec );
603
604 BOOST_TEST( !r.has_value() );
605 BOOST_TEST( r.has_error() );
606
607 BOOST_TEST_NOT( r );
608 BOOST_TEST( !r );
609
610 BOOST_TEST_THROWS( r.value(), std::system_error );
611
612 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
613 }
614
615 {
616 result<int&, errc::errc_t> const r( in_place_error, errc::invalid_argument );
617
618 BOOST_TEST( !r.has_value() );
619 BOOST_TEST( r.has_error() );
620
621 BOOST_TEST_NOT( r );
622 BOOST_TEST( !r );
623
624 BOOST_TEST_THROWS( r.value(), system_error );
625
626 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
627 }
628
629 {
630 result<int&, std::errc> const r( std::errc::invalid_argument );
631
632 BOOST_TEST( !r.has_value() );
633 BOOST_TEST( r.has_error() );
634
635 BOOST_TEST_NOT( r );
636 BOOST_TEST( !r );
637
638 BOOST_TEST_THROWS( r.value(), std::system_error );
639
640 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
641 }
642
643 {
644 result<int&, std::exception_ptr> const r( std::make_exception_ptr( ex: E2() ) );
645
646 BOOST_TEST( !r.has_value() );
647 BOOST_TEST( r.has_error() );
648
649 BOOST_TEST_NOT( r );
650 BOOST_TEST( !r );
651
652#if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
653#else
654 BOOST_TEST_THROWS( r.value(), E2 );
655#endif
656
657 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
658 }
659
660 {
661 result<int&, std::exception_ptr> const r( in_place_error );
662
663 BOOST_TEST( !r.has_value() );
664 BOOST_TEST( r.has_error() );
665
666 BOOST_TEST_NOT( r );
667 BOOST_TEST( !r );
668
669 BOOST_TEST_THROWS( r.value(), std::bad_exception );
670
671 BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
672 }
673
674 //
675
676 return boost::report_errors();
677}
678

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