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 | |
11 | using namespace boost::system; |
12 | |
13 | struct 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 | |
23 | struct Y |
24 | { |
25 | }; |
26 | |
27 | struct E |
28 | { |
29 | }; |
30 | |
31 | BOOST_NORETURN void throw_exception_from_error( Y const &, boost::source_location const& ) |
32 | { |
33 | throw E(); |
34 | } |
35 | |
36 | struct E2 |
37 | { |
38 | }; |
39 | |
40 | int 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 | |