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

   1 // Copyright (c) 2018-2020 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 #include <boost/leaf/handle_errors.hpp>
   7 #include <boost/leaf/pred.hpp>
   8 #include <boost/leaf/result.hpp>
   9 #include "_test_ec.hpp"
  10 #include "lightweight_test.hpp"
  11
  12 namespace leaf = boost::leaf;
  13
  14 template <int> struct info { int value; };
  15
  16 enum class my_error_code
  17 {
  18     ok,
  19     error1,
  20     error2,
  21     error3
  22 };
  23
  24 struct e_my_error_code { my_error_code value; };
  25
  26 struct e_std_error_code { std::error_code value; };
  27
  28 template <class R>
  29 leaf::result<R> f( my_error_code ec )
  30 {
  31     if( ec==my_error_code::ok )
  32         return R(42);
  33     else
  34         return leaf::new_error(ec, e_my_error_code{ec}, info<1>{1}, info<2>{2}, info<3>{3});
  35 }
  36
  37 template <class R, class Errc>
  38 leaf::result<R> f_errc( Errc ec )
  39 {
  40     return leaf::new_error(make_error_code(ec), info<1>{1}, info<2>{2}, info<3>{3});
  41 }
  42
  43 template <class R, class Errc>
  44 leaf::result<R> f_errc_wrapped( Errc ec )
  45 {
  46     return leaf::new_error(e_std_error_code{make_error_code(ec)}, info<1>{1}, info<2>{2}, info<3>{3});
  47 }
  48
  49 int main()
  50 {
  51     // void, try_handle_all (success)
  52     {
  53         int c=0;
  54         leaf::try_handle_all(
  55             [&c]() -> leaf::result<void>
  56             {
  57                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::ok));
  58                 c = answer;
  59                 return { };
  60             },
  61             [&c]
  62             {
  63                 BOOST_TEST_EQ(c, 0);
  64                 c = 1;
  65             } );
  66         BOOST_TEST_EQ(c, 42);
  67     }
  68
  69     // void, try_handle_all (failure)
  70     {
  71         int c=0;
  72         leaf::try_handle_all(
  73             [&c]() -> leaf::result<void>
  74             {
  75                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
  76                 c = answer;
  77                 return { };
  78             },
  79             [&c]( my_error_code ec, info<1> const & x,info<2> y )
  80             {
  81                 BOOST_TEST(ec==my_error_code::error1);
  82                 BOOST_TEST_EQ(x.value, 1);
  83                 BOOST_TEST_EQ(y.value, 2);
  84                 BOOST_TEST_EQ(c, 0);
  85                 c = 1;
  86             },
  87             [&c]()
  88             {
  89                 BOOST_TEST_EQ(c, 0);
  90                 c = 2;
  91             } );
  92         BOOST_TEST_EQ(c, 1);
  93     }
  94
  95     // void, try_handle_all (failure), match cond_x (single enum value)
  96     {
  97         int c=0;
  98         leaf::try_handle_all(
  99             [&c]() -> leaf::result<void>
 100             {
 101                 BOOST_LEAF_AUTO(answer, f_errc<int>(errc_a::a0));
 102                 c = answer;
 103                 return { };
 104             },
 105             [&c]( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
 106             {
 107                 BOOST_TEST_EQ(c, 0);
 108                 c = 1;
 109             },
 110             [&c]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
 111             {
 112                 BOOST_TEST_EQ(ec.matched, make_error_code(errc_a::a0));
 113                 BOOST_TEST_EQ(x.value, 1);
 114                 BOOST_TEST_EQ(y.value, 2);
 115                 BOOST_TEST_EQ(c, 0);
 116                 c = 2;
 117             },
 118             [&c]()
 119             {
 120                 BOOST_TEST_EQ(c, 0);
 121                 c = 3;
 122             } );
 123         BOOST_TEST_EQ(c, 2);
 124     }
 125
 126     // void, try_handle_all (failure), match cond_x (wrapped std::error_code)
 127     {
 128         int c=0;
 129         leaf::try_handle_all(
 130             [&c]() -> leaf::result<void>
 131             {
 132                 BOOST_LEAF_AUTO(answer, f_errc_wrapped<int>(errc_a::a0));
 133                 c = answer;
 134                 return { };
 135             },
 136             [&c]( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x11> )
 137             {
 138                 BOOST_TEST_EQ(c, 0);
 139                 c = 1;
 140             },
 141             [&c]( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
 142             {
 143                 BOOST_TEST_EQ(ec.matched.value, make_error_code(errc_a::a0));
 144                 BOOST_TEST_EQ(x.value, 1);
 145                 BOOST_TEST_EQ(y.value, 2);
 146                 BOOST_TEST_EQ(c, 0);
 147                 c = 2;
 148             },
 149             [&c]()
 150             {
 151                 BOOST_TEST_EQ(c, 0);
 152                 c = 3;
 153             } );
 154         BOOST_TEST_EQ(c, 2);
 155     }
 156
 157     // void, try_handle_all (failure), match enum (single enum value)
 158     {
 159         int c=0;
 160         leaf::try_handle_all(
 161             [&c]() -> leaf::result<void>
 162             {
 163                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
 164                 c = answer;
 165                 return { };
 166             },
 167             [&c]( leaf::match<my_error_code, my_error_code::error2> )
 168             {
 169                 BOOST_TEST_EQ(c, 0);
 170                 c = 1;
 171             },
 172             [&c]( leaf::match<my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
 173             {
 174                 BOOST_TEST(ec.matched==my_error_code::error1);
 175                 BOOST_TEST_EQ(x.value, 1);
 176                 BOOST_TEST_EQ(y.value, 2);
 177                 BOOST_TEST_EQ(c, 0);
 178                 c = 2;
 179             },
 180             [&c]()
 181             {
 182                 BOOST_TEST_EQ(c, 0);
 183                 c = 3;
 184             } );
 185         BOOST_TEST_EQ(c, 2);
 186     }
 187
 188     // void, try_handle_all (failure), match enum (multiple enum values)
 189     {
 190         int c=0;
 191         leaf::try_handle_all(
 192             [&c]() -> leaf::result<void>
 193             {
 194                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
 195                 c = answer;
 196                 return { };
 197             },
 198             [&c]( leaf::match<my_error_code, my_error_code::error2> )
 199             {
 200                 BOOST_TEST_EQ(c, 0);
 201                 c = 1;
 202             },
 203             [&c]( leaf::match<my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
 204             {
 205                 BOOST_TEST(ec.matched==my_error_code::error1);
 206                 BOOST_TEST_EQ(x.value, 1);
 207                 BOOST_TEST_EQ(y.value, 2);
 208                 BOOST_TEST_EQ(c, 0);
 209                 c = 2;
 210             },
 211             [&c]()
 212             {
 213                 BOOST_TEST_EQ(c, 0);
 214                 c = 3;
 215             } );
 216         BOOST_TEST_EQ(c, 2);
 217     }
 218
 219     // void, try_handle_all (failure), match value (single value)
 220     {
 221         int c=0;
 222         leaf::try_handle_all(
 223             [&c]() -> leaf::result<void>
 224             {
 225                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
 226                 c = answer;
 227                 return { };
 228             },
 229             [&c]( leaf::match_value<e_my_error_code, my_error_code::error2> )
 230             {
 231                 BOOST_TEST_EQ(c, 0);
 232                 c = 1;
 233             },
 234             [&c]( leaf::match_value<e_my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
 235             {
 236                 BOOST_TEST(ec.matched.value==my_error_code::error1);
 237                 BOOST_TEST_EQ(x.value, 1);
 238                 BOOST_TEST_EQ(y.value, 2);
 239                 BOOST_TEST_EQ(c, 0);
 240                 c = 2;
 241             },
 242             [&c]()
 243             {
 244                 BOOST_TEST_EQ(c, 0);
 245                 c = 3;
 246             } );
 247         BOOST_TEST_EQ(c, 2);
 248     }
 249
 250     // void, try_handle_all (failure), match value (multiple values)
 251     {
 252         int c=0;
 253         leaf::try_handle_all(
 254             [&c]() -> leaf::result<void>
 255             {
 256                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
 257                 c = answer;
 258                 return { };
 259             },
 260             [&c]( leaf::match_value<e_my_error_code, my_error_code::error2> )
 261             {
 262                 BOOST_TEST_EQ(c, 0);
 263                 c = 1;
 264             },
 265             [&c]( leaf::match_value<e_my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
 266             {
 267                 BOOST_TEST(ec.matched.value==my_error_code::error1);
 268                 BOOST_TEST_EQ(x.value, 1);
 269                 BOOST_TEST_EQ(y.value, 2);
 270                 BOOST_TEST_EQ(c, 0);
 271                 c = 2;
 272             },
 273             [&c]()
 274             {
 275                 BOOST_TEST_EQ(c, 0);
 276                 c = 3;
 277             } );
 278         BOOST_TEST_EQ(c, 2);
 279     }
 280
 281     //////////////////////////////////////
 282
 283     // int, try_handle_all (success)
 284     {
 285         int r = leaf::try_handle_all(
 286             []() -> leaf::result<int>
 287             {
 288                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::ok));
 289                 return answer;
 290             },
 291             []
 292             {
 293                 return 1;
 294             } );
 295         BOOST_TEST_EQ(r, 42);
 296     }
 297
 298     // int, try_handle_all (failure)
 299     {
 300         int r = leaf::try_handle_all(
 301             []() -> leaf::result<int>
 302             {
 303                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
 304                 return answer;
 305             },
 306             []( my_error_code ec, info<1> const & x, info<2> y )
 307             {
 308                 BOOST_TEST(ec==my_error_code::error1);
 309                 BOOST_TEST_EQ(x.value, 1);
 310                 BOOST_TEST_EQ(y.value, 2);
 311                 return 1;
 312             },
 313             []
 314             {
 315                 return 2;
 316             } );
 317         BOOST_TEST_EQ(r, 1);
 318     }
 319
 320     // int, try_handle_all (failure), match cond_x (single enum value)
 321     {
 322         int r = leaf::try_handle_all(
 323             []() -> leaf::result<int>
 324             {
 325                 BOOST_LEAF_AUTO(answer, f_errc<int>(errc_a::a0));
 326                 return answer;
 327             },
 328             []( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
 329             {
 330                 return 1;
 331             },
 332             []( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
 333             {
 334                 BOOST_TEST_EQ(ec.matched, make_error_code(errc_a::a0));
 335                 BOOST_TEST_EQ(x.value, 1);
 336                 BOOST_TEST_EQ(y.value, 2);
 337                 return 2;
 338             },
 339             []
 340             {
 341                 return 3;
 342             } );
 343         BOOST_TEST_EQ(r, 2);
 344     }
 345
 346     // int, try_handle_all (failure), match cond_x (wrapped std::error_code)
 347     {
 348         int r = leaf::try_handle_all(
 349             []() -> leaf::result<int>
 350             {
 351                 BOOST_LEAF_AUTO(answer, f_errc_wrapped<int>(errc_a::a0));
 352                 return answer;
 353             },
 354             []( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
 355             {
 356                 return 1;
 357             },
 358             []( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
 359             {
 360                 BOOST_TEST_EQ(ec.matched.value, make_error_code(errc_a::a0));
 361                 BOOST_TEST_EQ(x.value, 1);
 362                 BOOST_TEST_EQ(y.value, 2);
 363                 return 2;
 364             },
 365             []
 366             {
 367                 return 3;
 368             } );
 369         BOOST_TEST_EQ(r, 2);
 370     }
 371
 372     // int, try_handle_all (failure), match enum (single enum value)
 373     {
 374         int r = leaf::try_handle_all(
 375             []() -> leaf::result<int>
 376             {
 377                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
 378                 return answer;
 379             },
 380             []( leaf::match<my_error_code, my_error_code::error2> )
 381             {
 382                 return 1;
 383             },
 384             []( leaf::match<my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
 385             {
 386                 BOOST_TEST(ec.matched==my_error_code::error1);
 387                 BOOST_TEST_EQ(x.value, 1);
 388                 BOOST_TEST_EQ(y.value, 2);
 389                 return 2;
 390             },
 391             []
 392             {
 393                 return 3;
 394             } );
 395         BOOST_TEST_EQ(r, 2);
 396     }
 397
 398     // int, try_handle_all (failure), match enum (multiple enum values)
 399     {
 400         int r = leaf::try_handle_all(
 401             []() -> leaf::result<int>
 402             {
 403                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
 404                 return answer;
 405             },
 406             []( leaf::match<my_error_code, my_error_code::error2> )
 407             {
 408                 return 1;
 409             },
 410             []( leaf::match<my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
 411             {
 412                 BOOST_TEST(ec.matched==my_error_code::error1);
 413                 BOOST_TEST_EQ(x.value, 1);
 414                 BOOST_TEST_EQ(y.value, 2);
 415                 return 2;
 416             },
 417             []
 418             {
 419                 return 3;
 420             } );
 421         BOOST_TEST_EQ(r, 2);
 422     }
 423
 424     // int, try_handle_all (failure), match value (single value)
 425     {
 426         int r = leaf::try_handle_all(
 427             []() -> leaf::result<int>
 428             {
 429                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
 430                 return answer;
 431             },
 432             []( leaf::match_value<e_my_error_code, my_error_code::error2> )
 433             {
 434                 return 1;
 435             },
 436             []( leaf::match_value<e_my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
 437             {
 438                 BOOST_TEST(ec.matched.value==my_error_code::error1);
 439                 BOOST_TEST_EQ(x.value, 1);
 440                 BOOST_TEST_EQ(y.value, 2);
 441                 return 2;
 442             },
 443             []
 444             {
 445                 return 3;
 446             } );
 447         BOOST_TEST_EQ(r, 2);
 448     }
 449
 450     // int, try_handle_all (failure), match value (multiple values)
 451     {
 452         int r = leaf::try_handle_all(
 453             []() -> leaf::result<int>
 454             {
 455                 BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
 456                 return answer;
 457             },
 458             []( leaf::match_value<e_my_error_code, my_error_code::error2> )
 459             {
 460                 return 1;
 461             },
 462             []( leaf::match_value<e_my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
 463             {
 464                 BOOST_TEST(ec.matched.value==my_error_code::error1);
 465                 BOOST_TEST_EQ(x.value, 1);
 466                 BOOST_TEST_EQ(y.value, 2);
 467                 return 2;
 468             },
 469             []
 470             {
 471                 return 3;
 472             } );
 473         BOOST_TEST_EQ(r, 2);
 474     }
 475
 476     return boost::report_errors();
 477 }