boostorg/system
1
0
Fork 1
mirror of https://github.com/boostorg/system.git synced 2025-07-29 20:17:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

Add result<U&, E> specialization. Fixes #72.

Browse Source
This commit is contained in:
Peter Dimov
2023-09-12 03:34:24 +03:00
parent a57c568324
commit 951b3fe7b4
22 changed files with 1808 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
include/boost/system/result.hpp
View File

@ -649,6 +649,224 @@ template<class Ch, class Tr, class E> std::basic_ostream<Ch, Tr>& operator<<( st
return os;
}
// result<T&, E>
namespace detail
{
template<class U, class A> struct reference_to_temporary: std::integral_constant<bool,
!std::is_reference<A>::value ||
!std::is_convertible<typename std::remove_reference<A>::type*, U*>::value
> {};
} // namespace detail
template<class U, class E> class result<U&, E>
{
private:
variant2::variant<U*, E> v_;
public:
using value_type = U&;
using error_type = E;
static constexpr in_place_value_t in_place_value{};
static constexpr in_place_error_t in_place_error{};
public:
// constructors
// implicit, value
template<class A, typename std::enable_if<
std::is_convertible<A, U&>::value &&
!detail::reference_to_temporary<U, A>::value &&
!std::is_convertible<A, E>::value, int>::type = 0>
constexpr result( A&& a )
noexcept( std::is_nothrow_constructible<U&, A>::value )
: v_( in_place_value, &static_cast<U&>( std::forward<A>(a) ) )
{
}
// implicit, error
template<class A = E, class = void, typename std::enable_if<
std::is_convertible<A, E>::value &&
!std::is_convertible<A, U&>::value, int>::type = 0>
constexpr result( A&& a )
noexcept( std::is_nothrow_constructible<E, A>::value )
: v_( in_place_error, std::forward<A>(a) )
{
}
// explicit, value
template<class A, class En = typename std::enable_if<
detail::is_constructible<U&, A>::value &&
!std::is_convertible<A, U&>::value &&
!detail::reference_to_temporary<U, A>::value &&
!detail::is_constructible<E, A>::value
>::type>
explicit constexpr result( A&& a )
noexcept( std::is_nothrow_constructible<U&, A>::value )
: v_( in_place_value, &static_cast<U&>( std::forward<A>(a) ) )
{
}
// explicit, error
template<class... A, class En2 = void, class En = typename std::enable_if<
!detail::is_constructible<U&, A...>::value &&
detail::is_constructible<E, A...>::value &&
sizeof...(A) >= 1
>::type>
explicit constexpr result( A&&... a )
noexcept( std::is_nothrow_constructible<E, A...>::value )
: v_( in_place_error, std::forward<A>(a)... )
{
}
// tagged, value
template<class A, class En = typename std::enable_if<
std::is_constructible<U&, A>::value
>::type>
constexpr result( in_place_value_t, A&& a )
noexcept( std::is_nothrow_constructible<U&, A>::value )
: v_( in_place_value, &static_cast<U&>( std::forward<A>(a) ) )
{
}
// tagged, error
template<class... A, class En = typename std::enable_if<
std::is_constructible<E, A...>::value
>::type>
constexpr result( in_place_error_t, A&&... a )
noexcept( std::is_nothrow_constructible<E, A...>::value )
: v_( in_place_error, std::forward<A>(a)... )
{
}
// converting
template<class U2, class E2, class En = typename std::enable_if<
std::is_convertible<U2&, U&>::value &&
!detail::reference_to_temporary<U, U2&>::value &&
std::is_convertible<E2, E>::value &&
!std::is_convertible<result<U2&, E2> const&, U&>::value
>::type>
BOOST_CXX14_CONSTEXPR result( result<U2&, E2> const& r2 )
noexcept(
std::is_nothrow_constructible<U&, U2&>::value &&
std::is_nothrow_constructible<E, E2>::value &&
std::is_nothrow_default_constructible<E2>::value &&
std::is_nothrow_copy_constructible<E2>::value )
: v_( in_place_error, r2.error() )
{
if( r2 )
{
this->emplace( *r2 );
}
}
// queries
constexpr bool has_value() const noexcept
{
return v_.index() == 0;
}
constexpr bool has_error() const noexcept
{
return v_.index() == 1;
}
constexpr explicit operator bool() const noexcept
{
return v_.index() == 0;
}
// checked value access
BOOST_CXX14_CONSTEXPR U& value( boost::source_location const& loc = BOOST_CURRENT_LOCATION ) const
{
if( has_value() )
{
return *variant2::unsafe_get<0>( v_ );
}
else
{
throw_exception_from_error( variant2::unsafe_get<1>( v_ ), loc );
}
}
// unchecked value access
BOOST_CXX14_CONSTEXPR U* operator->() const noexcept
{
return has_value()? variant2::unsafe_get<0>( v_ ): 0;
}
BOOST_CXX14_CONSTEXPR U& operator*() const noexcept
{
U* p = operator->();
BOOST_ASSERT( p != 0 );
return *p;
}
// error access
constexpr E error() const &
noexcept( std::is_nothrow_default_constructible<E>::value && std::is_nothrow_copy_constructible<E>::value )
{
return has_error()? variant2::unsafe_get<1>( v_ ): E();
}
BOOST_CXX14_CONSTEXPR E error() &&
noexcept( std::is_nothrow_default_constructible<E>::value && std::is_nothrow_move_constructible<E>::value )
{
return has_error()? std::move( variant2::unsafe_get<1>( v_ ) ): E();
}
// emplace
template<class A, class En = typename std::enable_if<
detail::is_constructible<U&, A>::value &&
!detail::reference_to_temporary<U, A>::value
>::type>
BOOST_CXX14_CONSTEXPR U& emplace( A&& a )
{
return *v_.template emplace<0>( &static_cast<U&>( a ) );
}
// swap
BOOST_CXX14_CONSTEXPR void swap( result& r )
noexcept( noexcept( v_.swap( r.v_ ) ) )
{
v_.swap( r.v_ );
}
friend BOOST_CXX14_CONSTEXPR void swap( result & r1, result & r2 )
noexcept( noexcept( r1.swap( r2 ) ) )
{
r1.swap( r2 );
}
// equality
friend constexpr bool operator==( result const & r1, result const & r2 )
noexcept( noexcept( r1 && r2? *r1 == *r2: r1.v_ == r2.v_ ) )
{
return r1 && r2? *r1 == *r2: r1.v_ == r2.v_;
}
friend constexpr bool operator!=( result const & r1, result const & r2 )
noexcept( noexcept( !( r1 == r2 ) ) )
{
return !( r1 == r2 );
}
};
} // namespace system
} // namespace boost

3
test/CMakeLists.txt
View File

@ -164,3 +164,6 @@ boost_test(TYPE run SOURCES result_error_construct4.cpp)
boost_test(TYPE run SOURCES result_value_construct4.cpp)
boost_test(TYPE run SOURCES result_value_construct5.cpp)
boost_test(TYPE run SOURCES result_error_move.cpp)
boost_test(TYPE run SOURCES result_value_construct6.cpp)
boost_test(TYPE run SOURCES result_value_construct7.cpp)
boost_test(TYPE run SOURCES result_error_construct5.cpp)

3
test/Jamfile.v2
View File

@ -194,3 +194,6 @@ run result_error_construct4.cpp : : : $(CPP11) ;
run result_value_construct4.cpp : : : $(CPP11) ;
run result_value_construct5.cpp : : : $(CPP11) ;
run result_error_move.cpp : : : $(CPP11) ;
run result_value_construct6.cpp : : : $(CPP11) ;
run result_value_construct7.cpp : : : $(CPP11) ;
run result_error_construct5.cpp : : : $(CPP11) ;

40
test/result_convert_construct.cpp
View File

@ -181,6 +181,34 @@ int main()
BOOST_TEST_EQ( X::instances, 0 );
//
{
int x = 5;
result<int&> r( x );
result<int const&> r2 = r;
BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 5 );
}
{
int x = 6;
result<int&> const r( x );
result<int const&> r2 = r;
BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 6 );
}
{
int x = 7;
result<int const&> r2 = result<int&>( x );
BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 7 );
}
{
BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<long>, result<int>>));
BOOST_TEST_TRAIT_TRUE((std::is_convertible<result<int>, result<long>>));
@ -196,6 +224,18 @@ int main()
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int, void*>, result<int, int>>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<int, int>, result<int, void*>>));
BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int const&>, result<int&>>));
BOOST_TEST_TRAIT_TRUE((std::is_convertible<result<int&>, result<int const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, result<int>>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<int>, result<int const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, result<long&>>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<long&>, result<int const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, result<long const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<long const&>, result<int const&>>));
}
return boost::report_errors();

146
test/result_copy_assign.cpp
View File

@ -682,5 +682,151 @@ int main()
BOOST_TEST_EQ( r, r2 );
}
// reference
{
int x1 = 1;
int x2 = 2;
result<int&> r1( x1 );
result<int&> r2( x2 );
r2 = r1;
BOOST_TEST_EQ( x1, 1 );
BOOST_TEST_EQ( x2, 2 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r1, &*r2 );
}
{
int const x1 = 1;
int const x2 = 2;
result<int const&> r1( x1 );
result<int const&> r2( x2 );
r2 = r1;
BOOST_TEST_EQ( x1, 1 );
BOOST_TEST_EQ( x2, 2 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r1, &*r2 );
}
{
int x1 = 1;
result<int&> r1( x1 );
result<int&> r2( ENOENT, generic_category() );
r2 = r1;
BOOST_TEST_EQ( x1, 1 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r1, &*r2 );
}
{
int x1 = 1;
int x2 = 2;
result<int&> const r1( x1 );
result<int&> r2( x2 );
r2 = r1;
BOOST_TEST_EQ( x1, 1 );
BOOST_TEST_EQ( x2, 2 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r1, &*r2 );
}
{
int const x1 = 1;
int const x2 = 2;
result<int const &> const r1( x1 );
result<int const &> r2( x2 );
r2 = r1;
BOOST_TEST_EQ( x1, 1 );
BOOST_TEST_EQ( x2, 2 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r1, &*r2 );
}
{
int x1 = 1;
result<int&> const r1( x1 );
result<int&> r2( ENOENT, generic_category() );
r2 = r1;
BOOST_TEST_EQ( x1, 1 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r1, &*r2 );
}
{
int x2 = 2;
auto ec = make_error_code( errc::invalid_argument );
result<int&> r1( ec );
result<int&> r2( x2 );
r2 = r1;
BOOST_TEST_EQ( x2, 2 );
BOOST_TEST_EQ( r1, r2 );
}
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> r1( ec );
result<int&> r2( ENOENT, generic_category() );
r2 = r1;
BOOST_TEST_EQ( r1, r2 );
}
{
int x2 = 2;
auto ec = make_error_code( errc::invalid_argument );
result<int&> const r1( ec );
result<int&> r2( x2 );
r2 = r1;
BOOST_TEST_EQ( x2, 2 );
BOOST_TEST_EQ( r1, r2 );
}
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> const r1( ec );
result<int&> r2( ENOENT, generic_category() );
r2 = r1;
BOOST_TEST_EQ( r1, r2 );
}
return boost::report_errors();
}

118
test/result_copy_construct.cpp
View File

@ -145,6 +145,8 @@ int main()
BOOST_TEST_EQ( X::instances, 0 );
//
{
result<void> r;
result<void> r2( r );
@ -177,5 +179,121 @@ int main()
BOOST_TEST_EQ( r, r2 );
}
//
{
int x1 = 1;
result<int&> r1( x1 );
result<int&> r2( r1 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r2, &x1 );
}
{
int x1 = 1;
result<int&> const r1( x1 );
result<int&> r2( r1 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r2, &x1 );
}
{
int const x1 = 1;
result<int const&> r1( x1 );
result<int const&> r2( r1 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r2, &x1 );
}
{
int const x1 = 1;
result<int const&> const r1( x1 );
result<int const&> r2( r1 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r2, &x1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X x1( 1 );
result<X&> r1( x1 );
result<X&> r2( r1 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r2, &x1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X x1( 1 );
result<X&> const r1( x1 );
result<X&> r2( r1 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r2, &x1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X const x1( 1 );
result<X const&> r1( x1 );
result<X const&> r2( r1 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r2, &x1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X const x1( 1 );
result<X const&> const r1( x1 );
result<X const&> r2( r1 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r2, &x1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> r1( ec );
result<int&> r2( r1 );
BOOST_TEST_EQ( r1, r2 );
}
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> const r1( ec );
result<int&> r2( r1 );
BOOST_TEST_EQ( r1, r2 );
}
//
return boost::report_errors();
}

3
test/result_default_construct.cpp
View File

@ -52,6 +52,9 @@ int main()
BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<Y>>));
BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<Y, int>>));
BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<int&>>));
BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<int&, int>>));
}
return boost::report_errors();

42
test/result_emplace.cpp
View File

@ -172,5 +172,47 @@ int main()
BOOST_TEST_EQ( Y::instances, 0 );
}
{
int x1 = 1;
result<int&> r( x1 );
BOOST_TEST( r.has_value() );
BOOST_TEST_EQ( r.value(), 1 );
int x2 = 2;
r.emplace( x2 );
BOOST_TEST( r.has_value() );
BOOST_TEST_EQ( r.value(), 2 );
}
{
result<int&> r( ENOENT, generic_category() );
BOOST_TEST( !r.has_value() );
int x2 = 2;
r.emplace( x2 );
BOOST_TEST( r.has_value() );
BOOST_TEST_EQ( r.value(), 2 );
}
BOOST_TEST_EQ( Y::instances, 0 );
{
result<int&, Y> r( in_place_error );
BOOST_TEST( !r.has_value() );
BOOST_TEST_EQ( Y::instances, 1 );
int x2 = 2;
r.emplace( x2 );
BOOST_TEST( r.has_value() );
BOOST_TEST_EQ( *r, 2 );
BOOST_TEST_EQ( Y::instances, 0 );
}
return boost::report_errors();
}

78
test/result_eq.cpp
View File

@ -149,5 +149,83 @@ int main()
BOOST_TEST_NE( r1, r2 );
}
{
int x1 = 1;
int x2 = 2;
result<int&> r1( x1 );
result<int&> r2( x2 );
BOOST_TEST_EQ( r1, r1 );
BOOST_TEST_NE( r1, r2 );
}
{
int x1 = 1;
int x2 = 1;
result<int&> r1( x1 );
result<int&> r2( x2 );
BOOST_TEST_EQ( r1, r2 );
}
{
result<int&> r1( 1, generic_category() );
result<int&> r2( 2, generic_category() );
BOOST_TEST_EQ( r1, r1 );
BOOST_TEST_NE( r1, r2 );
}
{
int x1 = 1;
result<int&> r1( x1 );
result<int&> r2( 2, generic_category() );
BOOST_TEST_EQ( r1, r1 );
BOOST_TEST_NE( r1, r2 );
}
{
X x1( 1 );
X x2( 2 );
result<X&, Y> r1( x1 );
result<X&, Y> r2( x2 );
BOOST_TEST_EQ( r1, r1 );
BOOST_TEST_NE( r1, r2 );
}
{
X x1( 1 );
X x2( 1 );
result<X&, Y> r1( x1 );
result<X&, Y> r2( x2 );
BOOST_TEST_EQ( r1, r2 );
}
{
result<X&, Y> r1( in_place_error, 1 );
result<X&, Y> r2( in_place_error, 2 );
BOOST_TEST_EQ( r1, r1 );
BOOST_TEST_NE( r1, r2 );
}
{
X x1( 1 );
result<X&, Y> r1( x1 );
result<X&, Y> r2( in_place_error, 2 );
BOOST_TEST_EQ( r1, r1 );
BOOST_TEST_NE( r1, r2 );
}
return boost::report_errors();
}

9
test/result_errc_construct.cpp
View File

@ -19,5 +19,14 @@ int main()
BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<bool>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, errc::errc_t>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<int const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, errc::errc_t>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<double const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, errc::errc_t>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<bool const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool const&>, errc::errc_t>));
return boost::report_errors();
}

68
test/result_error_access.cpp
View File

@ -152,6 +152,8 @@ int main()
BOOST_TEST_EQ( (result<std::string, X>( "s" ).error().v_), 0 );
}
//
{
result<void> r;
@ -208,5 +210,71 @@ int main()
BOOST_TEST_EQ( result<void>( ec ).error(), ec );
}
//
{
int x1 = 1;
result<int&> r( x1 );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.error(), error_code() );
}
{
int x1 = 1;
result<int&> const r( x1 );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.error(), error_code() );
}
{
int x1 = 1;
BOOST_TEST( result<int&>( x1 ).has_value() );
BOOST_TEST( !result<int&>( x1 ).has_error() );
BOOST_TEST_EQ( result<int&>( x1 ).error(), error_code() );
}
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> r( ec );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error(), ec );
}
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> const r( ec );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error(), ec );
}
{
auto ec = make_error_code( errc::invalid_argument );
BOOST_TEST( !result<int&>( ec ).has_value() );
BOOST_TEST( result<int&>( ec ).has_error() );
BOOST_TEST_EQ( result<int&>( ec ).error(), ec );
}
//
return boost::report_errors();
}

22
test/result_error_construct3.cpp
View File

@ -157,5 +157,27 @@ int main()
BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
}
{
auto ec = make_error_code( errc::invalid_argument );
using R = result<int&>;
R r( R::in_place_error, ec );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error(), ec );
}
{
using R = result<int&>;
R r( R::in_place_error, EINVAL, generic_category() );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
}
return boost::report_errors();
}

160
test/result_error_construct5.cpp Normal file
View File

@ -0,0 +1,160 @@
// Copyright 2017, 2021 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/system/result.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#include <string>
#include <cerrno>
using namespace boost::system;
struct X
{
static int instances;
int v_;
X(): v_() { ++instances; }
explicit X( int v ): v_( v ) { ++instances; }
X( int v1, int v2 ): v_( v1+v2 ) { ++instances; }
X( int v1, int v2, int v3 ): v_( v1+v2+v3 ) { ++instances; }
X( X const& r ): v_( r.v_ ) { ++instances; }
X& operator=( X const& ) = delete;
~X() { --instances; }
};
int X::instances = 0;
int main()
{
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> r( ec );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error(), ec );
}
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> r = ec;
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error(), ec );
}
{
result<int&> r( EINVAL, generic_category() );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
}
{
auto ec = make_error_code( errc::invalid_argument );
result<error_code&> r( in_place_error, ec );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error(), ec );
}
{
result<error_code&> r( in_place_error, EINVAL, generic_category() );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
}
BOOST_TEST_EQ( X::instances, 0 );
{
result<std::string&, X> r( 1 );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error().v_, 1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
result<int&, X> r( 1, 2 );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error().v_, 1+2 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
result<int&, X> r( 1, 2, 3 );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error().v_, 1+2+3 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
result<X&, X> r( in_place_error, 1 );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( r.error().v_, 1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int&>, error_code>));
BOOST_TEST_TRAIT_TRUE((std::is_convertible<error_code, result<int&>>));
BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<std::string&, X>, int>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<std::string&, X>>));
BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int&, X>, int>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int&, X>>));
// There's an ambiguity here between int& and X, but since is_convertible
// is true, is_constructible can't be false.
// BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&, X>, int&>));
BOOST_TEST_TRAIT_TRUE((std::is_convertible<int&, result<int&, X>>));
}
return boost::report_errors();
}

44
test/result_error_move.cpp
View File

@ -55,7 +55,9 @@ int main()
BOOST_TEST_EQ( (result<std::string, X>( "s" ).error().v_), 0 );
}
{
//
{
result<void, X> r( 1 );
BOOST_TEST( !r.has_value() );
@ -87,5 +89,45 @@ int main()
BOOST_TEST_EQ( (result<void, X>().error().v_), 0 );
}
//
{
result<double&, X> r( 1 );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_EQ( std::move( r ).error().v_, 1 );
}
{
BOOST_TEST(( !result<double&, X>( 1 ).has_value() ));
BOOST_TEST(( result<double&, X>( 1 ).has_error() ));
BOOST_TEST_EQ( (result<double&, X>( 1 ).error().v_), 1 );
}
{
double x = 1.0;
result<double&, X> r( x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( std::move( r ).error().v_, 0 );
}
{
double x = 1.0;
BOOST_TEST(( result<double&, X>( x ).has_value() ));
BOOST_TEST(( !result<double&, X>( x ).has_error() ));
BOOST_TEST_EQ( (result<double&, X>( x ).error().v_), 0 );
}
//
return boost::report_errors();
}

107
test/result_move_assign.cpp
View File

@ -508,6 +508,8 @@ int main()
BOOST_TEST_EQ( Y::instances, 0 );
//
{
result<void> r;
result<void> r2;
@ -600,5 +602,110 @@ int main()
BOOST_TEST_EQ( r2.error(), ec );
}
//
{
int x1 = 1;
int x2 = 2;
result<int&> r1( x1 );
result<int&> r2( x2 );
r2 = std::move( r1 );
BOOST_TEST_EQ( x1, 1 );
BOOST_TEST_EQ( x2, 2 );
BOOST_TEST( r2.has_value() );
BOOST_TEST( !r2.has_error() );
BOOST_TEST_EQ( r2.value(), 1 );
BOOST_TEST_EQ( r1, r2 );
BOOST_TEST_EQ( &*r1, &*r2 );
}
{
int x1 = 1;
result<int&> r1( x1 );
result<int&> r2( ENOENT, generic_category() );
r2 = std::move( r1 );
BOOST_TEST_EQ( x1, 1 );
BOOST_TEST( r2.has_value() );
BOOST_TEST( !r2.has_error() );
BOOST_TEST_EQ( r2.value(), 1 );
BOOST_TEST_EQ( r1, r2 );
}
{
int x1 = 1;
auto ec = make_error_code( errc::invalid_argument );
result<int&> r1( ec );
result<int&> r2( x1 );
r2 = std::move( r1 );
BOOST_TEST_EQ( x1, 1 );
BOOST_TEST( !r2.has_value() );
BOOST_TEST( r2.has_error() );
BOOST_TEST_EQ( r2.error(), ec );
}
{
int x1 = 1;
auto ec = make_error_code( errc::invalid_argument );
result<int&> r2( x1 );
r2 = result<int&>( ec );
BOOST_TEST_EQ( x1, 1 );
BOOST_TEST( !r2.has_value() );
BOOST_TEST( r2.has_error() );
BOOST_TEST_EQ( r2.error(), ec );
}
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> r1( ec );
result<int&> r2( ENOENT, generic_category() );
r2 = std::move( r1 );
BOOST_TEST( !r2.has_value() );
BOOST_TEST( r2.has_error() );
BOOST_TEST_EQ( r2.error(), ec );
}
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> r2( ENOENT, generic_category() );
r2 = result<int&>( ec );
BOOST_TEST( !r2.has_value() );
BOOST_TEST( r2.has_error() );
BOOST_TEST_EQ( r2.error(), ec );
}
//
return boost::report_errors();
}

146
test/result_move_construct.cpp
View File

@ -207,6 +207,8 @@ int main()
BOOST_TEST_EQ( X::instances, 0 );
//
{
result<void> r;
result<void> r2( std::move( r ) );
@ -245,5 +247,149 @@ int main()
BOOST_TEST_EQ( r2.error(), ec );
}
//
{
int x1 = 1;
result<int&> r1( x1 );
result<int&> r2( std::move( r1 ) );
BOOST_TEST( r1.has_value() );
BOOST_TEST( !r1.has_error() );
BOOST_TEST_EQ( r1.value(), 1 );
BOOST_TEST_EQ( &*r1, &x1 );
BOOST_TEST( r2.has_value() );
BOOST_TEST( !r2.has_error() );
BOOST_TEST_EQ( r2.value(), 1 );
BOOST_TEST_EQ( &*r2, &x1 );
}
{
int const x1 = 1;
result<int const&> r1( x1 );
result<int const&> r2( std::move( r1 ) );
BOOST_TEST( r1.has_value() );
BOOST_TEST( !r1.has_error() );
BOOST_TEST_EQ( r1.value(), 1 );
BOOST_TEST_EQ( &*r1, &x1 );
BOOST_TEST( r2.has_value() );
BOOST_TEST( !r2.has_error() );
BOOST_TEST_EQ( r2.value(), 1 );
BOOST_TEST_EQ( &*r2, &x1 );
}
{
int x1 = 1;
result<int&> r2(( result<int&>( x1 ) ));
BOOST_TEST( r2.has_value() );
BOOST_TEST( !r2.has_error() );
BOOST_TEST_EQ( r2.value(), 1 );
BOOST_TEST_EQ( &*r2, &x1 );
}
{
int const x1 = 1;
result<int const&> r2(( result<int const&>( x1 ) ));
BOOST_TEST( r2.has_value() );
BOOST_TEST( !r2.has_error() );
BOOST_TEST_EQ( r2.value(), 1 );
BOOST_TEST_EQ( &*r2, &x1 );
}
{
X x1( 1 );
result<X&> r1( x1 );
result<X&> r2( std::move( r1 ) );
BOOST_TEST( r1.has_value() );
BOOST_TEST( !r1.has_error() );
BOOST_TEST_EQ( r1.value().v_, 1 );
BOOST_TEST_EQ( &*r1, &x1 );
BOOST_TEST( r2.has_value() );
BOOST_TEST( !r2.has_error() );
BOOST_TEST_EQ( r2.value().v_, 1 );
BOOST_TEST_EQ( &*r2, &x1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X x1( 1 );
result<X&> r2(( result<X&>( x1 ) ));
BOOST_TEST( r2.has_value() );
BOOST_TEST( !r2.has_error() );
BOOST_TEST_EQ( r2.value().v_, 1 );
BOOST_TEST_EQ( &*r2, &x1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X const x1( 1 );
result<X const&> r1( x1 );
result<X const&> r2( std::move( r1 ) );
BOOST_TEST( r1.has_value() );
BOOST_TEST( !r1.has_error() );
BOOST_TEST_EQ( r1.value().v_, 1 );
BOOST_TEST_EQ( &*r1, &x1 );
BOOST_TEST( r2.has_value() );
BOOST_TEST( !r2.has_error() );
BOOST_TEST_EQ( r2.value().v_, 1 );
BOOST_TEST_EQ( &*r2, &x1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X const x1( 1 );
result<X const&> r2(( result<X const&>( x1 ) ));
BOOST_TEST( r2.has_value() );
BOOST_TEST( !r2.has_error() );
BOOST_TEST_EQ( r2.value().v_, 1 );
BOOST_TEST_EQ( &*r2, &x1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
//
return boost::report_errors();
}

50
test/result_swap.cpp
View File

@ -259,5 +259,55 @@ int main()
BOOST_TEST_EQ( r2, r2c );
}
{
int x1 = 1;
int x2 = 2;
result<int&> r1( x1 ), r1c( r1 );
result<int&> r2( x2 ), r2c( r2 );
r1.swap( r2 );
BOOST_TEST_EQ( r1, r2c );
BOOST_TEST_EQ( r2, r1c );
swap( r1, r2 );
BOOST_TEST_EQ( r1, r1c );
BOOST_TEST_EQ( r2, r2c );
}
{
result<int&> r1( 1, generic_category() ), r1c( r1 );
result<int&> r2( 2, generic_category() ), r2c( r2 );
r1.swap( r2 );
BOOST_TEST_EQ( r1, r2c );
BOOST_TEST_EQ( r2, r1c );
swap( r1, r2 );
BOOST_TEST_EQ( r1, r1c );
BOOST_TEST_EQ( r2, r2c );
}
{
int x1 = 1;
result<int&> r1( x1 ), r1c( r1 );
result<int&> r2( 2, generic_category() ), r2c( r2 );
r1.swap( r2 );
BOOST_TEST_EQ( r1, r2c );
BOOST_TEST_EQ( r2, r1c );
swap( r1, r2 );
BOOST_TEST_EQ( r1, r1c );
BOOST_TEST_EQ( r2, r2c );
}
return boost::report_errors();
}

23
test/result_typedefs.cpp
View File

@ -12,11 +12,28 @@ struct X {};
int main()
{
BOOST_TEST_TRAIT_SAME( result<int>::value_type, int );
BOOST_TEST_TRAIT_SAME( result<X>::value_type, X );
BOOST_TEST_TRAIT_SAME( result<void>::value_type, void );
BOOST_TEST_TRAIT_SAME( result<int>::error_type, error_code );
BOOST_TEST_TRAIT_SAME( result<X>::value_type, X );
BOOST_TEST_TRAIT_SAME( result<X>::error_type, error_code );
BOOST_TEST_TRAIT_SAME( result<void>::value_type, void );
BOOST_TEST_TRAIT_SAME( result<void>::error_type, error_code );
BOOST_TEST_TRAIT_SAME( result<int&>::value_type, int& );
BOOST_TEST_TRAIT_SAME( result<int&>::error_type, error_code );
BOOST_TEST_TRAIT_SAME( result<int, X>::value_type, int );
BOOST_TEST_TRAIT_SAME( result<int, X>::error_type, X );
BOOST_TEST_TRAIT_SAME( result<X, X>::value_type, X );
BOOST_TEST_TRAIT_SAME( result<X, X>::error_type, X );
BOOST_TEST_TRAIT_SAME( result<void, X>::value_type, void );
BOOST_TEST_TRAIT_SAME( result<void, X>::error_type, X );
BOOST_TEST_TRAIT_SAME( result<int&, X>::value_type, int& );
BOOST_TEST_TRAIT_SAME( result<int&, X>::error_type, X );
return boost::report_errors();
}

176
test/result_value_access.cpp
View File

@ -336,6 +336,8 @@ int main()
BOOST_TEST_EQ( (result<X, Y>( ec ).operator->()), static_cast<X*>(0) );
}
//
{
result<void> r;
@ -497,5 +499,179 @@ int main()
BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
}
//
{
int x1 = 1;
result<int&> r( x1 );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST( r );
BOOST_TEST_NOT( !r );
BOOST_TEST_EQ( r.value(), 1 );
BOOST_TEST_EQ( *r, 1 );
BOOST_TEST_EQ( r.operator->(), &*r );
}
{
int x1 = 1;
result<int&> const r( x1 );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST( r );
BOOST_TEST_NOT( !r );
BOOST_TEST_EQ( r.value(), 1 );
BOOST_TEST_EQ( *r, 1 );
BOOST_TEST_EQ( r.operator->(), &*r );
}
{
int x1 = 1;
BOOST_TEST( result<int&>( x1 ).has_value() );
BOOST_TEST( !result<int&>( x1 ).has_error() );
BOOST_TEST( result<int&>( x1 ) );
BOOST_TEST_NOT( !result<int&>( x1 ) );
BOOST_TEST_EQ( result<int&>( x1 ).value(), 1 );
BOOST_TEST_EQ( *result<int&>( x1 ), 1 );
BOOST_TEST_EQ( result<int&>( x1 ).operator->(), &x1 );
}
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> r( ec );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_NOT( r );
BOOST_TEST( !r );
BOOST_TEST_THROWS( r.value(), system_error );
BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
}
{
auto ec = make_error_code( errc::invalid_argument );
result<int&> const r( ec );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_NOT( r );
BOOST_TEST( !r );
BOOST_TEST_THROWS( r.value(), system_error );
BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
}
{
auto ec = make_error_code( errc::invalid_argument );
BOOST_TEST( !result<int&>( ec ).has_value() );
BOOST_TEST( result<int&>( ec ).has_error() );
BOOST_TEST_NOT( result<int&>( ec ) );
BOOST_TEST( !result<int&>( ec ) );
BOOST_TEST_THROWS( result<int&>( ec ).value(), system_error );
BOOST_TEST_EQ( result<int&>( ec ).operator->(), static_cast<int*>(0) );
}
{
auto ec = make_error_code( std::errc::invalid_argument );
result<int&, std::error_code> const r( ec );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_NOT( r );
BOOST_TEST( !r );
BOOST_TEST_THROWS( r.value(), std::system_error );
BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
}
{
result<int&, errc::errc_t> const r( in_place_error, errc::invalid_argument );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_NOT( r );
BOOST_TEST( !r );
BOOST_TEST_THROWS( r.value(), system_error );
BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
}
{
result<int&, std::errc> const r( std::errc::invalid_argument );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_NOT( r );
BOOST_TEST( !r );
BOOST_TEST_THROWS( r.value(), std::system_error );
BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
}
{
result<int&, std::exception_ptr> const r( std::make_exception_ptr( E2() ) );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_NOT( r );
BOOST_TEST( !r );
#if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30600
#else
BOOST_TEST_THROWS( r.value(), E2 );
#endif
BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
}
{
result<int&, std::exception_ptr> const r( in_place_error );
BOOST_TEST( !r.has_value() );
BOOST_TEST( r.has_error() );
BOOST_TEST_NOT( r );
BOOST_TEST( !r );
BOOST_TEST_THROWS( r.value(), std::bad_exception );
BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
}
//
return boost::report_errors();
}

24
test/result_value_construct3.cpp
View File

@ -114,5 +114,29 @@ int main()
BOOST_TEST( !r.has_error() );
}
{
int x1 = 1;
using R = result<int&>;
R r( R::in_place_value, x1 );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value(), 1 );
}
{
int x1 = 1;
using R = result<int&, int>;
R r( R::in_place_value, x1 );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( *r, 1 );
}
return boost::report_errors();
}

121
test/result_value_construct6.cpp Normal file
View File

@ -0,0 +1,121 @@
// Copyright 2017, 2021, 2023 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/system/result.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/core/lightweight_test_trait.hpp>
using namespace boost::system;
struct X
{
static int instances;
int v_;
explicit X( int v ): v_( v ) { ++instances; }
X( X const& ) = delete;
X& operator=( X const& ) = delete;
~X() { --instances; }
};
int X::instances = 0;
int main()
{
{
int x = 0;
result<int&> r( x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value(), 0 );
}
{
int x = 0;
result<int&> r = x;
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value(), 0 );
}
{
int x = 1;
result<int&, int> r( in_place_value, x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( *r, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X x( 1 );
result<X&> r( x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value().v_, 1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X x( 1 );
result<X&> r = x;
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value().v_, 1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X x( 1 );
result<X&, X> r( in_place_value, x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r->v_, 1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int&>, int&>));
BOOST_TEST_TRAIT_TRUE((std::is_convertible<int&, result<int&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&>, int const&>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<int const&, result<int&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&>, int>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&, int>, int&>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int&, float>, int&>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<X&>, int>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<X&>>));
}
return boost::report_errors();
}

211
test/result_value_construct7.cpp Normal file
View File

@ -0,0 +1,211 @@
// Copyright 2017, 2021, 2023 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/system/result.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/core/lightweight_test_trait.hpp>
using namespace boost::system;
struct X
{
static int instances;
int v_;
explicit X( int v ): v_( v ) { ++instances; }
X( X const& ) = delete;
X& operator=( X const& ) = delete;
~X() { --instances; }
};
int X::instances = 0;
int main()
{
{
int x = 0;
result<int const&> r( x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value(), 0 );
}
{
int const x = 0;
result<int const&> r( x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value(), 0 );
}
{
int x = 0;
result<int const&> r = x;
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value(), 0 );
}
{
int const x = 0;
result<int const&> r = x;
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value(), 0 );
}
{
int x = 1;
result<int const&, int> r( in_place_value, x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( *r, 1 );
}
{
int const x = 1;
result<int const&, int> r( in_place_value, x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( *r, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X x( 1 );
result<X const&> r( x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value().v_, 1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X const x( 1 );
result<X const&> r( x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value().v_, 1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X x( 1 );
result<X const&> r = x;
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value().v_, 1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X const x( 1 );
result<X const&> r = x;
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r.value().v_, 1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X x( 1 );
result<X const&, X> r( in_place_value, x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r->v_, 1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
X const x( 1 );
result<X const&, X> r( in_place_value, x );
BOOST_TEST( r.has_value() );
BOOST_TEST( !r.has_error() );
BOOST_TEST_EQ( r->v_, 1 );
BOOST_TEST_EQ( X::instances, 1 );
}
BOOST_TEST_EQ( X::instances, 0 );
{
BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int const&>, int&>));
BOOST_TEST_TRAIT_TRUE((std::is_convertible<int&, result<int const&>>));
BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int const&>, int const&>));
BOOST_TEST_TRAIT_TRUE((std::is_convertible<int const&, result<int const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&>, int>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, int&>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<int&, result<double const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, int const&>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<int const&, result<double const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double const&>, int>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<double const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, int>, int&>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, float>, int&>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, int>, int const&>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, float>, int const&>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, int>, int>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int const&, float>, int>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<X const&>, int>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<X const&>>));
BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<X const&>, X const>));
BOOST_TEST_TRAIT_FALSE((std::is_convertible<X const, result<X const&>>));
}
return boost::report_errors();
}