boost/leaf
2
0
Fork 0
mirror of https://github.com/boostorg/leaf.git synced 2026-01-26 06:32:23 +00:00
Code Issues Projects Releases Wiki Activity
Files
a16600a9893f2cbb1e024b181752f6cb5fbabfb4
leaf/test/handle_some_test.cpp
Emil Dotchevski a16600a989 error constructor -> new_error
2019-01-10 09:29:48 -08:00

1014 lines
22 KiB
C++
Raw Blame History

//Copyright (c) 2018 Emil Dotchevski
//Copyright (c) 2018 Second Spectrum, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/leaf/handle.hpp>
#include "boost/core/lightweight_test.hpp"
namespace leaf = boost::leaf;
template <int> struct info { int value; };
enum class error_codes
{
ok,
error1,
error2,
error3
};
namespace boost { namespace leaf {
template <> struct is_error_type<error_codes>: std::true_type { };
} }
struct error_codes_ { error_codes value; };
template <class R>
leaf::result<R> f( error_codes ec )
{
if( ec==error_codes::ok )
return R(42);
else
return leaf::new_error(ec,error_codes_{ec},info<1>{1},info<2>{2},info<3>{3});
}
int main()
{
//void, handle_some (success)
{
int c=0;
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::ok));
c = answer;
return { };
},
[&c]( leaf::error e )
{
BOOST_TEST(c==0);
c = 1;
return e;
} );
BOOST_TEST(r);
BOOST_TEST(c==42);
}
//void, handle_some (failure, matched)
{
int c=0;
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( error_codes ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 1;
} );
BOOST_TEST(c==1);
BOOST_TEST(r);
}
//void, handle_some (failure, matched), match enum (single enum value)
{
int c=0;
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 1;
},
[&c]( leaf::match<error_codes,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 2;
} );
BOOST_TEST(c==2);
BOOST_TEST(r);
}
//void, handle_some (failure, matched), match enum (multiple enum values)
{
int c=0;
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 1;
},
[&c]( leaf::match<error_codes,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 2;
} );
BOOST_TEST(c==2);
BOOST_TEST(r);
}
//void, handle_some (failure, matched), match value (single value)
{
int c=0;
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes_,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 1;
},
[&c]( leaf::match<error_codes_,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 2;
} );
BOOST_TEST(c==2);
BOOST_TEST(r);
}
//void, handle_some (failure, matched), match value (multiple values)
{
int c=0;
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes_,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 1;
},
[&c]( leaf::match<error_codes_,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 2;
} );
BOOST_TEST(c==2);
BOOST_TEST(r);
}
//void, handle_some (failure, initially not matched)
{
int c=0;
leaf::handle_all(
[&c]
{
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( info<4> )
{
BOOST_TEST(c==0);
c = 1;
} );
BOOST_TEST(!r);
BOOST_TEST(c==0);
return r;
},
[&c]( error_codes ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
c = 3;
} );
BOOST_TEST(c==2);
}
//void, handle_some (failure, initially not matched), match enum (single enum value)
{
int c=0;
leaf::handle_all(
[&c]
{
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 1;
} );
BOOST_TEST(!r);
BOOST_TEST(c==0);
return r;
},
[&c]( leaf::match<error_codes,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
c = 3;
} );
BOOST_TEST(c==2);
}
//void, handle_some (failure, initially not matched), match enum (multiple enum values)
{
int c=0;
leaf::handle_all(
[&c]
{
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 1;
} );
BOOST_TEST(!r);
BOOST_TEST(c==0);
return r;
},
[&c]( leaf::match<error_codes,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
c = 3;
} );
BOOST_TEST(c==2);
}
//void, handle_some (failure, initially not matched), match value (single value)
{
int c=0;
leaf::handle_all(
[&c]
{
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes_,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 1;
} );
BOOST_TEST(!r);
BOOST_TEST(c==0);
return r;
},
[&c]( leaf::match<error_codes_,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
c = 3;
} );
BOOST_TEST(c==2);
}
//void, handle_some (failure, initially not matched), match value (multiple values)
{
int c=0;
leaf::handle_all(
[&c]
{
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes_,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 1;
} );
BOOST_TEST(!r);
BOOST_TEST(c==0);
return r;
},
[&c]( leaf::match<error_codes_,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
c = 3;
} );
BOOST_TEST(c==2);
}
//void, handle_some (failure, initially matched)
{
int c=0;
leaf::handle_all(
[&c]
{
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( error_codes ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 1;
} );
BOOST_TEST(r);
BOOST_TEST(c==1);
return r;
},
[&c]( info<4> )
{
BOOST_TEST(c==0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
c = 3;
} );
BOOST_TEST(c==1);
}
//void, handle_some (failure, initially matched), match enum (single enum value)
{
int c=0;
leaf::handle_all(
[&c]
{
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 1;
} );
BOOST_TEST(r);
BOOST_TEST(c==1);
return r;
},
[&c]( leaf::match<error_codes,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
c = 3;
} );
BOOST_TEST(c==1);
}
//void, handle_some (failure, initially matched), match enum (multiple enum values)
{
int c=0;
leaf::handle_all(
[&c]
{
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 1;
} );
BOOST_TEST(r);
BOOST_TEST(c==1);
return r;
},
[&c]( leaf::match<error_codes,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
c = 3;
} );
BOOST_TEST(c==1);
}
//void, handle_some (failure, initially matched), match value (single value)
{
int c=0;
leaf::handle_all(
[&c]
{
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes_,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 1;
} );
BOOST_TEST(r);
BOOST_TEST(c==1);
return r;
},
[&c]( leaf::match<error_codes_,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
c = 3;
} );
BOOST_TEST(c==1);
}
//void, handle_some (failure, initially matched), match value (multiple values)
{
int c=0;
leaf::handle_all(
[&c]
{
leaf::result<void> r = leaf::handle_some(
[&c]() -> leaf::result<void>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
c = answer;
return { };
},
[&c]( leaf::match<error_codes_,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
c = 1;
} );
BOOST_TEST(r);
BOOST_TEST(c==1);
return r;
},
[&c]( leaf::match<error_codes_,error_codes::error2> )
{
BOOST_TEST(c==0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
c = 3;
} );
BOOST_TEST(c==1);
}
//////////////////////////////////////
//int, handle_some (success)
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::ok));
return answer;
},
[ ]( leaf::error e )
{
return e;
} );
BOOST_TEST(r && *r==42);
}
//int, handle_some (failure, matched)
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( error_codes ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 1;
} );
BOOST_TEST(r && *r==1);
}
//int, handle_some (failure, matched), match enum (single enum value)
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes,error_codes::error2> )
{
return 1;
},
[ ]( leaf::match<error_codes,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 2;
} );
BOOST_TEST(r && *r==2);
}
//int, handle_some (failure, matched), match enum (multiple enum values)
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes,error_codes::error2> )
{
return 1;
},
[ ]( leaf::match<error_codes,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 2;
} );
BOOST_TEST(r && *r==2);
}
//int, handle_some (failure, matched), match value (single value)
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes_,error_codes::error2> )
{
return 1;
},
[ ]( leaf::match<error_codes_,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 2;
} );
BOOST_TEST(r && *r==2);
}
//int, handle_some (failure, matched), match value (multiple values)
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes_,error_codes::error2> )
{
return 1;
},
[ ]( leaf::match<error_codes_,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 2;
} );
BOOST_TEST(r && *r==2);
}
//int, handle_some (failure, initially not matched)
{
int r = leaf::handle_all(
[ ]
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( info<4> )
{
return 1;
} );
BOOST_TEST(!r);
return r;
},
[ ]( error_codes ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
}
//int, handle_some (failure, initially not matched), match enum (single enum value)
{
int r = leaf::handle_all(
[ ]
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes,error_codes::error2> )
{
return 1;
} );
BOOST_TEST(!r);
return r;
},
[ ]( leaf::match<error_codes,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
}
//int, handle_some (failure, initially not matched), match enum (multiple enum values)
{
int r = leaf::handle_all(
[ ]
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes,error_codes::error2> )
{
return 1;
} );
BOOST_TEST(!r);
return r;
},
[ ]( leaf::match<error_codes,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
}
//int, handle_some (failure, initially not matched), match value (single value)
{
int r = leaf::handle_all(
[ ]
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes_,error_codes::error2> )
{
return 1;
} );
BOOST_TEST(!r);
return r;
},
[ ]( leaf::match<error_codes_,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
}
//int, handle_some (failure, initially not matched), match value (multiple values)
{
int r = leaf::handle_all(
[ ]
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes_,error_codes::error2> )
{
return 1;
} );
BOOST_TEST(!r);
return r;
},
[ ]( leaf::match<error_codes_,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
}
//int, handle_some (failure, initially matched)
{
int r = leaf::handle_all(
[ ]
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( error_codes ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 1;
} );
BOOST_TEST(r);
return r;
},
[ ]( info<4> )
{
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==1);
}
//int, handle_some (failure, initially matched), match enum (single enum value)
{
int r = leaf::handle_all(
[ ]
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 1;
} );
BOOST_TEST(r);
return r;
},
[ ]( leaf::match<error_codes,error_codes::error2> )
{
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==1);
}
//int, handle_some (failure, initially matched), match enum (multiple enum values)
{
int r = leaf::handle_all(
[ ]
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 1;
} );
BOOST_TEST(r);
return r;
},
[ ]( leaf::match<error_codes,error_codes::error2> )
{
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==1);
}
//int, handle_some (failure, initially matched), match value (single value)
{
int r = leaf::handle_all(
[ ]
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes_,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 1;
} );
BOOST_TEST(r);
return r;
},
[ ]( leaf::match<error_codes_,error_codes::error2> )
{
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==1);
}
//int, handle_some (failure, initially matched), match value (multiple values)
{
int r = leaf::handle_all(
[ ]
{
leaf::result<int> r = leaf::handle_some(
[ ]() -> leaf::result<int>
{
LEAF_AUTO(answer, f<int>(error_codes::error1));
return answer;
},
[ ]( leaf::match<error_codes_,error_codes::error2,error_codes::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value==error_codes::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
return 1;
} );
BOOST_TEST(r);
return r;
},
[ ]( leaf::match<error_codes_,error_codes::error2> )
{
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==1);
}
return boost::report_errors();
}
Reference in New Issue View Git Blame Copy Permalink