boost/leaf
2
0
Fork 0
mirror of https://github.com/boostorg/leaf.git synced 2026-01-24 18:02:22 +00:00
Code Issues Projects Releases Wiki Activity
Files
9368aa2226df24547b831751fb21396092c13e79
leaf/test/result_state_test.cpp

867 lines
25 KiB
C++
Raw Blame History

// Copyright (c) 2018-2019 Emil Dotchevski and Reverge Studios, 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/result.hpp>
#include <boost/leaf/capture.hpp>
#include <boost/leaf/handle_error.hpp>
#include "lightweight_test.hpp"
namespace leaf = boost::leaf;
struct val
{
static int id_count;
static int count;
int id;
val():
id(++id_count)
{
++count;
}
val( val const & x ):
id(x.id)
{
++count;
}
val( val && x ):
id(x.id)
{
++count;
}
~val()
{
--count;
}
friend bool operator==( val const & a, val const & b )
{
return a.id==b.id;
}
};
int val::count = 0;
int val::id_count = 0;
struct err
{
static int count;
err()
{
++count;
}
err( err const & )
{
++count;
}
err( err && )
{
++count;
}
~err()
{
--count;
}
};
int err::count = 0;
struct e_err { err value; };
bool eq_value( leaf::result<val> & r1, leaf::result<val> & r2 )
{
leaf::result<val> const & cr1 = r1;
leaf::result<val> const & cr2 = r2;
return
r1.value()==r2.value() &&
cr1.value()==cr2.value() &&
*r1==*r2 &&
*cr1==*cr2 &&
r1->id==r2->id &&
cr1->id==cr2->id;
}
int main()
{
{ // value default -> copy
leaf::result<val> r1;
BOOST_TEST(r1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 3);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> move
leaf::result<val> r1;
BOOST_TEST(r1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 3);
}
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 3);
BOOST_TEST(eq_value(r1,r2));
}
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 3);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> capture -> copy
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>(); } );
BOOST_TEST(r1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> capture -> copy
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>(val()); } );
BOOST_TEST(r1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> capture -> copy
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ val v; return leaf::result<val>(v); } );
BOOST_TEST(r1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> capture -> move
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>(); } );
BOOST_TEST(r1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> capture -> move
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>(val()); } );
BOOST_TEST(r1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> capture -> move
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ val v; return leaf::result<val>(v); } );
BOOST_TEST(r1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> capture -> assign-copy
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>(); } );
BOOST_TEST(r1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> capture -> assign-copy
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>(val()); } );
BOOST_TEST(r1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> capture -> assign-copy
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ val v; return leaf::result<val>(v); } );
BOOST_TEST(r1);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 1);
leaf::result<val> r2; r2=r1;
BOOST_TEST(r2);
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
BOOST_TEST(eq_value(r1,r2));
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value default -> capture -> assign-move
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>(); } );
BOOST_TEST(r1);
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value move -> capture -> assign-move
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>(val()); } );
BOOST_TEST(r1);
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // value copy -> capture -> assign-move
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ val v; return leaf::result<val>(v); } );
BOOST_TEST(r1);
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_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 2);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
// ^^ value ^^
// vv error vv
{ // error move -> copy
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::do_not_propagate);
leaf::result<val> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> copy
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::do_not_propagate);
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<val> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> move
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::do_not_propagate);
leaf::result<val> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> move
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::propagate);
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<val> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> assign copy
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::propagate);
leaf::result<val> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> assign copy
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::propagate);
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<val> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> assign move
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::propagate);
leaf::result<val> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=std::move(r1);
BOOST_TEST(!r2);
{
val x;
BOOST_TEST(ctx.handle_all(r2, [&]{ return x; }) == x);
}
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> assign move
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::propagate);
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<val> r1 = err;
BOOST_TEST(!r1);
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_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> capture -> copy
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> capture -> copy
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), [] { leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> capture -> move
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } );
BOOST_TEST(!r1);
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);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> capture -> move
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } );
BOOST_TEST(!r1);
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);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> capture -> assign-copy
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> capture -> assign-copy
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
BOOST_TEST_EQ(val::count, 0);
leaf::result<val> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error move -> capture -> assign-move
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } );
BOOST_TEST(!r1);
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);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
{ // error copy -> capture -> assign-move
leaf::result<val> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } );
BOOST_TEST(!r1);
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);
}
BOOST_TEST_EQ(err::count, 0);
BOOST_TEST_EQ(val::count, 0);
// ^^ result<T> ^^
/////////////////////////////////////////////////////////////
// vv result<void> vv
{ // void default -> copy
leaf::result<void> r1;
BOOST_TEST(r1);
leaf::result<void> r2 = r1;
BOOST_TEST(r2);
}
{ // void default -> move
leaf::result<void> r1;
BOOST_TEST(r1);
leaf::result<void> r2 = std::move(r1);
BOOST_TEST(r2);
}
{ // void default -> assign-copy
leaf::result<void> r1;
BOOST_TEST(r1);
leaf::result<void> r2; r2=r1;
BOOST_TEST(r2);
}
{ // void default -> assign-move
leaf::result<void> r1;
BOOST_TEST(r1);
leaf::result<void> r2; r2=std::move(r1);
BOOST_TEST(r2);
}
{ // void default -> capture -> copy
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<void>(); } );
BOOST_TEST(r1);
leaf::result<void> r2 = r1;
BOOST_TEST(r2);
}
{ // void default -> capture -> move
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<void>(); } );
BOOST_TEST(r1);
leaf::result<void> r2 = std::move(r1);
BOOST_TEST(r2);
}
{ // void default -> capture -> assign-copy
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<void>(); } );
BOOST_TEST(r1);
leaf::result<void> r2; r2=r1;
BOOST_TEST(r2);
}
{ // void default -> capture -> assign-move
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<void>(); } );
BOOST_TEST(r1);
leaf::result<void> r2; r2=std::move(r1);
BOOST_TEST(r2);
}
// ^^ void default ^^
// vv void error vv
{ // void error move -> copy
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::do_not_propagate);
leaf::result<void> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> copy
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::do_not_propagate);
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<void> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> move
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::do_not_propagate);
leaf::result<void> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> move
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::propagate);
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<void> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> assign copy
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::propagate);
leaf::result<void> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> assign copy
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::propagate);
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<void> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> assign move
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::propagate);
leaf::result<void> r1 = leaf::new_error( e_err { } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=std::move(r1);
BOOST_TEST(!r2);
ctx.handle_all(r2, []{ });
BOOST_TEST_EQ(err::count, 1);
}
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> assign move
leaf::context<e_err> ctx;
leaf::context_activator<> active_context(ctx, leaf::on_deactivation::propagate);
leaf::error_id err = leaf::new_error( e_err{ } );
leaf::result<void> r1 = err;
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> capture -> copy
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> capture -> copy
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), [] { leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> capture -> move
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> capture -> move
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2 = std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> capture -> assign-copy
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> capture -> assign-copy
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=r1;
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error move -> capture -> assign-move
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{ // void error copy -> capture -> assign-move
leaf::result<void> r1 = leaf::capture( std::make_shared<leaf::context<e_err>>(), []{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } );
BOOST_TEST(!r1);
BOOST_TEST_EQ(err::count, 1);
leaf::result<void> r2; r2=std::move(r1);
BOOST_TEST(!r2);
BOOST_TEST_EQ(r1.error(), r2.error());
}
BOOST_TEST_EQ(err::count, 0);
{
leaf::result<int> r;
BOOST_TEST(r);
BOOST_TEST(!r.error());
}
{
leaf::result<void> r;
BOOST_TEST(r);
BOOST_TEST(!r.error());
}
return boost::report_errors();
}
Reference in New Issue View Git Blame Copy Permalink