283 lines
11 KiB
C++
283 lines
11 KiB
C++
// Copyright (c) 2018-2021 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)
|
|
|
|
#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
|
|
# include "leaf.hpp"
|
|
#else
|
|
# include <boost/leaf/result.hpp>
|
|
# include <boost/leaf/capture.hpp>
|
|
# include <boost/leaf/handle_errors.hpp>
|
|
#endif
|
|
|
|
#include "lightweight_test.hpp"
|
|
|
|
namespace leaf = boost::leaf;
|
|
|
|
struct val
|
|
{
|
|
int id;
|
|
|
|
friend bool operator==( val const & a, val const & b )
|
|
{
|
|
return a.id==b.id;
|
|
}
|
|
|
|
friend std::ostream & operator<<( std::ostream & os, val const & v )
|
|
{
|
|
return os << v.id;
|
|
}
|
|
};
|
|
|
|
struct base
|
|
{
|
|
};
|
|
|
|
struct derived: base
|
|
{
|
|
};
|
|
|
|
int main()
|
|
{
|
|
{
|
|
leaf::result<val const> r1, r2;
|
|
leaf::result<val const> & ref = r1;
|
|
leaf::result<val const> const & cref = r1;
|
|
leaf::result<val const> && rvref = std::move(r1);
|
|
leaf::result<val const> const && rvcref = std::move(r2);
|
|
|
|
static_assert(std::is_same<decltype(ref.value()), val const &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(cref.value()), val const &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(rvref.value())), val const &&>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(rvcref.value())), val const &&>::value, "result type deduction bug");
|
|
|
|
static_assert(std::is_same<decltype(*ref), val const &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(*cref), val const &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(*rvref)), val const &&>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(*rvcref)), val const &&>::value, "result type deduction bug");
|
|
|
|
auto & ref_id = ref->id; static_assert(std::is_same<decltype(ref_id), int const &>::value, "result type deduction bug");
|
|
auto & cref_id = cref->id; static_assert(std::is_same<decltype(cref_id), int const &>::value, "result type deduction bug");
|
|
auto & rvref_id = rvref->id; static_assert(std::is_same<decltype(rvref_id), int const &>::value, "result type deduction bug");
|
|
auto & rvcref_id = rvcref->id; static_assert(std::is_same<decltype(rvcref_id), int const &>::value, "result type deduction bug");
|
|
}
|
|
|
|
{
|
|
leaf::result<val> r1, r2;
|
|
leaf::result<val> & ref = r1;
|
|
leaf::result<val> const & cref = r1;
|
|
leaf::result<val> && rvref = std::move(r1);
|
|
leaf::result<val> const && rvcref = std::move(r2);
|
|
|
|
static_assert(std::is_same<decltype(ref.value()), val &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(cref.value()), val const &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(rvref.value())), val &&>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(rvcref.value())), val const &&>::value, "result type deduction bug");
|
|
|
|
static_assert(std::is_same<decltype(*ref), val &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(*cref), val const &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(*rvref)), val &&>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(*rvcref)), val const &&>::value, "result type deduction bug");
|
|
|
|
auto & ref_id = ref->id; static_assert(std::is_same<decltype(ref_id), int &>::value, "result type deduction bug");
|
|
auto & cref_id = cref->id; static_assert(std::is_same<decltype(cref_id), int const &>::value, "result type deduction bug");
|
|
auto & rvref_id = rvref->id; static_assert(std::is_same<decltype(rvref_id), int &>::value, "result type deduction bug");
|
|
auto & rvcref_id = rvcref->id; static_assert(std::is_same<decltype(rvcref_id), int const &>::value, "result type deduction bug");
|
|
}
|
|
|
|
{
|
|
val v;
|
|
leaf::result<val const &> r1(v), r2(v);
|
|
leaf::result<val const &> & ref = r1;
|
|
leaf::result<val const &> const & cref = r1;
|
|
leaf::result<val const &> && rvref = std::move(r1);
|
|
leaf::result<val const &> const && rvcref = std::move(r2);
|
|
|
|
static_assert(std::is_same<decltype(ref.value()), val const &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(cref.value()), val const &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(rvref.value())), val const &&>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(rvcref.value())), val const &&>::value, "result type deduction bug");
|
|
|
|
static_assert(std::is_same<decltype(*ref), val const &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(*cref), val const &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(*rvref)), val const &&>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(*rvcref)), val const &&>::value, "result type deduction bug");
|
|
|
|
auto & ref_id = ref->id; static_assert(std::is_same<decltype(ref_id), int const &>::value, "result type deduction bug");
|
|
auto & cref_id = cref->id; static_assert(std::is_same<decltype(cref_id), int const &>::value, "result type deduction bug");
|
|
auto & rvref_id = rvref->id; static_assert(std::is_same<decltype(rvref_id), int const &>::value, "result type deduction bug");
|
|
auto & rvcref_id = rvcref->id; static_assert(std::is_same<decltype(rvcref_id), int const &>::value, "result type deduction bug");
|
|
}
|
|
|
|
{
|
|
val v;
|
|
leaf::result<val &> r1(v), r2(v);
|
|
leaf::result<val &> & ref = r1;
|
|
leaf::result<val &> const & cref = r1;
|
|
leaf::result<val &> && rvref = std::move(r1);
|
|
leaf::result<val &> const && rvcref = std::move(r2);
|
|
|
|
static_assert(std::is_same<decltype(ref.value()), val &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(cref.value()), val &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(rvref.value())), val &&>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(rvcref.value())), val &&>::value, "result type deduction bug");
|
|
|
|
static_assert(std::is_same<decltype(*ref), val &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(*cref), val &>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(*rvref)), val &&>::value, "result type deduction bug");
|
|
static_assert(std::is_same<decltype(std::move(*rvcref)), val &&>::value, "result type deduction bug");
|
|
|
|
auto & ref_id = ref->id; static_assert(std::is_same<decltype(ref_id), int &>::value, "result type deduction bug");
|
|
auto & cref_id = cref->id; static_assert(std::is_same<decltype(cref_id), int &>::value, "result type deduction bug");
|
|
auto & rvref_id = rvref->id; static_assert(std::is_same<decltype(rvref_id), int &>::value, "result type deduction bug");
|
|
auto & rvcref_id = rvcref->id; static_assert(std::is_same<decltype(rvcref_id), int &>::value, "result type deduction bug");
|
|
}
|
|
|
|
// Mutable:
|
|
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val const &> r(x);
|
|
BOOST_TEST(r);
|
|
val a = r.value();
|
|
BOOST_TEST_EQ(a, x);
|
|
val b = *r;
|
|
BOOST_TEST_EQ(b, x);
|
|
}
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val const &> r(x);
|
|
BOOST_TEST(r);
|
|
val const & a = r.value();
|
|
BOOST_TEST_EQ(&a, &x);
|
|
val const & b = *r;
|
|
BOOST_TEST_EQ(&b, &x);
|
|
}
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val const &> r(x);
|
|
BOOST_TEST(r);
|
|
auto & a = r.value();
|
|
BOOST_TEST_EQ(&a, &x);
|
|
auto & b = *r;
|
|
BOOST_TEST_EQ(&b, &x);
|
|
}
|
|
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val &> r(x);
|
|
BOOST_TEST(r);
|
|
val a = r.value();
|
|
BOOST_TEST_EQ(a, x);
|
|
val b = *r;
|
|
BOOST_TEST_EQ(b, x);
|
|
int id = x.id;
|
|
BOOST_TEST_EQ(id+1, ++r->id);
|
|
}
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val &> r(x);
|
|
BOOST_TEST(r);
|
|
val & a = r.value();
|
|
BOOST_TEST_EQ(&a, &x);
|
|
val & b = *r;
|
|
BOOST_TEST_EQ(&b, &x);
|
|
int id = x.id;
|
|
BOOST_TEST_EQ(id+1, ++r->id);
|
|
}
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val &> r(x);
|
|
BOOST_TEST(r);
|
|
auto & a = r.value();
|
|
BOOST_TEST_EQ(&a, &x);
|
|
auto & b = *r;
|
|
BOOST_TEST_EQ(&b, &x);
|
|
int id = x.id;
|
|
BOOST_TEST_EQ(id+1, ++r->id);
|
|
}
|
|
|
|
// Const:
|
|
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val const &> const r(x);
|
|
BOOST_TEST(r);
|
|
val a = r.value();
|
|
BOOST_TEST_EQ(a, x);
|
|
val b = *r;
|
|
BOOST_TEST_EQ(b, x);
|
|
}
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val const &> const r(x);
|
|
BOOST_TEST(r);
|
|
val const & a = r.value();
|
|
BOOST_TEST_EQ(&a, &x);
|
|
val const & b = *r;
|
|
BOOST_TEST_EQ(&b, &x);
|
|
}
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val const &> const r(x);
|
|
BOOST_TEST(r);
|
|
auto & a = r.value();
|
|
BOOST_TEST_EQ(&a, &x);
|
|
auto & b = *r;
|
|
BOOST_TEST_EQ(&b, &x);
|
|
}
|
|
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val &> const r(x);
|
|
BOOST_TEST(r);
|
|
val a = r.value();
|
|
BOOST_TEST_EQ(a, x);
|
|
val b = *r;
|
|
BOOST_TEST_EQ(b, x);
|
|
int id = x.id;
|
|
BOOST_TEST_EQ(id+1, ++r->id);
|
|
}
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val &> const r(x);
|
|
BOOST_TEST(r);
|
|
val & a = r.value();
|
|
BOOST_TEST_EQ(&a, &x);
|
|
val & b = *r;
|
|
BOOST_TEST_EQ(&b, &x);
|
|
}
|
|
{
|
|
val x = { 42 };
|
|
leaf::result<val &> const r(x);
|
|
BOOST_TEST(r);
|
|
auto & a = r.value();
|
|
BOOST_TEST_EQ(&a, &x);
|
|
auto & b = *r;
|
|
BOOST_TEST_EQ(&b, &x);
|
|
int id = x.id;
|
|
BOOST_TEST_EQ(id+1, ++r->id);
|
|
}
|
|
|
|
// Hierarchy
|
|
|
|
{
|
|
derived d;
|
|
leaf::result<base &> r = d;
|
|
BOOST_TEST_EQ(&r.value(), &d);
|
|
BOOST_TEST_EQ(&*r, &d);
|
|
BOOST_TEST_EQ(r.operator->(), &d);
|
|
}
|
|
|
|
{
|
|
derived d;
|
|
leaf::result<base *> r = &d;
|
|
BOOST_TEST_EQ(r.value(), &d);
|
|
BOOST_TEST_EQ(*r, &d);
|
|
BOOST_TEST_EQ(*r.operator->(), &d);
|
|
}
|
|
|
|
return boost::report_errors();
|
|
}
|