boost/leaf
2
0
Fork 0
mirror of https://github.com/boostorg/leaf.git synced 2026-01-19 04:22:08 +00:00
Code Issues Projects Releases Wiki Activity

BOOST_TEST->BOOST_TEST_EQ

Browse Source
This commit is contained in:
Emil Dotchevski
2019-01-25 10:13:23 -08:00
parent 73aabdb466
commit e45cb511c5
34 changed files with 810 additions and 801 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
test/capture_exception_async_test.cpp
View File

@@ -67,8 +67,8 @@ int main()
},
[&]( info<1> const & x1, info<2> const & x2 )
{
BOOST_TEST(x1.value==f.a);
BOOST_TEST(x2.value==f.b);
BOOST_TEST_EQ(x1.value, f.a);
BOOST_TEST_EQ(x2.value, f.b);
return -1;
},
[ ]
@@ -76,9 +76,9 @@ int main()
return -2;
} );
if( f.result>=0 )
BOOST_TEST(r==f.result);
BOOST_TEST_EQ(r, f.result);
else
BOOST_TEST(r==-1);
BOOST_TEST_EQ(r, -1);
}
return boost::report_errors();

6
test/capture_exception_state_test.cpp
View File

@@ -46,14 +46,14 @@ int main()
leaf::try_(
[&f]
{
BOOST_TEST(count==0);
BOOST_TEST_EQ(count, 0);
try { f(); }
catch(...) { BOOST_TEST(count==2); throw; }
catch(...) { BOOST_TEST_EQ(count, 2); throw; }
},
[ ]
{
} );
BOOST_TEST(count==0);
BOOST_TEST_EQ(count, 0);
return boost::report_errors();
}

32
test/capture_exception_unload_test.cpp
View File

@@ -28,16 +28,16 @@ void test( F f_ )
},
[&c]( info<1> const & x )
{
BOOST_TEST(x.value==1);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
}
{
@@ -49,16 +49,16 @@ void test( F f_ )
},
[&c]( info<2> const & x )
{
BOOST_TEST(x.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
{
@@ -69,14 +69,14 @@ void test( F f_ )
},
[ ]( info<1> const & x )
{
BOOST_TEST(x.value==1);
BOOST_TEST_EQ(x.value, 1);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
{
@@ -87,14 +87,14 @@ void test( F f_ )
},
[ ]( info<2> const & x )
{
BOOST_TEST(x.value==2);
BOOST_TEST_EQ(x.value, 2);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
{
@@ -109,8 +109,8 @@ void test( F f_ )
},
[ ]( info<1> const & x, info<3> const & y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==3);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 3);
return false;
},
[ ]( info<1> const & x )
@@ -136,8 +136,8 @@ void test( F f_ )
},
[ ]( info<1> const & x, info<3> const & y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==3);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 3);
return true;
},
[ ]( info<1> const & x )

8
test/capture_result_async_test.cpp
View File

@@ -67,8 +67,8 @@ int main()
},
[&]( info<1> const & x1, info<2> const & x2 )
{
BOOST_TEST(x1.value==f.a);
BOOST_TEST(x2.value==f.b);
BOOST_TEST_EQ(x1.value, f.a);
BOOST_TEST_EQ(x2.value, f.b);
return -1;
},
[ ]
@@ -76,9 +76,9 @@ int main()
return -2;
} );
if( f.result>=0 )
BOOST_TEST(r==f.result);
BOOST_TEST_EQ(r, f.result);
else
BOOST_TEST(r==-1);
BOOST_TEST_EQ(r, -1);
}
return boost::report_errors();

6
test/capture_result_state_test.cpp
View File

@@ -46,14 +46,14 @@ int main()
leaf::handle_all(
[&f]
{
BOOST_TEST(count==0);
BOOST_TEST_EQ(count, 0);
auto r = f();
BOOST_TEST(count==2);
BOOST_TEST_EQ(count, 2);
return r;
},
[ ]
{
} );
BOOST_TEST(count==0);
BOOST_TEST_EQ(count, 0);
return boost::report_errors();
}

32
test/capture_result_unload_test.cpp
View File

@@ -28,16 +28,16 @@ void test( F f_ )
},
[&c]( info<1> const & x )
{
BOOST_TEST(x.value==1);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
}
{
@@ -49,16 +49,16 @@ void test( F f_ )
},
[&c]( info<2> const & x )
{
BOOST_TEST(x.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
{
@@ -69,14 +69,14 @@ void test( F f_ )
},
[ ]( info<1> const & x )
{
BOOST_TEST(x.value==1);
BOOST_TEST_EQ(x.value, 1);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
{
@@ -87,14 +87,14 @@ void test( F f_ )
},
[ ]( info<2> const & x )
{
BOOST_TEST(x.value==2);
BOOST_TEST_EQ(x.value, 2);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
{
@@ -109,8 +109,8 @@ void test( F f_ )
},
[ ]( info<1> const & x, info<3> const & y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==3);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 3);
return false;
},
[ ]( info<1> const & x )
@@ -136,8 +136,8 @@ void test( F f_ )
},
[ ]( info<1> const & x, info<3> const & y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==3);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 3);
return true;
},
[ ]( info<1> const & x )

4
test/defer_basic_test.cpp
View File

@@ -45,13 +45,13 @@ int main()
},
[ ]( info const & i42 )
{
BOOST_TEST(i42.value==42);
BOOST_TEST_EQ(i42.value, 42);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

10
test/defer_nested_error_exception_test.cpp
View File

@@ -52,17 +52,17 @@ int main()
},
[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
{
BOOST_TEST(i0.value==0);
BOOST_TEST(i1.value==1);
BOOST_TEST(i2.value==2);
BOOST_TEST(i3.value==3);
BOOST_TEST_EQ(i0.value, 0);
BOOST_TEST_EQ(i1.value, 1);
BOOST_TEST_EQ(i2.value, 2);
BOOST_TEST_EQ(i3.value, 3);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

10
test/defer_nested_error_result_test.cpp
View File

@@ -43,17 +43,17 @@ int main()
},
[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
{
BOOST_TEST(i0.value==0);
BOOST_TEST(i1.value==1);
BOOST_TEST(i2.value==2);
BOOST_TEST(i3.value==3);
BOOST_TEST_EQ(i0.value, 0);
BOOST_TEST_EQ(i1.value, 1);
BOOST_TEST_EQ(i2.value, 2);
BOOST_TEST_EQ(i3.value, 3);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

10
test/defer_nested_new_error_exception_test.cpp
View File

@@ -59,17 +59,17 @@ int main()
},
[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
{
BOOST_TEST(i0.value==0);
BOOST_TEST(i1.value==1);
BOOST_TEST(i2.value==2);
BOOST_TEST(i3.value==3);
BOOST_TEST_EQ(i0.value, 0);
BOOST_TEST_EQ(i1.value, 1);
BOOST_TEST_EQ(i2.value, 2);
BOOST_TEST_EQ(i3.value, 3);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

10
test/defer_nested_new_error_result_test.cpp
View File

@@ -44,17 +44,17 @@ int main()
},
[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
{
BOOST_TEST(i0.value==0);
BOOST_TEST(i1.value==1);
BOOST_TEST(i2.value==2);
BOOST_TEST(i3.value==3);
BOOST_TEST_EQ(i0.value, 0);
BOOST_TEST_EQ(i1.value, 1);
BOOST_TEST_EQ(i2.value, 2);
BOOST_TEST_EQ(i3.value, 3);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

4
test/defer_nested_success_exception_test.cpp
View File

@@ -39,14 +39,14 @@ int main()
},
[ ]( info x )
{
BOOST_TEST(x.value==2);
BOOST_TEST_EQ(x.value, 2);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

4
test/defer_nested_success_result_test.cpp
View File

@@ -41,14 +41,14 @@ int main()
},
[ ]( info x )
{
BOOST_TEST(x.value==2);
BOOST_TEST_EQ(x.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
return boost::report_errors();
}

4
test/diagnostic_info_test.cpp
View File

@@ -103,7 +103,7 @@ int main()
BOOST_TEST(s.find("*** printable_info_non_printable_payload ***")!=s.npos);
BOOST_TEST(s.find("*** printable_info_printable_payload printed printable_payload ***")!=s.npos);
BOOST_TEST(s.find(") in function")!=s.npos);
BOOST_TEST(s.find("unexpected")==s.npos);
BOOST_TEST_EQ(s.find("unexpected"), s.npos);
std::cout << s;
} );
@@ -142,7 +142,7 @@ int main()
BOOST_TEST(s.find(") in function")!=s.npos);
BOOST_TEST(s.find("Detected 2 attempts")!=s.npos);
BOOST_TEST(s.find("unexpected_test<1>")!=s.npos);
BOOST_TEST(s.find("unexpected_test<2>")==s.npos);
BOOST_TEST_EQ(s.find("unexpected_test<2>"), s.npos);
std::cout << s;
} );

6
test/exception_to_result_test.cpp
View File

@@ -37,7 +37,7 @@ int main()
{
return 3;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
{
int r = leaf::handle_all(
@@ -61,7 +61,7 @@ int main()
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
{
int r = leaf::handle_all(
@@ -85,7 +85,7 @@ int main()
{
return 3;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
return boost::report_errors();
}

10
test/handle_all_other_result_test.cpp
View File

@@ -84,7 +84,7 @@ int main()
{
return -1;
} );
BOOST_TEST(r==42);
BOOST_TEST_EQ(r, 42);
}
{
int r = leaf::handle_all(
@@ -93,21 +93,21 @@ int main()
auto r = g(false);
BOOST_TEST(!r);
auto ec = r.error();
BOOST_TEST(ec.message()=="LEAF error, use with leaf::handle_some or leaf::handle_all.");
BOOST_TEST_EQ(ec.message(), "LEAF error, use with leaf::handle_some or leaf::handle_all.");
BOOST_TEST(!std::strcmp(ec.category().name(),"LEAF error, use with leaf::handle_some or leaf::handle_all."));
return r;
},
[ ]( info<42> const & x, std::error_code const & ec )
{
BOOST_TEST(x.value==42);
BOOST_TEST(ec==make_error_code(std::errc::no_such_file_or_directory));
BOOST_TEST_EQ(x.value, 42);
BOOST_TEST_EQ(ec, make_error_code(std::errc::no_such_file_or_directory));
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
return boost::report_errors();
}

116
test/handle_all_test.cpp
View File

@@ -55,10 +55,10 @@ int main()
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(c==42);
BOOST_TEST_EQ(c, 42);
}
// void, handle_all (failure)
@@ -74,17 +74,17 @@ int main()
[&c]( error_code ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==error_code::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
}
// void, handle_all (failure), match cond_x (single enum value)
@@ -99,23 +99,23 @@ int main()
},
[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_all (failure), match enum (single enum value)
@@ -130,23 +130,23 @@ int main()
},
[&c]( leaf::match<error_code,error_code::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::match<error_code,error_code::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==error_code::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_all (failure), match enum (multiple enum values)
@@ -161,23 +161,23 @@ int main()
},
[&c]( leaf::match<error_code,error_code::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::match<error_code,error_code::error2,error_code::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==error_code::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_all (failure), match value (single value)
@@ -192,23 +192,23 @@ int main()
},
[&c]( leaf::match<e_error_code,error_code::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::match<e_error_code,error_code::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==error_code::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_all (failure), match value (multiple values)
@@ -223,23 +223,23 @@ int main()
},
[&c]( leaf::match<e_error_code,error_code::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::match<e_error_code,error_code::error2,error_code::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==error_code::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
//////////////////////////////////////
@@ -256,7 +256,7 @@ int main()
{
return 1;
} );
BOOST_TEST(r==42);
BOOST_TEST_EQ(r, 42);
}
// int, handle_all (failure)
@@ -270,15 +270,15 @@ int main()
[ ]( error_code ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==error_code::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
// int, handle_all (failure), match cond_x (single enum value)
@@ -295,16 +295,16 @@ int main()
},
[ ]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_all (failure), match enum (single enum value)
@@ -322,15 +322,15 @@ int main()
[ ]( leaf::match<error_code,error_code::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==error_code::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_all (failure), match enum (multiple enum values)
@@ -348,15 +348,15 @@ int main()
[ ]( leaf::match<error_code,error_code::error2,error_code::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==error_code::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_all (failure), match value (single value)
@@ -374,15 +374,15 @@ int main()
[ ]( leaf::match<e_error_code,error_code::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==error_code::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_all (failure), match value (multiple values)
@@ -400,15 +400,15 @@ int main()
[ ]( leaf::match<e_error_code,error_code::error2,error_code::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==error_code::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
return boost::report_errors();

16
test/handle_basic_test.cpp
View File

@@ -79,8 +79,8 @@ leaf::result<void> handle_some_errors_void( int what_to_do )
int main()
{
BOOST_TEST(handle_some_errors(0).value()==42);
BOOST_TEST(handle_some_errors(1).value()==-42);
BOOST_TEST_EQ(handle_some_errors(0).value(), 42);
BOOST_TEST_EQ(handle_some_errors(1).value(), -42);
{
int r = leaf::handle_all(
[ ]() -> leaf::result<int>
@@ -97,13 +97,13 @@ int main()
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
///////////////////////////
BOOST_TEST(handle_some_errors_float(0).value()==42.0f);
BOOST_TEST(handle_some_errors_float(2).value()==-42.0f);
BOOST_TEST_EQ(handle_some_errors_float(0).value(), 42.0f);
BOOST_TEST_EQ(handle_some_errors_float(2).value(), -42.0f);
{
int r = leaf::handle_all(
[ ]() -> leaf::result<int>
@@ -120,7 +120,7 @@ int main()
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
///////////////////////////
@@ -142,7 +142,7 @@ int main()
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
///////////////////////////
@@ -162,7 +162,7 @@ int main()
{
return 2;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
return boost::report_errors();

8
test/handle_some_other_result_test.cpp
View File

@@ -37,7 +37,7 @@ int main()
return g(true);
} );
BOOST_TEST(r);
BOOST_TEST(r.value()==42);
BOOST_TEST_EQ(r.value(), 42);
}
{
int called = 0;
@@ -47,18 +47,18 @@ int main()
auto r = g(false);
BOOST_TEST(!r);
auto ec = r.error();
BOOST_TEST(ec.message()=="LEAF error, use with leaf::handle_some or leaf::handle_all.");
BOOST_TEST_EQ(ec.message(), "LEAF error, use with leaf::handle_some or leaf::handle_all.");
BOOST_TEST(!std::strcmp(ec.category().name(),"LEAF error, use with leaf::handle_some or leaf::handle_all."));
return r;
},
[&]( info<42> const & x, leaf::match<leaf::condition<cond_x>, cond_x::x00> ec )
{
called = 1;
BOOST_TEST(x.value==42);
BOOST_TEST_EQ(x.value, 42);
return ec.value();
} );
BOOST_TEST(!r);
BOOST_TEST(r.error() == make_error_code(errc_a::a0));
BOOST_TEST_EQ(r.error(), make_error_code(errc_a::a0));
BOOST_TEST(called);
}
return boost::report_errors();

348
test/handle_some_test.cpp
View File

@@ -56,12 +56,12 @@ int main()
},
[&c]( leaf::error_info const & unmatched )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
return unmatched.error();
} );
BOOST_TEST(r);
BOOST_TEST(c==42);
BOOST_TEST_EQ(c, 42);
}
// void, handle_some (failure, matched)
@@ -77,12 +77,12 @@ int main()
[&c]( not_error_code_enum ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
BOOST_TEST(r);
}
@@ -98,13 +98,13 @@ int main()
},
[&c]( leaf::match<leaf::condition<cond_x>,cond_x::x00> ec, info<1> const & x, info<2> const & y )
{
BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
BOOST_TEST(r);
}
@@ -120,18 +120,18 @@ int main()
},
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
BOOST_TEST(r);
}
@@ -147,18 +147,18 @@ int main()
},
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
BOOST_TEST(r);
}
@@ -174,18 +174,18 @@ int main()
},
[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
BOOST_TEST(r);
}
@@ -201,18 +201,18 @@ int main()
},
[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
BOOST_TEST(r);
}
@@ -231,27 +231,27 @@ int main()
},
[&c]( info<4> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(!r);
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
return r;
},
[&c]( not_error_code_enum ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_some (failure, initially not matched), match cond_x (single enum value)
@@ -269,27 +269,27 @@ int main()
},
[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(!r);
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
return r;
},
[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_some (failure, initially not matched), match enum (single enum value)
@@ -307,27 +307,27 @@ int main()
},
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(!r);
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
return r;
},
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_some (failure, initially not matched), match enum (multiple enum values)
@@ -345,27 +345,27 @@ int main()
},
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(!r);
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
return r;
},
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_some (failure, initially not matched), match value (single value)
@@ -383,27 +383,27 @@ int main()
},
[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(!r);
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
return r;
},
[&c]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_some (failure, initially not matched), match value (multiple values)
@@ -421,27 +421,27 @@ int main()
},
[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(!r);
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
return r;
},
[&c]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_some (failure, initially matched)
@@ -460,26 +460,26 @@ int main()
[&c]( not_error_code_enum ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(r);
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
return r;
},
[&c]( info<4> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
}
// void, handle_some (failure, initially matched), match cond_x (single enum value)
@@ -497,27 +497,27 @@ int main()
},
[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(r);
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
return r;
},
[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
}
// void, handle_some (failure, initially matched), match enum (single enum value)
@@ -536,26 +536,26 @@ int main()
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(r);
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
return r;
},
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
}
// void, handle_some (failure, initially matched), match enum (multiple enum values)
@@ -574,26 +574,26 @@ int main()
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(r);
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
return r;
},
[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
}
// void, handle_some (failure, initially matched), match value (single value)
@@ -612,26 +612,26 @@ int main()
[&c]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(r);
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
return r;
},
[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
}
// void, handle_some (failure, initially matched), match value (multiple values)
@@ -650,26 +650,26 @@ int main()
[&c]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(r);
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
return r;
},
[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]()
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
}
//////////////////////////////////////
@@ -686,7 +686,7 @@ int main()
{
return unmatched.error();
} );
BOOST_TEST(r && *r==42);
BOOST_TEST_EQ(*r, 42);
}
// int, handle_some (failure, matched)
@@ -700,11 +700,12 @@ int main()
[ ]( not_error_code_enum ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 1;
} );
BOOST_TEST(r && *r==1);
BOOST_TEST(r);
BOOST_TEST_EQ(*r, 1);
}
// int, handle_some (failure, matched), match cond_x (single enum value)
@@ -721,12 +722,13 @@ int main()
},
[ ]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
} );
BOOST_TEST(r && *r==2);
BOOST_TEST(r);
BOOST_TEST_EQ(*r, 2);
}
// int, handle_some (failure, matched), match enum (single enum value)
@@ -744,11 +746,12 @@ int main()
[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
} );
BOOST_TEST(r && *r==2);
BOOST_TEST(r);
BOOST_TEST_EQ(*r, 2);
}
// int, handle_some (failure, matched), match enum (multiple enum values)
@@ -766,11 +769,12 @@ int main()
[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
} );
BOOST_TEST(r && *r==2);
BOOST_TEST(r);
BOOST_TEST_EQ(*r, 2);
}
// int, handle_some (failure, matched), match value (single value)
@@ -788,11 +792,12 @@ int main()
[ ]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
} );
BOOST_TEST(r && *r==2);
BOOST_TEST(r);
BOOST_TEST_EQ(*r, 2);
}
// int, handle_some (failure, matched), match value (multiple values)
@@ -810,11 +815,12 @@ int main()
[ ]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
} );
BOOST_TEST(r && *r==2);
BOOST_TEST(r);
BOOST_TEST_EQ(*r, 2);
}
// int, handle_some (failure, initially not matched)
@@ -838,15 +844,15 @@ int main()
[ ]( not_error_code_enum ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_some (failure, initially not matched), match cond_x (single enum value)
@@ -869,16 +875,16 @@ int main()
},
[ ]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_some (failure, initially not matched), match enum (single enum value)
@@ -902,15 +908,15 @@ int main()
[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_some (failure, initially not matched), match enum (multiple enum values)
@@ -934,15 +940,15 @@ int main()
[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_some (failure, initially not matched), match value (single value)
@@ -966,15 +972,15 @@ int main()
[ ]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_some (failure, initially not matched), match value (multiple values)
@@ -998,15 +1004,15 @@ int main()
[ ]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_some (failure, initially matched)
@@ -1023,8 +1029,8 @@ int main()
[ ]( not_error_code_enum ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 1;
} );
BOOST_TEST(r);
@@ -1038,7 +1044,7 @@ int main()
{
return 3;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
// int, handle_some (failure, initially matched), match enum (single enum value)
@@ -1055,8 +1061,8 @@ int main()
[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 1;
} );
BOOST_TEST(r);
@@ -1070,7 +1076,7 @@ int main()
{
return 3;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
// int, handle_some (failure, initially matched), match enum (multiple enum values)
@@ -1087,8 +1093,8 @@ int main()
[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 1;
} );
BOOST_TEST(r);
@@ -1102,7 +1108,7 @@ int main()
{
return 3;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
// int, handle_some (failure, initially matched), match value (single value)
@@ -1119,8 +1125,8 @@ int main()
[ ]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 1;
} );
BOOST_TEST(r);
@@ -1134,7 +1140,7 @@ int main()
{
return 3;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
// int, handle_some (failure, initially matched), match value (multiple values)
@@ -1151,8 +1157,8 @@ int main()
[ ]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(ec.value()==not_error_code_enum::error1);
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 1;
} );
BOOST_TEST(r);
@@ -1166,7 +1172,7 @@ int main()
{
return 3;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
return boost::report_errors();

6
test/multiple_errors_test.cpp
View File

@@ -42,14 +42,14 @@ int main()
},
[ ]( info<2> const & x, info<3> const & y )
{
BOOST_TEST(x.value==2);
BOOST_TEST(y.value==3);
BOOST_TEST_EQ(x.value, 2);
BOOST_TEST_EQ(y.value, 3);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
return boost::report_errors();
}

166
test/optional_test.cpp
View File

@@ -88,19 +88,19 @@ void run_tests()
BOOST_TEST(!value_count);
{
my_info a(42);
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
optional<my_info> x(a);
BOOST_TEST(object_count==2);
BOOST_TEST(value_count==2);
BOOST_TEST_EQ(object_count, 2);
BOOST_TEST_EQ(value_count, 2);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
throws_on_copy a;
BOOST_TEST(object_count==1);
BOOST_TEST_EQ(object_count, 1);
try
{
optional<throws_on_copy> x(a);
@@ -114,86 +114,86 @@ void run_tests()
BOOST_TEST(!value_count);
{
my_info a(42);
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
optional<my_info> x(std::move(a));
BOOST_TEST(object_count==2);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 2);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
optional<my_info> x(my_info(42));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
optional<my_info> y(x);
BOOST_TEST(object_count==2);
BOOST_TEST(value_count==2);
BOOST_TEST_EQ(object_count, 2);
BOOST_TEST_EQ(value_count, 2);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
BOOST_TEST(y.has_value());
BOOST_TEST(y.value().value==42);
BOOST_TEST_EQ(y.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
optional<my_info> x(my_info(42));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
optional<my_info> y(std::move(x));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(!x.has_value());
BOOST_TEST(y.has_value());
BOOST_TEST(y.value().value==42);
BOOST_TEST_EQ(y.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
optional<my_info> x(my_info(42));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
optional<my_info> y;
BOOST_TEST(&(y=x)==&y);
BOOST_TEST(object_count==2);
BOOST_TEST(value_count==2);
BOOST_TEST_EQ(&(y=x), &y);
BOOST_TEST_EQ(object_count, 2);
BOOST_TEST_EQ(value_count, 2);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
BOOST_TEST(y.has_value());
BOOST_TEST(y.value().value==42);
BOOST_TEST_EQ(y.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
optional<my_info> x(my_info(42));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
optional<my_info> y(my_info(43));
BOOST_TEST(object_count==2);
BOOST_TEST(value_count==2);
BOOST_TEST(&(y=x)==&y);
BOOST_TEST(object_count==2);
BOOST_TEST(value_count==2);
BOOST_TEST_EQ(object_count, 2);
BOOST_TEST_EQ(value_count, 2);
BOOST_TEST_EQ(&(y=x), &y);
BOOST_TEST_EQ(object_count, 2);
BOOST_TEST_EQ(value_count, 2);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
BOOST_TEST(y.has_value());
BOOST_TEST(y.value().value==42);
BOOST_TEST_EQ(y.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
optional<throws_on_copy> x((throws_on_copy()));
BOOST_TEST(object_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST(x.has_value());
optional<throws_on_copy> y;
try
@@ -203,7 +203,7 @@ void run_tests()
catch( std::exception & )
{
}
BOOST_TEST(object_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST(x.has_value());
BOOST_TEST(!y.has_value());
}
@@ -211,35 +211,35 @@ void run_tests()
BOOST_TEST(!value_count);
{
optional<my_info> x(my_info(42));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
optional<my_info> y;
BOOST_TEST(&(y=std::move(x))==&y);
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(&(y=std::move(x)), &y);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(!x.has_value());
BOOST_TEST(y.has_value());
BOOST_TEST(y.value().value==42);
BOOST_TEST_EQ(y.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
optional<my_info> x(my_info(42));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
optional<my_info> y(my_info(43));
BOOST_TEST(object_count==2);
BOOST_TEST(value_count==2);
BOOST_TEST(&(y=std::move(x))==&y);
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 2);
BOOST_TEST_EQ(value_count, 2);
BOOST_TEST_EQ(&(y=std::move(x)), &y);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(!x.has_value());
BOOST_TEST(y.has_value());
BOOST_TEST(y.value().value==42);
BOOST_TEST_EQ(y.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
@@ -247,64 +247,64 @@ void run_tests()
optional<my_info> x;
my_info a(42);
x.put(a);
BOOST_TEST(object_count==2);
BOOST_TEST(value_count==2);
BOOST_TEST_EQ(object_count, 2);
BOOST_TEST_EQ(value_count, 2);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
optional<my_info> x(my_info(43));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
my_info a(42);
x.put(a);
BOOST_TEST(object_count==2);
BOOST_TEST(value_count==2);
BOOST_TEST_EQ(object_count, 2);
BOOST_TEST_EQ(value_count, 2);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
optional<my_info> x;
x.put(my_info(42));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
optional<my_info> x(my_info(43));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
x.put(my_info(42));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(x.has_value());
BOOST_TEST(x.value().value==42);
BOOST_TEST_EQ(x.value().value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
optional<my_info> x(my_info(42));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
my_info a = std::move(x).value();
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(!x.has_value());
BOOST_TEST(a.value==42);
BOOST_TEST_EQ(a.value, 42);
}
BOOST_TEST(!object_count);
BOOST_TEST(!value_count);
{
optional<my_info> x(my_info(42));
BOOST_TEST(object_count==1);
BOOST_TEST(value_count==1);
BOOST_TEST_EQ(object_count, 1);
BOOST_TEST_EQ(value_count, 1);
BOOST_TEST(x.has_value());
x.reset();
BOOST_TEST(!x.has_value());

4
test/preload_basic_test.cpp
View File

@@ -36,13 +36,13 @@ int main()
},
[ ]( info const & i42 )
{
BOOST_TEST(i42.value==42);
BOOST_TEST_EQ(i42.value, 42);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

10
test/preload_nested_error_exception_test.cpp
View File

@@ -52,17 +52,17 @@ int main()
},
[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
{
BOOST_TEST(i0.value==0);
BOOST_TEST(i1.value==1);
BOOST_TEST(i2.value==2);
BOOST_TEST(i3.value==3);
BOOST_TEST_EQ(i0.value, 0);
BOOST_TEST_EQ(i1.value, 1);
BOOST_TEST_EQ(i2.value, 2);
BOOST_TEST_EQ(i3.value, 3);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

10
test/preload_nested_error_result_test.cpp
View File

@@ -43,17 +43,17 @@ int main()
},
[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
{
BOOST_TEST(i0.value==0);
BOOST_TEST(i1.value==1);
BOOST_TEST(i2.value==2);
BOOST_TEST(i3.value==3);
BOOST_TEST_EQ(i0.value, 0);
BOOST_TEST_EQ(i1.value, 1);
BOOST_TEST_EQ(i2.value, 2);
BOOST_TEST_EQ(i3.value, 3);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

10
test/preload_nested_new_error_exception_test.cpp
View File

@@ -59,17 +59,17 @@ int main()
},
[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
{
BOOST_TEST(i0.value==0);
BOOST_TEST(i1.value==1);
BOOST_TEST(i2.value==2);
BOOST_TEST(i3.value==3);
BOOST_TEST_EQ(i0.value, 0);
BOOST_TEST_EQ(i1.value, 1);
BOOST_TEST_EQ(i2.value, 2);
BOOST_TEST_EQ(i3.value, 3);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

10
test/preload_nested_new_error_result_test.cpp
View File

@@ -44,17 +44,17 @@ int main()
},
[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
{
BOOST_TEST(i0.value==0);
BOOST_TEST(i1.value==1);
BOOST_TEST(i2.value==2);
BOOST_TEST(i3.value==3);
BOOST_TEST_EQ(i0.value, 0);
BOOST_TEST_EQ(i1.value, 1);
BOOST_TEST_EQ(i2.value, 2);
BOOST_TEST_EQ(i3.value, 3);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

4
test/preload_nested_success_exception_test.cpp
View File

@@ -39,14 +39,14 @@ int main()
},
[ ]( info x )
{
BOOST_TEST(x.value==2);
BOOST_TEST_EQ(x.value, 2);
return 1;
},
[ ]
{
return 2;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return boost::report_errors();
}

4
test/preload_nested_success_result_test.cpp
View File

@@ -41,14 +41,14 @@ int main()
},
[ ]( info x )
{
BOOST_TEST(x.value==2);
BOOST_TEST_EQ(x.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
return boost::report_errors();
}

8
test/result_bad_result_test.cpp
View File

@@ -29,7 +29,7 @@ int main()
return 0;
},
check );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
{
int r = leaf::try_(
@@ -40,7 +40,7 @@ int main()
return 0;
},
check );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
{
int r = leaf::try_(
@@ -51,7 +51,7 @@ int main()
return 0;
},
check );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
{
int r = leaf::try_(
@@ -62,7 +62,7 @@ int main()
return 0;
},
check );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
return boost::report_errors();
}

546
test/result_state_test.cpp
View File

@@ -94,314 +94,314 @@ int main()
{ // value default -> copy
leaf::result<val> r1;
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> copy
leaf::result<val> r1 = val();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> copy
val v;
leaf::result<val> r1 = v;
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==3);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 3);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> move
leaf::result<val> r1;
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> move
leaf::result<val> r1 = val();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> move
val v;
leaf::result<val> r1 = v;
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==3);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 3);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> assign-copy
leaf::result<val> r1;
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> assign-copy
leaf::result<val> r1 = val();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> assign-copy
val v;
leaf::result<val> r1 = v;
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==3);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 3);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> assign-move
leaf::result<val> r1;
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> assign-move
leaf::result<val> r1 = val();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> assign-move
val v;
leaf::result<val> r1 = v;
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==3);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 3);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> capture -> copy
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> capture -> copy
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(val()); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> capture -> copy
leaf::result<val> r1 = capture_result<e_err>( [ ]{ val v; return leaf::result<val>(v); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> capture -> move
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> capture -> move
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(val()); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> capture -> move
leaf::result<val> r1 = capture_result<e_err>( [ ]{ val v; return leaf::result<val>(v); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> capture -> assign-copy
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> capture -> assign-copy
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(val()); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> capture -> assign-copy
leaf::result<val> r1 = capture_result<e_err>( [ ]{ val v; return leaf::result<val>(v); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> capture -> assign-move
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> capture -> assign-move
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(val()); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> capture -> assign-move
leaf::result<val> r1 = capture_result<e_err>( [ ]{ val v; return leaf::result<val>(v); } )();
BOOST_TEST(r1);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(r2);
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
// ^^ value ^^
// vv error vv
@@ -411,201 +411,201 @@ int main()
exp.set_reset(true);
leaf::result<val> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> copy
static_store<e_err> exp;
exp.set_reset(true);
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<val> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> move
static_store<e_err> exp;
exp.set_reset(true);
leaf::result<val> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> move
static_store<e_err> exp;
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<val> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> assign copy
static_store<e_err> exp;
leaf::result<val> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> assign copy
static_store<e_err> exp;
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<val> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> assign move
static_store<e_err> exp;
leaf::result<val> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(!r2);
exp.handle_error(leaf::error_info(r2.error()), [ ]{ });
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> assign move
static_store<e_err> exp;
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<val> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> capture -> copy
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> capture -> copy
leaf::result<val> r1 = capture_result<e_err>( [ ] { leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> capture -> move
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> capture -> move
leaf::result<val> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> capture -> assign-copy
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> capture -> assign-copy
leaf::result<val> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> capture -> assign-move
leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> capture -> assign-move
leaf::result<val> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST(val::count==0);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
// ^^ result<T> ^^
@@ -677,168 +677,168 @@ int main()
exp.set_reset(true);
leaf::result<void> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> copy
static_store<e_err> exp;
exp.set_reset(true);
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<void> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> move
static_store<e_err> exp;
exp.set_reset(true);
leaf::result<void> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> move
static_store<e_err> exp;
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<void> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> assign copy
static_store<e_err> exp;
leaf::result<void> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> assign copy
static_store<e_err> exp;
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<void> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> assign move
static_store<e_err> exp;
leaf::result<void> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=std::move(r1);
BOOST_TEST(!r2);
exp.handle_error(leaf::error_info(r2.error()), [ ]{ });
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> assign move
static_store<e_err> exp;
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<void> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> capture -> copy
leaf::result<void> r1 = capture_result<e_err>( [ ]{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> capture -> copy
leaf::result<void> r1 = capture_result<e_err>( [ ] { leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> capture -> move
leaf::result<void> r1 = capture_result<e_err>( [ ]{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> capture -> move
leaf::result<void> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> capture -> assign-copy
leaf::result<void> r1 = capture_result<e_err>( [ ]{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> capture -> assign-copy
leaf::result<void> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> capture -> assign-move
leaf::result<void> r1 = capture_result<e_err>( [ ]{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> capture -> assign-move
leaf::result<void> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } )();
BOOST_TEST(!r1);
BOOST_TEST(err::count==1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST(r1.error()==r2.error());
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST(err::count==0);
BOOST_TEST_EQ(err::count, 0);
return boost::report_errors();
}

13
test/try_exception_and_result_test.cpp
View File

@@ -26,7 +26,8 @@ int main()
{
return { };
} );
BOOST_TEST(r && r.value()==42);
BOOST_TEST(r);
BOOST_TEST_EQ(r.value(), 42);
}
{
leaf::result<int> r = leaf::try_(
@@ -36,10 +37,11 @@ int main()
},
[ ]( leaf::catch_<my_exception>, info<1> const & x ) -> leaf::result<int>
{
BOOST_TEST(x.value==1);
BOOST_TEST_EQ(x.value, 1);
return 42;
} );
BOOST_TEST(r && r.value()==42);
BOOST_TEST(r);
BOOST_TEST_EQ(r.value(), 42);
}
{
leaf::result<int> r = leaf::try_(
@@ -49,10 +51,11 @@ int main()
},
[ ]( info<1> const & x ) -> leaf::result<int>
{
BOOST_TEST(x.value==1);
BOOST_TEST_EQ(x.value, 1);
return 42;
} );
BOOST_TEST(r && r.value()==42);
BOOST_TEST(r);
BOOST_TEST_EQ(r.value(), 42);
}
return boost::report_errors();
}

14
test/try_exception_test.cpp
View File

@@ -47,16 +47,16 @@ int test( F && f )
int main()
{
BOOST_TEST( 5==test( [ ] { throw my_error(); } ) );
BOOST_TEST_EQ( 5, test( [ ] { throw my_error(); } ) );
BOOST_TEST( 5==test( [ ] { throw leaf::exception(my_error()); } ) );
BOOST_TEST( 3==test( [ ] { throw leaf::exception(my_error(),info{42}); } ) );
BOOST_TEST_EQ( 5, test( [ ] { throw leaf::exception(my_error()); } ) );
BOOST_TEST_EQ( 3, test( [ ] { throw leaf::exception(my_error(),info{42}); } ) );
BOOST_TEST( 4==test( [ ] { throw LEAF_EXCEPTION(my_error()); } ) );
BOOST_TEST( 2==test( [ ] { throw LEAF_EXCEPTION(my_error(),info{42}); } ) );
BOOST_TEST_EQ( 4, test( [ ] { throw LEAF_EXCEPTION(my_error()); } ) );
BOOST_TEST_EQ( 2, test( [ ] { throw LEAF_EXCEPTION(my_error(),info{42}); } ) );
BOOST_TEST( 4==test( [ ] { LEAF_THROW(my_error()); } ) );
BOOST_TEST( 2==test( [ ] { LEAF_THROW(my_error(),info{42}); } ) );
BOOST_TEST_EQ( 4, test( [ ] { LEAF_THROW(my_error()); } ) );
BOOST_TEST_EQ( 2, test( [ ] { LEAF_THROW(my_error(),info{42}); } ) );
return boost::report_errors();
}

154
test/try_test.cpp
View File

@@ -40,10 +40,10 @@ int main()
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(c==42);
BOOST_TEST_EQ(c, 42);
}
// void, handle_all (failure), match_enum (single enum value)
@@ -56,22 +56,22 @@ int main()
},
[&c]( leaf::catch_<error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::catch_<error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_all (failure), match_enum (multiple enum values)
@@ -84,22 +84,22 @@ int main()
},
[&c]( leaf::catch_<error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_all (failure), match_value (single value)
@@ -112,22 +112,22 @@ int main()
},
[&c]( leaf::catch_<error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::catch_<error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_all (failure), match_value (multiple values)
@@ -140,22 +140,22 @@ int main()
},
[&c]( leaf::catch_<error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
},
[&c]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
//////////////////////////////////////
@@ -173,24 +173,24 @@ int main()
},
[&c]( leaf::catch_<error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(false);
},
[&c]( leaf::catch_<error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_some (failure, initially not matched), match_enum (multiple enum values)
@@ -206,24 +206,24 @@ int main()
},
[&c]( leaf::catch_<error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
BOOST_TEST(false);
},
[&c]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==2);
BOOST_TEST_EQ(c, 2);
}
// void, handle_some (failure, initially matched), match_enum (single enum value)
@@ -239,23 +239,23 @@ int main()
},
[&c]( leaf::catch_<error1> ec, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
},
[&c]( leaf::catch_<error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
}
// void, handle_some (failure, initially matched), match_enum (multiple enum values)
@@ -271,23 +271,23 @@ int main()
},
[&c]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST(c==0);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
BOOST_TEST_EQ(c, 0);
c = 1;
} );
},
[&c]( leaf::catch_<error2> )
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 2;
},
[&c]
{
BOOST_TEST(c==0);
BOOST_TEST_EQ(c, 0);
c = 3;
} );
BOOST_TEST(c==1);
BOOST_TEST_EQ(c, 1);
}
//////////////////////////////////////
@@ -303,7 +303,7 @@ int main()
{
return 1;
} );
BOOST_TEST(r==42);
BOOST_TEST_EQ(r, 42);
}
// int, handle_all (failure), match_enum (single enum value)
@@ -319,15 +319,15 @@ int main()
},
[ ]( leaf::catch_<error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_all (failure), match_enum (multiple enum values)
@@ -343,15 +343,15 @@ int main()
},
[ ]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
//////////////////////////////////////
@@ -369,11 +369,11 @@ int main()
},
[ ]( leaf::catch_<error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_some (failure, matched), match_enum (multiple enum values)
@@ -389,11 +389,11 @@ int main()
},
[ ]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_some (failure, initially not matched), match_enum (single enum value)
@@ -415,15 +415,15 @@ int main()
},
[ ]( leaf::catch_<error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_some (failure, initially not matched), match_enum (multiple enum values)
@@ -445,15 +445,15 @@ int main()
},
[ ]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 2;
},
[ ]
{
return 3;
} );
BOOST_TEST(r==2);
BOOST_TEST_EQ(r, 2);
}
// int, handle_some (failure, initially matched), match_enum (single enum value)
@@ -468,11 +468,11 @@ int main()
},
[ ]( leaf::catch_<error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 1;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return r;
},
[ ]( leaf::catch_<error1> )
@@ -483,7 +483,7 @@ int main()
{
return 3;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
// int, handle_some (failure, initially matched), match_enum (multiple enum values)
@@ -498,11 +498,11 @@ int main()
},
[ ]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
{
BOOST_TEST(x.value==1);
BOOST_TEST(y.value==2);
BOOST_TEST_EQ(x.value, 1);
BOOST_TEST_EQ(y.value, 2);
return 1;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
return r;
},
[ ]( leaf::catch_<error1> )
@@ -513,7 +513,7 @@ int main()
{
return 3;
} );
BOOST_TEST(r==1);
BOOST_TEST_EQ(r, 1);
}
//////////////////////////////////////