feedc0de/boost_optional
1
0
Fork 0
forked from boostorg/optional
Code Pull Requests Activity

Drop dependency on Boost.StaticAssert

Browse Source
This commit is contained in:
Andrzej Krzemienski
2024-10-16 23:31:33 +02:00
parent b2c7f93ead
commit e601f1ef2d
11 changed files with 78 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/optional_test_convert_assign.cpp
+3 -3
View File
@@ -40,9 +40,9 @@ void test_no_bad_assignment()
{
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800)
// this means that type trait `boost::is_assignable` works.
BOOST_STATIC_ASSERT((boost::is_assignable<optional<bool>&, bool>::value));
BOOST_STATIC_ASSERT((boost::is_assignable<optional<bool>&, implicit_bool_conv>::value));
BOOST_STATIC_ASSERT((! boost::is_assignable<optional<bool>&, explicit_bool_conv>::value));
static_assert((boost::is_assignable<optional<bool>&, bool>::value), "ERROR");
static_assert((boost::is_assignable<optional<bool>&, implicit_bool_conv>::value), "ERROR");
static_assert((! boost::is_assignable<optional<bool>&, explicit_bool_conv>::value), "ERROR");
#endif
}
test/optional_test_convert_from_T.cpp
+8 -8
View File
@@ -28,14 +28,14 @@ struct superconv
{
#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
template <typename T>
superconv(T&&) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }
superconv(T&&) { static_assert(sizeof(T) == 0, "ERROR"); }
#else
template <typename T>
superconv(const T&) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }
superconv(const T&) { static_assert(sizeof(T) == 0, "ERROR"); }
template <typename T>
superconv( T&) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }
superconv( T&) { static_assert(sizeof(T) == 0, "ERROR"); }
#endif
superconv() {}
};
@@ -52,19 +52,19 @@ void test_optional_optional_T()
{
optional<int> oi1 (1), oiN;
optional< optional<int> > ooi1 (oi1), ooiN(oiN);
BOOST_TEST(ooi1);
BOOST_TEST(*ooi1);
BOOST_TEST_EQ(**ooi1, 1);
BOOST_TEST(ooiN);
BOOST_TEST(!*ooiN);
}
}
int main()
{
test_optional_optional_T();
test_optional_of_superconverting_T();
return boost::report_errors();
}
test/optional_test_noexcept_move.cpp
+42 -44
View File
@@ -44,36 +44,36 @@ struct NothrowNone {
#if 0 // these also test type_traits, which are wrong
void test_noexcept_as_defined() // this is a compile-time test
{
BOOST_STATIC_ASSERT(::boost::is_nothrow_move_constructible<NothrowBoth>::value);
BOOST_STATIC_ASSERT(::boost::is_nothrow_move_assignable<NothrowBoth>::value);
BOOST_STATIC_ASSERT(::boost::is_nothrow_move_constructible<NothrowCtor>::value);
BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<NothrowCtor>::value);
BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_constructible<NothrowAssign>::value);
BOOST_STATIC_ASSERT(::boost::is_nothrow_move_assignable<NothrowAssign>::value);
BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_constructible<NothrowNone>::value);
BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<NothrowNone>::value);
static_assert(::boost::is_nothrow_move_constructible<NothrowBoth>::value, "ERROR");
static_assert(::boost::is_nothrow_move_assignable<NothrowBoth>::value, "ERROR");
static_assert(::boost::is_nothrow_move_constructible<NothrowCtor>::value, "ERROR");
static_assert(!::boost::is_nothrow_move_assignable<NothrowCtor>::value, "ERROR");
static_assert(!::boost::is_nothrow_move_constructible<NothrowAssign>::value, "ERROR");
static_assert(::boost::is_nothrow_move_assignable<NothrowAssign>::value, "ERROR");
static_assert(!::boost::is_nothrow_move_constructible<NothrowNone>::value, "ERROR");
static_assert(!::boost::is_nothrow_move_assignable<NothrowNone>::value, "ERROR");
}
void test_noexcept_on_optional_with_type_traits() // this is a compile-time test
{
BOOST_STATIC_ASSERT(::boost::is_nothrow_move_constructible<optional<NothrowBoth> >::value);
BOOST_STATIC_ASSERT(::boost::is_nothrow_move_assignable<optional<NothrowBoth> >::value);
BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowBoth>()));
BOOST_STATIC_ASSERT(::boost::is_nothrow_move_constructible<optional<NothrowCtor> >::value);
BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<optional<NothrowCtor> >::value);
BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowCtor>()));
BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_constructible<optional<NothrowAssign> >::value);
BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<optional<NothrowAssign> >::value);
BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowAssign>()));
BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_constructible<optional<NothrowNone> >::value);
BOOST_STATIC_ASSERT(!::boost::is_nothrow_move_assignable<optional<NothrowNone> >::value);
BOOST_STATIC_ASSERT(BOOST_NOEXCEPT_EXPR(optional<NothrowNone>()));
static_assert(::boost::is_nothrow_move_constructible<optional<NothrowBoth> >::value, "ERROR");
static_assert(::boost::is_nothrow_move_assignable<optional<NothrowBoth> >::value, "ERROR");
static_assert(BOOST_NOEXCEPT_EXPR(optional<NothrowBoth>()), "ERROR");
static_assert(::boost::is_nothrow_move_constructible<optional<NothrowCtor> >::value, "ERROR");
static_assert(!::boost::is_nothrow_move_assignable<optional<NothrowCtor> >::value, "ERROR");
static_assert(BOOST_NOEXCEPT_EXPR(optional<NothrowCtor>()), "ERROR");
static_assert(!::boost::is_nothrow_move_constructible<optional<NothrowAssign> >::value, "ERROR");
static_assert(!::boost::is_nothrow_move_assignable<optional<NothrowAssign> >::value, "ERROR");
static_assert(BOOST_NOEXCEPT_EXPR(optional<NothrowAssign>()), "ERROR");
static_assert(!::boost::is_nothrow_move_constructible<optional<NothrowNone> >::value, "ERROR");
static_assert(!::boost::is_nothrow_move_assignable<optional<NothrowNone> >::value, "ERROR");
static_assert(BOOST_NOEXCEPT_EXPR(optional<NothrowNone>()), "ERROR");
}
#endif
@@ -87,22 +87,22 @@ void test_noexcept_optional_with_operator() // compile-time test
ONxC onxC;
ONxA onxA;
ONx0 onx0;
BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONx2() ));
BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONx2(std::move(onx2)) ));
BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( onx2 = ONx2() ));
BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONxC() ));
BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONxC(std::move(onxC)) ));
BOOST_STATIC_ASSERT(!BOOST_NOEXCEPT_EXPR( onxC = ONxC() ));
BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONxA() ));
BOOST_STATIC_ASSERT(!BOOST_NOEXCEPT_EXPR( ONxA(std::move(onxA)) ));
BOOST_STATIC_ASSERT(!BOOST_NOEXCEPT_EXPR( onxA = ONxA() ));
BOOST_STATIC_ASSERT( BOOST_NOEXCEPT_EXPR( ONx0() ));
BOOST_STATIC_ASSERT(!BOOST_NOEXCEPT_EXPR( ONx0(std::move(onx0)) ));
BOOST_STATIC_ASSERT(!BOOST_NOEXCEPT_EXPR( onx0 = ONx0() ));
static_assert( BOOST_NOEXCEPT_EXPR( ONx2() ), "ERROR");
static_assert( BOOST_NOEXCEPT_EXPR( ONx2(std::move(onx2)) ), "ERROR");
static_assert( BOOST_NOEXCEPT_EXPR( onx2 = ONx2() ), "ERROR");
static_assert( BOOST_NOEXCEPT_EXPR( ONxC() ), "ERROR");
static_assert( BOOST_NOEXCEPT_EXPR( ONxC(std::move(onxC)) ), "ERROR");
static_assert(!BOOST_NOEXCEPT_EXPR( onxC = ONxC() ), "ERROR");
static_assert( BOOST_NOEXCEPT_EXPR( ONxA() ), "ERROR");
static_assert(!BOOST_NOEXCEPT_EXPR( ONxA(std::move(onxA)) ), "ERROR");
static_assert(!BOOST_NOEXCEPT_EXPR( onxA = ONxA() ), "ERROR");
static_assert( BOOST_NOEXCEPT_EXPR( ONx0() ), "ERROR");
static_assert(!BOOST_NOEXCEPT_EXPR( ONx0(std::move(onx0)) ), "ERROR");
static_assert(!BOOST_NOEXCEPT_EXPR( onx0 = ONx0() ), "ERROR");
}
#endif // !defined BOOST_NO_CXX11_NOEXCEPT
@@ -112,5 +112,3 @@ int main()
{
return 0;
}
test/optional_test_path_assignment.cpp
+1 -1
View File
@@ -66,7 +66,7 @@ int main()
optFs1 = optFs2;
// the following still fails although it shouldn't
//BOOST_STATIC_ASSERT((std::is_copy_constructible<boost::optional<Path>>::value));
//static_assert((std::is_copy_constructible<boost::optional<Path>>::value), "ERROR");
#endif
#endif
test/optional_test_ref_convert_assign_const_int_prevented.cpp
+1 -1
View File
@@ -26,7 +26,7 @@ int main()
#ifdef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT
test_converting_assignment<const int, const int>();
#else
BOOST_STATIC_ASSERT_MSG(false, "EXPECTED TEST COMPILE-TIME FAILURE");
static_assert(false, "EXPECTED TEST COMPILE-TIME FAILURE");
#endif
return boost::report_errors();
}
test/optional_test_sfinae_friendly_ctor.cpp
+12 -12
View File
@@ -21,29 +21,29 @@ using boost::optional;
struct X {};
struct Y {};
struct Resource
{
explicit Resource(const X&) {}
};
BOOST_STATIC_ASSERT(( boost::is_constructible<Resource, const X&>::value ));
BOOST_STATIC_ASSERT(( !boost::is_constructible<Resource, const Y&>::value ));
static_assert(( boost::is_constructible<Resource, const X&>::value ), "ERROR");
static_assert(( !boost::is_constructible<Resource, const Y&>::value ), "ERROR");
BOOST_STATIC_ASSERT(( boost::is_constructible<optional<Resource>, const X&>::value ));
BOOST_STATIC_ASSERT(( !boost::is_constructible<optional<Resource>, const Y&>::value ));
static_assert(( boost::is_constructible<optional<Resource>, const X&>::value ), "ERROR");
static_assert(( !boost::is_constructible<optional<Resource>, const Y&>::value ), "ERROR");
#ifndef BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
BOOST_STATIC_ASSERT(( boost::is_constructible< optional< optional<int> >, optional<int> >::value ));
BOOST_STATIC_ASSERT(( !boost::is_constructible< optional<int>, optional< optional<int> > >::value ));
static_assert(( boost::is_constructible< optional< optional<int> >, optional<int> >::value ), "ERROR");
static_assert(( !boost::is_constructible< optional<int>, optional< optional<int> > >::value ), "ERROR");
BOOST_STATIC_ASSERT(( boost::is_constructible< optional< optional<int> >, const optional<int>& >::value ));
BOOST_STATIC_ASSERT(( !boost::is_constructible< optional<int>, const optional< optional<int> >& >::value ));
static_assert(( boost::is_constructible< optional< optional<int> >, const optional<int>& >::value ), "ERROR");
static_assert(( !boost::is_constructible< optional<int>, const optional< optional<int> >& >::value ), "ERROR");
BOOST_STATIC_ASSERT(( boost::is_constructible<optional<Resource>, const optional<X>&>::value ));
BOOST_STATIC_ASSERT(( !boost::is_constructible<optional<Resource>, const optional<Y>&>::value ));
static_assert(( boost::is_constructible<optional<Resource>, const optional<X>&>::value ), "ERROR");
static_assert(( !boost::is_constructible<optional<Resource>, const optional<Y>&>::value ), "ERROR");
#endif
#endif
int main() { }