1// Copyright 2018-2023 Emil Dotchevski and Reverge Studios, Inc.
2
3// Distributed under the Boost Software License, Version 1.0. (See accompanying
4// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5
6#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
7# include "leaf.hpp"
8#else
9# include <boost/leaf/handle_errors.hpp>
10# include <boost/leaf/pred.hpp>
11# include <boost/leaf/result.hpp>
12#endif
13
14#include "_test_ec.hpp"
15#include "lightweight_test.hpp"
16
17namespace leaf = boost::leaf;
18
19template <int> struct info { int value; };
20
21enum class my_error_code
22{
23 ok,
24 error1,
25 error2,
26 error3
27};
28
29struct e_my_error_code { my_error_code value; };
30
31#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
32struct e_std_error_code { std::error_code value; };
33#endif
34
35template <class R>
36leaf::result<R> f( my_error_code ec )
37{
38 if( ec==my_error_code::ok )
39 return R(42);
40 else
41 return leaf::new_error(item&: ec, item: e_my_error_code{.value: ec}, item: info<1>{.value: 1}, item: info<2>{.value: 2}, item: info<3>{.value: 3});
42}
43
44#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
45template <class R, class Errc>
46leaf::result<R> f_errc( Errc ec )
47{
48 return leaf::new_error(make_error_code(ec), info<1>{.value: 1}, info<2>{.value: 2}, info<3>{.value: 3});
49}
50
51template <class R, class Errc>
52leaf::result<R> f_errc_wrapped( Errc ec )
53{
54 return leaf::new_error(item: e_std_error_code{make_error_code(ec)}, item: info<1>{.value: 1}, item: info<2>{.value: 2}, item: info<3>{.value: 3});
55}
56#endif
57
58int main()
59{
60 // void, try_handle_some (success)
61 {
62 int c=0;
63 leaf::result<void> r = leaf::try_handle_some(
64 try_block: [&c]() -> leaf::result<void>
65 {
66 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::ok));
67 c = answer;
68 return { };
69 },
70 h: [&c]( leaf::error_info const & unmatched )
71 {
72 BOOST_TEST_EQ(c, 0);
73 c = 1;
74 return unmatched.error();
75 } );
76 BOOST_TEST(r);
77 BOOST_TEST_EQ(c, 42);
78 }
79
80 // void, try_handle_some (failure, matched)
81 {
82 int c=0;
83 leaf::result<void> r = leaf::try_handle_some(
84 try_block: [&c]() -> leaf::result<void>
85 {
86 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
87 c = answer;
88 return { };
89 },
90 h: [&c]( my_error_code ec, info<1> const & x, info<2> y )
91 {
92 BOOST_TEST(ec==my_error_code::error1);
93 BOOST_TEST_EQ(x.value, 1);
94 BOOST_TEST_EQ(y.value, 2);
95 BOOST_TEST_EQ(c, 0);
96 c = 1;
97 } );
98 BOOST_TEST_EQ(c, 1);
99 BOOST_TEST(r);
100 }
101
102#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
103 // void, try_handle_some (failure, matched), match cond_x (single enum value)
104 {
105 int c=0;
106 leaf::result<void> r = leaf::try_handle_some(
107 try_block: [&c]() -> leaf::result<void>
108 {
109 BOOST_LEAF_AUTO(answer, f_errc<int>(errc_a::a0));
110 c = answer;
111 return { };
112 },
113 h: [&c]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> const & y )
114 {
115 BOOST_TEST_EQ(ec.matched, make_error_code(errc_a::a0));
116 BOOST_TEST_EQ(x.value, 1);
117 BOOST_TEST_EQ(y.value, 2);
118 BOOST_TEST_EQ(c, 0);
119 c = 1;
120 } );
121 BOOST_TEST_EQ(c, 1);
122 BOOST_TEST(r);
123 }
124#endif
125
126#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
127 // void, try_handle_some (failure, matched), match cond_x (wrapped std::error_code)
128 {
129 int c=0;
130 leaf::result<void> r = leaf::try_handle_some(
131 try_block: [&c]() -> leaf::result<void>
132 {
133 BOOST_LEAF_AUTO(answer, f_errc_wrapped<int>(errc_a::a0));
134 c = answer;
135 return { };
136 },
137 h: [&c]( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x00> ec, info<1> const & x, info<2> const & y )
138 {
139 BOOST_TEST_EQ(ec.matched.value, make_error_code(errc_a::a0));
140 BOOST_TEST_EQ(x.value, 1);
141 BOOST_TEST_EQ(y.value, 2);
142 BOOST_TEST_EQ(c, 0);
143 c = 1;
144 } );
145 BOOST_TEST_EQ(c, 1);
146 BOOST_TEST(r);
147 }
148#endif
149
150 // void, try_handle_some (failure, matched), match enum (single enum value)
151 {
152 int c=0;
153 leaf::result<void> r = leaf::try_handle_some(
154 try_block: [&c]() -> leaf::result<void>
155 {
156 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
157 c = answer;
158 return { };
159 },
160 h: [&c]( leaf::match<my_error_code, my_error_code::error2> )
161 {
162 BOOST_TEST_EQ(c, 0);
163 c = 1;
164 },
165 h: [&c]( leaf::match<my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
166 {
167 BOOST_TEST(ec.matched==my_error_code::error1);
168 BOOST_TEST_EQ(x.value, 1);
169 BOOST_TEST_EQ(y.value, 2);
170 BOOST_TEST_EQ(c, 0);
171 c = 2;
172 } );
173 BOOST_TEST_EQ(c, 2);
174 BOOST_TEST(r);
175 }
176
177 // void, try_handle_some (failure, matched), match enum (multiple enum values)
178 {
179 int c=0;
180 leaf::result<void> r = leaf::try_handle_some(
181 try_block: [&c]() -> leaf::result<void>
182 {
183 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
184 c = answer;
185 return { };
186 },
187 h: [&c]( leaf::match<my_error_code, my_error_code::error2> )
188 {
189 BOOST_TEST_EQ(c, 0);
190 c = 1;
191 },
192 h: [&c]( leaf::match<my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
193 {
194 BOOST_TEST(ec.matched==my_error_code::error1);
195 BOOST_TEST_EQ(x.value, 1);
196 BOOST_TEST_EQ(y.value, 2);
197 BOOST_TEST_EQ(c, 0);
198 c = 2;
199 } );
200 BOOST_TEST_EQ(c, 2);
201 BOOST_TEST(r);
202 }
203
204 // void, try_handle_some (failure, matched), match value (single value)
205 {
206 int c=0;
207 leaf::result<void> r = leaf::try_handle_some(
208 try_block: [&c]() -> leaf::result<void>
209 {
210 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
211 c = answer;
212 return { };
213 },
214 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error2> )
215 {
216 BOOST_TEST_EQ(c, 0);
217 c = 1;
218 },
219 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
220 {
221 BOOST_TEST(ec.matched.value==my_error_code::error1);
222 BOOST_TEST_EQ(x.value, 1);
223 BOOST_TEST_EQ(y.value, 2);
224 BOOST_TEST_EQ(c, 0);
225 c = 2;
226 } );
227 BOOST_TEST_EQ(c, 2);
228 BOOST_TEST(r);
229 }
230
231 // void, try_handle_some (failure, matched), match value (multiple values)
232 {
233 int c=0;
234 leaf::result<void> r = leaf::try_handle_some(
235 try_block: [&c]() -> leaf::result<void>
236 {
237 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
238 c = answer;
239 return { };
240 },
241 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error2> )
242 {
243 BOOST_TEST_EQ(c, 0);
244 c = 1;
245 },
246 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
247 {
248 BOOST_TEST(ec.matched.value==my_error_code::error1);
249 BOOST_TEST_EQ(x.value, 1);
250 BOOST_TEST_EQ(y.value, 2);
251 BOOST_TEST_EQ(c, 0);
252 c = 2;
253 } );
254 BOOST_TEST_EQ(c, 2);
255 BOOST_TEST(r);
256 }
257
258 // void, try_handle_some (failure, initially not matched)
259 {
260 int c=0;
261 leaf::try_handle_all(
262 try_block: [&c]
263 {
264 leaf::result<void> r = leaf::try_handle_some(
265 try_block: [&c]() -> leaf::result<void>
266 {
267 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
268 c = answer;
269 return { };
270 },
271 h: [&c]( info<4> )
272 {
273 BOOST_TEST_EQ(c, 0);
274 c = 1;
275 } );
276 BOOST_TEST(!r);
277 BOOST_TEST_EQ(c, 0);
278 return r;
279 },
280 h: [&c]( my_error_code ec, info<1> const & x, info<2> y )
281 {
282 BOOST_TEST(ec==my_error_code::error1);
283 BOOST_TEST_EQ(x.value, 1);
284 BOOST_TEST_EQ(y.value, 2);
285 BOOST_TEST_EQ(c, 0);
286 c = 2;
287 },
288 h: [&c]
289 {
290 BOOST_TEST_EQ(c, 0);
291 c = 3;
292 } );
293 BOOST_TEST_EQ(c, 2);
294 }
295
296#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
297 // void, try_handle_some (failure, initially not matched), match cond_x (single enum value)
298 {
299 int c=0;
300 leaf::try_handle_all(
301 try_block: [&c]
302 {
303 leaf::result<void> r = leaf::try_handle_some(
304 try_block: [&c]() -> leaf::result<void>
305 {
306 BOOST_LEAF_AUTO(answer, f_errc<int>(errc_a::a0));
307 c = answer;
308 return { };
309 },
310 h: [&c]( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
311 {
312 BOOST_TEST_EQ(c, 0);
313 c = 1;
314 } );
315 BOOST_TEST(!r);
316 BOOST_TEST_EQ(c, 0);
317 return r;
318 },
319 h: [&c]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
320 {
321 BOOST_TEST_EQ(ec.matched, make_error_code(errc_a::a0));
322 BOOST_TEST_EQ(x.value, 1);
323 BOOST_TEST_EQ(y.value, 2);
324 BOOST_TEST_EQ(c, 0);
325 c = 2;
326 },
327 h: [&c]
328 {
329 BOOST_TEST_EQ(c, 0);
330 c = 3;
331 } );
332 BOOST_TEST_EQ(c, 2);
333 }
334#endif
335
336#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
337 // void, try_handle_some (failure, initially not matched), match cond_x (wrapped std::error_code)
338 {
339 int c=0;
340 leaf::try_handle_all(
341 try_block: [&c]
342 {
343 leaf::result<void> r = leaf::try_handle_some(
344 try_block: [&c]() -> leaf::result<void>
345 {
346 BOOST_LEAF_AUTO(answer, f_errc_wrapped<int>(errc_a::a0));
347 c = answer;
348 return { };
349 },
350 h: [&c]( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x11> )
351 {
352 BOOST_TEST_EQ(c, 0);
353 c = 1;
354 } );
355 BOOST_TEST(!r);
356 BOOST_TEST_EQ(c, 0);
357 return r;
358 },
359 h: [&c]( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
360 {
361 BOOST_TEST_EQ(ec.matched.value, make_error_code(errc_a::a0));
362 BOOST_TEST_EQ(x.value, 1);
363 BOOST_TEST_EQ(y.value, 2);
364 BOOST_TEST_EQ(c, 0);
365 c = 2;
366 },
367 h: [&c]
368 {
369 BOOST_TEST_EQ(c, 0);
370 c = 3;
371 } );
372 BOOST_TEST_EQ(c, 2);
373 }
374#endif
375
376 // void, try_handle_some (failure, initially not matched), match enum (single enum value)
377 {
378 int c=0;
379 leaf::try_handle_all(
380 try_block: [&c]
381 {
382 leaf::result<void> r = leaf::try_handle_some(
383 try_block: [&c]() -> leaf::result<void>
384 {
385 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
386 c = answer;
387 return { };
388 },
389 h: [&c]( leaf::match<my_error_code, my_error_code::error2> )
390 {
391 BOOST_TEST_EQ(c, 0);
392 c = 1;
393 } );
394 BOOST_TEST(!r);
395 BOOST_TEST_EQ(c, 0);
396 return r;
397 },
398 h: [&c]( leaf::match<my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
399 {
400 BOOST_TEST(ec.matched==my_error_code::error1);
401 BOOST_TEST_EQ(x.value, 1);
402 BOOST_TEST_EQ(y.value, 2);
403 BOOST_TEST_EQ(c, 0);
404 c = 2;
405 },
406 h: [&c]
407 {
408 BOOST_TEST_EQ(c, 0);
409 c = 3;
410 } );
411 BOOST_TEST_EQ(c, 2);
412 }
413
414 // void, try_handle_some (failure, initially not matched), match enum (multiple enum values)
415 {
416 int c=0;
417 leaf::try_handle_all(
418 try_block: [&c]
419 {
420 leaf::result<void> r = leaf::try_handle_some(
421 try_block: [&c]() -> leaf::result<void>
422 {
423 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
424 c = answer;
425 return { };
426 },
427 h: [&c]( leaf::match<my_error_code, my_error_code::error2> )
428 {
429 BOOST_TEST_EQ(c, 0);
430 c = 1;
431 } );
432 BOOST_TEST(!r);
433 BOOST_TEST_EQ(c, 0);
434 return r;
435 },
436 h: [&c]( leaf::match<my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
437 {
438 BOOST_TEST(ec.matched==my_error_code::error1);
439 BOOST_TEST_EQ(x.value, 1);
440 BOOST_TEST_EQ(y.value, 2);
441 BOOST_TEST_EQ(c, 0);
442 c = 2;
443 },
444 h: [&c]
445 {
446 BOOST_TEST_EQ(c, 0);
447 c = 3;
448 } );
449 BOOST_TEST_EQ(c, 2);
450 }
451
452 // void, try_handle_some (failure, initially not matched), match value (single value)
453 {
454 int c=0;
455 leaf::try_handle_all(
456 try_block: [&c]
457 {
458 leaf::result<void> r = leaf::try_handle_some(
459 try_block: [&c]() -> leaf::result<void>
460 {
461 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
462 c = answer;
463 return { };
464 },
465 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error2> )
466 {
467 BOOST_TEST_EQ(c, 0);
468 c = 1;
469 } );
470 BOOST_TEST(!r);
471 BOOST_TEST_EQ(c, 0);
472 return r;
473 },
474 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
475 {
476 BOOST_TEST(ec.matched.value==my_error_code::error1);
477 BOOST_TEST_EQ(x.value, 1);
478 BOOST_TEST_EQ(y.value, 2);
479 BOOST_TEST_EQ(c, 0);
480 c = 2;
481 },
482 h: [&c]
483 {
484 BOOST_TEST_EQ(c, 0);
485 c = 3;
486 } );
487 BOOST_TEST_EQ(c, 2);
488 }
489
490 // void, try_handle_some (failure, initially not matched), match value (multiple values)
491 {
492 int c=0;
493 leaf::try_handle_all(
494 try_block: [&c]
495 {
496 leaf::result<void> r = leaf::try_handle_some(
497 try_block: [&c]() -> leaf::result<void>
498 {
499 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
500 c = answer;
501 return { };
502 },
503 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error2> )
504 {
505 BOOST_TEST_EQ(c, 0);
506 c = 1;
507 } );
508 BOOST_TEST(!r);
509 BOOST_TEST_EQ(c, 0);
510 return r;
511 },
512 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
513 {
514 BOOST_TEST(ec.matched.value==my_error_code::error1);
515 BOOST_TEST_EQ(x.value, 1);
516 BOOST_TEST_EQ(y.value, 2);
517 BOOST_TEST_EQ(c, 0);
518 c = 2;
519 },
520 h: [&c]
521 {
522 BOOST_TEST_EQ(c, 0);
523 c = 3;
524 } );
525 BOOST_TEST_EQ(c, 2);
526 }
527
528 // void, try_handle_some (failure, initially matched)
529 {
530 int c=0;
531 leaf::try_handle_all(
532 try_block: [&c]
533 {
534 leaf::result<void> r = leaf::try_handle_some(
535 try_block: [&c]() -> leaf::result<void>
536 {
537 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
538 c = answer;
539 return { };
540 },
541 h: [&c]( my_error_code ec, info<1> const & x, info<2> y )
542 {
543 BOOST_TEST(ec==my_error_code::error1);
544 BOOST_TEST_EQ(x.value, 1);
545 BOOST_TEST_EQ(y.value, 2);
546 BOOST_TEST_EQ(c, 0);
547 c = 1;
548 } );
549 BOOST_TEST(r);
550 BOOST_TEST_EQ(c, 1);
551 return r;
552 },
553 h: [&c]( info<4> )
554 {
555 BOOST_TEST_EQ(c, 0);
556 c = 2;
557 },
558 h: [&c]
559 {
560 BOOST_TEST_EQ(c, 0);
561 c = 3;
562 } );
563 BOOST_TEST_EQ(c, 1);
564 }
565
566#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
567 // void, try_handle_some (failure, initially matched), match cond_x (single enum value)
568 {
569 int c=0;
570 leaf::try_handle_all(
571 try_block: [&c]
572 {
573 leaf::result<void> r = leaf::try_handle_some(
574 try_block: [&c]() -> leaf::result<void>
575 {
576 BOOST_LEAF_AUTO(answer, f_errc<int>(errc_a::a0));
577 c = answer;
578 return { };
579 },
580 h: [&c]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
581 {
582 BOOST_TEST_EQ(ec.matched, make_error_code(errc_a::a0));
583 BOOST_TEST_EQ(x.value, 1);
584 BOOST_TEST_EQ(y.value, 2);
585 BOOST_TEST_EQ(c, 0);
586 c = 1;
587 } );
588 BOOST_TEST(r);
589 BOOST_TEST_EQ(c, 1);
590 return r;
591 },
592 h: [&c]( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
593 {
594 BOOST_TEST_EQ(c, 0);
595 c = 2;
596 },
597 h: [&c]
598 {
599 BOOST_TEST_EQ(c, 0);
600 c = 3;
601 } );
602 BOOST_TEST_EQ(c, 1);
603 }
604#endif
605
606#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
607 // void, try_handle_some (failure, initially matched), match cond_x (wrapped std::error_code)
608 {
609 int c=0;
610 leaf::try_handle_all(
611 try_block: [&c]
612 {
613 leaf::result<void> r = leaf::try_handle_some(
614 try_block: [&c]() -> leaf::result<void>
615 {
616 BOOST_LEAF_AUTO(answer, f_errc_wrapped<int>(errc_a::a0));
617 c = answer;
618 return { };
619 },
620 h: [&c]( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
621 {
622 BOOST_TEST_EQ(ec.matched.value, make_error_code(errc_a::a0));
623 BOOST_TEST_EQ(x.value, 1);
624 BOOST_TEST_EQ(y.value, 2);
625 BOOST_TEST_EQ(c, 0);
626 c = 1;
627 } );
628 BOOST_TEST(r);
629 BOOST_TEST_EQ(c, 1);
630 return r;
631 },
632 h: [&c]( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x11> )
633 {
634 BOOST_TEST_EQ(c, 0);
635 c = 2;
636 },
637 h: [&c]
638 {
639 BOOST_TEST_EQ(c, 0);
640 c = 3;
641 } );
642 BOOST_TEST_EQ(c, 1);
643 }
644#endif
645
646 // void, try_handle_some (failure, initially matched), match enum (single enum value)
647 {
648 int c=0;
649 leaf::try_handle_all(
650 try_block: [&c]
651 {
652 leaf::result<void> r = leaf::try_handle_some(
653 try_block: [&c]() -> leaf::result<void>
654 {
655 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
656 c = answer;
657 return { };
658 },
659 h: [&c]( leaf::match<my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
660 {
661 BOOST_TEST(ec.matched==my_error_code::error1);
662 BOOST_TEST_EQ(x.value, 1);
663 BOOST_TEST_EQ(y.value, 2);
664 BOOST_TEST_EQ(c, 0);
665 c = 1;
666 } );
667 BOOST_TEST(r);
668 BOOST_TEST_EQ(c, 1);
669 return r;
670 },
671 h: [&c]( leaf::match<my_error_code, my_error_code::error2> )
672 {
673 BOOST_TEST_EQ(c, 0);
674 c = 2;
675 },
676 h: [&c]
677 {
678 BOOST_TEST_EQ(c, 0);
679 c = 3;
680 } );
681 BOOST_TEST_EQ(c, 1);
682 }
683
684 // void, try_handle_some (failure, initially matched), match enum (multiple enum values)
685 {
686 int c=0;
687 leaf::try_handle_all(
688 try_block: [&c]
689 {
690 leaf::result<void> r = leaf::try_handle_some(
691 try_block: [&c]() -> leaf::result<void>
692 {
693 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
694 c = answer;
695 return { };
696 },
697 h: [&c]( leaf::match<my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
698 {
699 BOOST_TEST(ec.matched==my_error_code::error1);
700 BOOST_TEST_EQ(x.value, 1);
701 BOOST_TEST_EQ(y.value, 2);
702 BOOST_TEST_EQ(c, 0);
703 c = 1;
704 } );
705 BOOST_TEST(r);
706 BOOST_TEST_EQ(c, 1);
707 return r;
708 },
709 h: [&c]( leaf::match<my_error_code, my_error_code::error2> )
710 {
711 BOOST_TEST_EQ(c, 0);
712 c = 2;
713 },
714 h: [&c]
715 {
716 BOOST_TEST_EQ(c, 0);
717 c = 3;
718 } );
719 BOOST_TEST_EQ(c, 1);
720 }
721
722 // void, try_handle_some (failure, initially matched), match value (single value)
723 {
724 int c=0;
725 leaf::try_handle_all(
726 try_block: [&c]
727 {
728 leaf::result<void> r = leaf::try_handle_some(
729 try_block: [&c]() -> leaf::result<void>
730 {
731 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
732 c = answer;
733 return { };
734 },
735 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
736 {
737 BOOST_TEST(ec.matched.value==my_error_code::error1);
738 BOOST_TEST_EQ(x.value, 1);
739 BOOST_TEST_EQ(y.value, 2);
740 BOOST_TEST_EQ(c, 0);
741 c = 1;
742 } );
743 BOOST_TEST(r);
744 BOOST_TEST_EQ(c, 1);
745 return r;
746 },
747 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error2> )
748 {
749 BOOST_TEST_EQ(c, 0);
750 c = 2;
751 },
752 h: [&c]
753 {
754 BOOST_TEST_EQ(c, 0);
755 c = 3;
756 } );
757 BOOST_TEST_EQ(c, 1);
758 }
759
760 // void, try_handle_some (failure, initially matched), match value (multiple values)
761 {
762 int c=0;
763 leaf::try_handle_all(
764 try_block: [&c]
765 {
766 leaf::result<void> r = leaf::try_handle_some(
767 try_block: [&c]() -> leaf::result<void>
768 {
769 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
770 c = answer;
771 return { };
772 },
773 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
774 {
775 BOOST_TEST(ec.matched.value==my_error_code::error1);
776 BOOST_TEST_EQ(x.value, 1);
777 BOOST_TEST_EQ(y.value, 2);
778 BOOST_TEST_EQ(c, 0);
779 c = 1;
780 } );
781 BOOST_TEST(r);
782 BOOST_TEST_EQ(c, 1);
783 return r;
784 },
785 h: [&c]( leaf::match_value<e_my_error_code, my_error_code::error2> )
786 {
787 BOOST_TEST_EQ(c, 0);
788 c = 2;
789 },
790 h: [&c]
791 {
792 BOOST_TEST_EQ(c, 0);
793 c = 3;
794 } );
795 BOOST_TEST_EQ(c, 1);
796 }
797
798 //////////////////////////////////////
799
800 // int, try_handle_some (success)
801 {
802 leaf::result<int> r = leaf::try_handle_some(
803 try_block: []() -> leaf::result<int>
804 {
805 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::ok));
806 return answer;
807 },
808 h: []( leaf::error_info const & unmatched )
809 {
810 return unmatched.error();
811 } );
812 BOOST_TEST_EQ(*r, 42);
813 }
814
815 // int, try_handle_some (failure, matched)
816 {
817 leaf::result<int> r = leaf::try_handle_some(
818 try_block: []() -> leaf::result<int>
819 {
820 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
821 return answer;
822 },
823 h: []( my_error_code ec, info<1> const & x, info<2> y )
824 {
825 BOOST_TEST(ec==my_error_code::error1);
826 BOOST_TEST_EQ(x.value, 1);
827 BOOST_TEST_EQ(y.value, 2);
828 return 1;
829 } );
830 BOOST_TEST(r);
831 BOOST_TEST_EQ(*r, 1);
832 }
833
834#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
835 // int, try_handle_some (failure, matched), match cond_x (single enum value)
836 {
837 leaf::result<int> r = leaf::try_handle_some(
838 try_block: []() -> leaf::result<int>
839 {
840 BOOST_LEAF_AUTO(answer, f_errc<int>(errc_a::a0));
841 return answer;
842 },
843 h: []( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
844 {
845 return 1;
846 },
847 h: []( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
848 {
849 BOOST_TEST_EQ(ec.matched, make_error_code(errc_a::a0));
850 BOOST_TEST_EQ(x.value, 1);
851 BOOST_TEST_EQ(y.value, 2);
852 return 2;
853 } );
854 BOOST_TEST(r);
855 BOOST_TEST_EQ(*r, 2);
856 }
857#endif
858
859 // int, try_handle_some (failure, matched), match enum (single enum value)
860 {
861 leaf::result<int> r = leaf::try_handle_some(
862 try_block: []() -> leaf::result<int>
863 {
864 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
865 return answer;
866 },
867 h: []( leaf::match<my_error_code,my_error_code::error2> )
868 {
869 return 1;
870 },
871 h: []( leaf::match<my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
872 {
873 BOOST_TEST(ec.matched==my_error_code::error1);
874 BOOST_TEST_EQ(x.value, 1);
875 BOOST_TEST_EQ(y.value, 2);
876 return 2;
877 } );
878 BOOST_TEST(r);
879 BOOST_TEST_EQ(*r, 2);
880 }
881
882 // int, try_handle_some (failure, matched), match enum (multiple enum values)
883 {
884 leaf::result<int> r = leaf::try_handle_some(
885 try_block: []() -> leaf::result<int>
886 {
887 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
888 return answer;
889 },
890 h: []( leaf::match<my_error_code,my_error_code::error2> )
891 {
892 return 1;
893 },
894 h: []( leaf::match<my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
895 {
896 BOOST_TEST(ec.matched==my_error_code::error1);
897 BOOST_TEST_EQ(x.value, 1);
898 BOOST_TEST_EQ(y.value, 2);
899 return 2;
900 } );
901 BOOST_TEST(r);
902 BOOST_TEST_EQ(*r, 2);
903 }
904
905 // int, try_handle_some (failure, matched), match value (single value)
906 {
907 leaf::result<int> r = leaf::try_handle_some(
908 try_block: []() -> leaf::result<int>
909 {
910 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
911 return answer;
912 },
913 h: []( leaf::match_value<e_my_error_code,my_error_code::error2> )
914 {
915 return 1;
916 },
917 h: []( leaf::match_value<e_my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
918 {
919 BOOST_TEST(ec.matched.value==my_error_code::error1);
920 BOOST_TEST_EQ(x.value, 1);
921 BOOST_TEST_EQ(y.value, 2);
922 return 2;
923 } );
924 BOOST_TEST(r);
925 BOOST_TEST_EQ(*r, 2);
926 }
927
928 // int, try_handle_some (failure, matched), match value (multiple values)
929 {
930 leaf::result<int> r = leaf::try_handle_some(
931 try_block: []() -> leaf::result<int>
932 {
933 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
934 return answer;
935 },
936 h: []( leaf::match_value<e_my_error_code,my_error_code::error2> )
937 {
938 return 1;
939 },
940 h: []( leaf::match_value<e_my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
941 {
942 BOOST_TEST(ec.matched.value==my_error_code::error1);
943 BOOST_TEST_EQ(x.value, 1);
944 BOOST_TEST_EQ(y.value, 2);
945 return 2;
946 } );
947 BOOST_TEST(r);
948 BOOST_TEST_EQ(*r, 2);
949 }
950
951 // int, try_handle_some (failure, initially not matched)
952 {
953 int r = leaf::try_handle_all(
954 try_block: []
955 {
956 leaf::result<int> r1 = leaf::try_handle_some(
957 try_block: []() -> leaf::result<int>
958 {
959 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
960 return answer;
961 },
962 h: []( info<4> )
963 {
964 return 1;
965 } );
966 BOOST_TEST(!r1);
967 return r1;
968 },
969 h: []( my_error_code ec, info<1> const & x, info<2> y )
970 {
971 BOOST_TEST(ec==my_error_code::error1);
972 BOOST_TEST_EQ(x.value, 1);
973 BOOST_TEST_EQ(y.value, 2);
974 return 2;
975 },
976 h: []
977 {
978 return 3;
979 } );
980 BOOST_TEST_EQ(r, 2);
981 }
982
983#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
984 // int, try_handle_some (failure, initially not matched), match cond_x (single enum value)
985 {
986 int r = leaf::try_handle_all(
987 try_block: []
988 {
989 leaf::result<int> r1 = leaf::try_handle_some(
990 try_block: []() -> leaf::result<int>
991 {
992 BOOST_LEAF_AUTO(answer, f_errc<int>(errc_a::a0));
993 return answer;
994 },
995 h: []( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
996 {
997 return 1;
998 } );
999 BOOST_TEST(!r1);
1000 return r1;
1001 },
1002 h: []( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
1003 {
1004 BOOST_TEST_EQ(ec.matched, make_error_code(errc_a::a0));
1005 BOOST_TEST_EQ(x.value, 1);
1006 BOOST_TEST_EQ(y.value, 2);
1007 return 2;
1008 },
1009 h: []
1010 {
1011 return 3;
1012 } );
1013 BOOST_TEST_EQ(r, 2);
1014 }
1015#endif
1016
1017#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
1018 // int, try_handle_some (failure, initially not matched), match cond_x (wrapped std::error_code)
1019 {
1020 int r = leaf::try_handle_all(
1021 try_block: []
1022 {
1023 leaf::result<int> r1 = leaf::try_handle_some(
1024 try_block: []() -> leaf::result<int>
1025 {
1026 BOOST_LEAF_AUTO(answer, f_errc_wrapped<int>(errc_a::a0));
1027 return answer;
1028 },
1029 h: []( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x11> )
1030 {
1031 return 1;
1032 } );
1033 BOOST_TEST(!r1);
1034 return r1;
1035 },
1036 h: []( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
1037 {
1038 BOOST_TEST_EQ(ec.matched.value, make_error_code(errc_a::a0));
1039 BOOST_TEST_EQ(x.value, 1);
1040 BOOST_TEST_EQ(y.value, 2);
1041 return 2;
1042 },
1043 h: []
1044 {
1045 return 3;
1046 } );
1047 BOOST_TEST_EQ(r, 2);
1048 }
1049#endif
1050
1051 // int, try_handle_some (failure, initially not matched), match enum (single enum value)
1052 {
1053 int r = leaf::try_handle_all(
1054 try_block: []
1055 {
1056 leaf::result<int> r1 = leaf::try_handle_some(
1057 try_block: []() -> leaf::result<int>
1058 {
1059 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
1060 return answer;
1061 },
1062 h: []( leaf::match<my_error_code,my_error_code::error2> )
1063 {
1064 return 1;
1065 } );
1066 BOOST_TEST(!r1);
1067 return r1;
1068 },
1069 h: []( leaf::match<my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
1070 {
1071 BOOST_TEST(ec.matched==my_error_code::error1);
1072 BOOST_TEST_EQ(x.value, 1);
1073 BOOST_TEST_EQ(y.value, 2);
1074 return 2;
1075 },
1076 h: []
1077 {
1078 return 3;
1079 } );
1080 BOOST_TEST_EQ(r, 2);
1081 }
1082
1083 // int, try_handle_some (failure, initially not matched), match enum (multiple enum values)
1084 {
1085 int r = leaf::try_handle_all(
1086 try_block: []
1087 {
1088 leaf::result<int> r1 = leaf::try_handle_some(
1089 try_block: []() -> leaf::result<int>
1090 {
1091 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
1092 return answer;
1093 },
1094 h: []( leaf::match<my_error_code,my_error_code::error2> )
1095 {
1096 return 1;
1097 } );
1098 BOOST_TEST(!r1);
1099 return r1;
1100 },
1101 h: []( leaf::match<my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
1102 {
1103 BOOST_TEST(ec.matched==my_error_code::error1);
1104 BOOST_TEST_EQ(x.value, 1);
1105 BOOST_TEST_EQ(y.value, 2);
1106 return 2;
1107 },
1108 h: []
1109 {
1110 return 3;
1111 } );
1112 BOOST_TEST_EQ(r, 2);
1113 }
1114
1115 // int, try_handle_some (failure, initially not matched), match value (single value)
1116 {
1117 int r = leaf::try_handle_all(
1118 try_block: []
1119 {
1120 leaf::result<int> r1 = leaf::try_handle_some(
1121 try_block: []() -> leaf::result<int>
1122 {
1123 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
1124 return answer;
1125 },
1126 h: []( leaf::match_value<e_my_error_code,my_error_code::error2> )
1127 {
1128 return 1;
1129 } );
1130 BOOST_TEST(!r1);
1131 return r1;
1132 },
1133 h: []( leaf::match_value<e_my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
1134 {
1135 BOOST_TEST(ec.matched.value==my_error_code::error1);
1136 BOOST_TEST_EQ(x.value, 1);
1137 BOOST_TEST_EQ(y.value, 2);
1138 return 2;
1139 },
1140 h: []
1141 {
1142 return 3;
1143 } );
1144 BOOST_TEST_EQ(r, 2);
1145 }
1146
1147 // int, try_handle_some (failure, initially not matched), match value (multiple values)
1148 {
1149 int r = leaf::try_handle_all(
1150 try_block: []
1151 {
1152 leaf::result<int> r1 = leaf::try_handle_some(
1153 try_block: []() -> leaf::result<int>
1154 {
1155 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
1156 return answer;
1157 },
1158 h: []( leaf::match_value<e_my_error_code,my_error_code::error2> )
1159 {
1160 return 1;
1161 } );
1162 BOOST_TEST(!r1);
1163 return r1;
1164 },
1165 h: []( leaf::match_value<e_my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
1166 {
1167 BOOST_TEST(ec.matched.value==my_error_code::error1);
1168 BOOST_TEST_EQ(x.value, 1);
1169 BOOST_TEST_EQ(y.value, 2);
1170 return 2;
1171 },
1172 h: []
1173 {
1174 return 3;
1175 } );
1176 BOOST_TEST_EQ(r, 2);
1177 }
1178
1179 // int, try_handle_some (failure, initially matched)
1180 {
1181 int r = leaf::try_handle_all(
1182 try_block: []
1183 {
1184 leaf::result<int> r1 = leaf::try_handle_some(
1185 try_block: []() -> leaf::result<int>
1186 {
1187 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
1188 return answer;
1189 },
1190 h: []( my_error_code ec, info<1> const & x, info<2> y )
1191 {
1192 BOOST_TEST(ec==my_error_code::error1);
1193 BOOST_TEST_EQ(x.value, 1);
1194 BOOST_TEST_EQ(y.value, 2);
1195 return 1;
1196 } );
1197 BOOST_TEST(r1);
1198 return r1;
1199 },
1200 h: []( info<4> )
1201 {
1202 return 2;
1203 },
1204 h: []
1205 {
1206 return 3;
1207 } );
1208 BOOST_TEST_EQ(r, 1);
1209 }
1210
1211#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
1212 // int, try_handle_some (failure, initially matched), match cond_x (single enum value)
1213 {
1214 int r = leaf::try_handle_all(
1215 try_block: []
1216 {
1217 leaf::result<int> r1 = leaf::try_handle_some(
1218 try_block: []() -> leaf::result<int>
1219 {
1220 BOOST_LEAF_AUTO(answer, f_errc<int>(errc_a::a0));
1221 return answer;
1222 },
1223 h: []( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
1224 {
1225 BOOST_TEST_EQ(ec.matched, make_error_code(errc_a::a0));
1226 BOOST_TEST_EQ(x.value, 1);
1227 BOOST_TEST_EQ(y.value, 2);
1228 return 1;
1229 } );
1230 BOOST_TEST(r1);
1231 return r1;
1232 },
1233 h: []( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
1234 {
1235 return 2;
1236 },
1237 h: []
1238 {
1239 return 3;
1240 } );
1241 BOOST_TEST_EQ(r, 1);
1242 }
1243#endif
1244
1245#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
1246 // int, try_handle_some (failure, initially matched), match cond_x (wrapped std::error_code)
1247 {
1248 int r = leaf::try_handle_all(
1249 try_block: []
1250 {
1251 leaf::result<int> r1 = leaf::try_handle_some(
1252 try_block: []() -> leaf::result<int>
1253 {
1254 BOOST_LEAF_AUTO(answer, f_errc_wrapped<int>(errc_a::a0));
1255 return answer;
1256 },
1257 h: []( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
1258 {
1259 BOOST_TEST_EQ(ec.matched.value, make_error_code(errc_a::a0));
1260 BOOST_TEST_EQ(x.value, 1);
1261 BOOST_TEST_EQ(y.value, 2);
1262 return 1;
1263 } );
1264 BOOST_TEST(r1);
1265 return r1;
1266 },
1267 h: []( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x11> )
1268 {
1269 return 2;
1270 },
1271 h: []
1272 {
1273 return 3;
1274 } );
1275 BOOST_TEST_EQ(r, 1);
1276 }
1277#endif
1278
1279 // int, try_handle_some (failure, initially matched), match enum (single enum value)
1280 {
1281 int r = leaf::try_handle_all(
1282 try_block: []
1283 {
1284 leaf::result<int> r1 = leaf::try_handle_some(
1285 try_block: []() -> leaf::result<int>
1286 {
1287 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
1288 return answer;
1289 },
1290 h: []( leaf::match<my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
1291 {
1292 BOOST_TEST(ec.matched==my_error_code::error1);
1293 BOOST_TEST_EQ(x.value, 1);
1294 BOOST_TEST_EQ(y.value, 2);
1295 return 1;
1296 } );
1297 BOOST_TEST(r1);
1298 return r1;
1299 },
1300 h: []( leaf::match<my_error_code,my_error_code::error2> )
1301 {
1302 return 2;
1303 },
1304 h: []
1305 {
1306 return 3;
1307 } );
1308 BOOST_TEST_EQ(r, 1);
1309 }
1310
1311 // int, try_handle_some (failure, initially matched), match enum (multiple enum values)
1312 {
1313 int r = leaf::try_handle_all(
1314 try_block: []
1315 {
1316 leaf::result<int> r1 = leaf::try_handle_some(
1317 try_block: []() -> leaf::result<int>
1318 {
1319 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
1320 return answer;
1321 },
1322 h: []( leaf::match<my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
1323 {
1324 BOOST_TEST(ec.matched==my_error_code::error1);
1325 BOOST_TEST_EQ(x.value, 1);
1326 BOOST_TEST_EQ(y.value, 2);
1327 return 1;
1328 } );
1329 BOOST_TEST(r1);
1330 return r1;
1331 },
1332 h: []( leaf::match<my_error_code,my_error_code::error2> )
1333 {
1334 return 2;
1335 },
1336 h: []
1337 {
1338 return 3;
1339 } );
1340 BOOST_TEST_EQ(r, 1);
1341 }
1342
1343 // int, try_handle_some (failure, initially matched), match value (single value)
1344 {
1345 int r = leaf::try_handle_all(
1346 try_block: []
1347 {
1348 leaf::result<int> r1 = leaf::try_handle_some(
1349 try_block: []() -> leaf::result<int>
1350 {
1351 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
1352 return answer;
1353 },
1354 h: []( leaf::match_value<e_my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
1355 {
1356 BOOST_TEST(ec.matched.value==my_error_code::error1);
1357 BOOST_TEST_EQ(x.value, 1);
1358 BOOST_TEST_EQ(y.value, 2);
1359 return 1;
1360 } );
1361 BOOST_TEST(r1);
1362 return r1;
1363 },
1364 h: []( leaf::match_value<e_my_error_code,my_error_code::error2> )
1365 {
1366 return 2;
1367 },
1368 h: []
1369 {
1370 return 3;
1371 } );
1372 BOOST_TEST_EQ(r, 1);
1373 }
1374
1375 // int, try_handle_some (failure, initially matched), match value (multiple values)
1376 {
1377 int r = leaf::try_handle_all(
1378 try_block: []
1379 {
1380 leaf::result<int> r1 = leaf::try_handle_some(
1381 try_block: []() -> leaf::result<int>
1382 {
1383 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
1384 return answer;
1385 },
1386 h: []( leaf::match_value<e_my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
1387 {
1388 BOOST_TEST(ec.matched.value==my_error_code::error1);
1389 BOOST_TEST_EQ(x.value, 1);
1390 BOOST_TEST_EQ(y.value, 2);
1391 return 1;
1392 } );
1393 BOOST_TEST(r1);
1394 return r1;
1395 },
1396 h: []( leaf::match_value<e_my_error_code,my_error_code::error2> )
1397 {
1398 return 2;
1399 },
1400 h: []
1401 {
1402 return 3;
1403 } );
1404 BOOST_TEST_EQ(r, 1);
1405 }
1406
1407 //////////////////////////////////////
1408
1409 // no exception caught, error handled
1410 {
1411 int handle_some_handler_called = 0;
1412 leaf::result<int> r = leaf::try_handle_some(
1413 try_block: []() -> leaf::result<int>
1414 {
1415 return leaf::new_error( item: info<0>{.value: 1} );
1416 },
1417 h: [&]( info<0> & x )
1418 {
1419 BOOST_TEST_EQ(x.value, 1);
1420 ++handle_some_handler_called;
1421 return 1;
1422 } );
1423 BOOST_TEST_EQ(r.value(), 1);
1424 BOOST_TEST_EQ(handle_some_handler_called, 1);
1425 }
1426
1427 // no exception caught, error not handled
1428 {
1429 int handle_some_handler_called = 0;
1430 int r = leaf::try_handle_all(
1431 try_block: [&]
1432 {
1433 leaf::result<int> r1 = leaf::try_handle_some(
1434 try_block: []() -> leaf::result<int>
1435 {
1436 return leaf::new_error( item: info<0>{.value: 1} );
1437 },
1438 h: [&]( leaf::error_info const & e, info<0> & x ) -> leaf::result<int>
1439 {
1440 BOOST_TEST_EQ(x.value, 1);
1441 ++handle_some_handler_called;
1442 return e.error();
1443 } );
1444 BOOST_TEST(!r1);
1445 BOOST_TEST_EQ(handle_some_handler_called, 1);
1446 return r1;
1447 },
1448 h: [](info<0> & x)
1449 {
1450 BOOST_TEST_EQ(x.value, 1);
1451 return 1;
1452 },
1453 h: []
1454 {
1455 return 2;
1456 });
1457 BOOST_TEST_EQ(r, 1);
1458 }
1459
1460#ifndef BOOST_LEAF_NO_EXCEPTIONS
1461 // exception caught, error handled
1462 {
1463 int handle_some_handler_called = 0;
1464 leaf::result<int> r = leaf::try_handle_some(
1465 try_block: []() -> leaf::result<int>
1466 {
1467 BOOST_LEAF_THROW_EXCEPTION( car: info<0>{.value: 1} );
1468 },
1469 h: [&]( info<0> & x ) -> leaf::result<int>
1470 {
1471 BOOST_TEST_EQ(x.value, 1);
1472 ++handle_some_handler_called;
1473 return 1;
1474 } );
1475 BOOST_TEST_EQ(r.value(), 1);
1476 BOOST_TEST_EQ(handle_some_handler_called, 1);
1477 }
1478#endif
1479
1480#ifndef BOOST_LEAF_NO_EXCEPTIONS
1481 // exception caught, error not handled
1482 {
1483 int handle_some_handler_called = 0;
1484 int r = leaf::try_handle_all(
1485 try_block: [&]
1486 {
1487 leaf::result<int> r = leaf::try_handle_some(
1488 try_block: []() -> leaf::result<int>
1489 {
1490 BOOST_LEAF_THROW_EXCEPTION( car: info<0>{.value: 1} );
1491 },
1492 h: [&]( leaf::error_info const & e, info<0> & x ) -> leaf::result<int>
1493 {
1494 BOOST_TEST_EQ(x.value, 1);
1495 ++handle_some_handler_called;
1496 return e.error();
1497 } );
1498 BOOST_TEST(!r);
1499 BOOST_TEST_EQ(handle_some_handler_called, 1);
1500 return r;
1501 },
1502 h: []( info<0> & x )
1503 {
1504 BOOST_TEST_EQ(x.value, 1);
1505 return 1;
1506 },
1507 h: []
1508 {
1509 return 2;
1510 });
1511 BOOST_TEST_EQ(r, 1);
1512 }
1513#endif
1514
1515 return boost::report_errors();
1516}
1517

source code of boost/libs/leaf/test/handle_some_test.cpp