ceph/src/boost/libs/leaf/test/handle_all_test.cpp

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