forked from Alepha/Alepha
104 lines
4.6 KiB
C++
104 lines
4.6 KiB
C++
static_assert( __cplusplus > 2020'99 );
|
|
|
|
#include <Alepha/Exception.h>
|
|
|
|
#include <type_traits>
|
|
|
|
#include <Alepha/Testing/test.h>
|
|
#include <Alepha/Testing/TableTest.h>
|
|
#include <Alepha/Utility/evaluation_helpers.h>
|
|
|
|
namespace
|
|
{
|
|
using Alepha::Hydrogen::exports::types_m::argcnt_t;
|
|
using Alepha::Hydrogen::exports::types_m::argvec_t;
|
|
|
|
namespace util= Alepha::Utility;
|
|
using namespace Alepha::Testing::exports;
|
|
namespace boost= Alepha::boost;
|
|
|
|
struct tag;
|
|
|
|
template< typename CatchException >
|
|
void
|
|
testException()
|
|
{
|
|
try
|
|
{
|
|
auto exc= Alepha::build_exception< Alepha::TaggedAllocationError< struct tag > >( "This is my allocation exception" );
|
|
static_assert( std::is_same_v< decltype( exc )::grade_type, Alepha::Error > );
|
|
|
|
static_assert( std::is_same_v< Alepha::AnyTaggedException::grade_type, Alepha::Exception > );
|
|
|
|
static_assert( std::is_same_v< typename Alepha::TaggedException< struct bob >::grade_type, Alepha::Exception > );
|
|
|
|
static_assert( std::is_same_v< typename Alepha::TaggedCondition< struct bob >::grade_type, Alepha::Condition > );
|
|
static_assert( std::is_same_v< typename Alepha::TaggedNotification< struct bob >::grade_type, Alepha::Notification > );
|
|
static_assert( std::is_same_v< typename Alepha::TaggedError< struct bob >::grade_type, Alepha::Error > );
|
|
static_assert( std::is_same_v< typename Alepha::TaggedCriticalError< struct bob >::grade_type, Alepha::CriticalError > );
|
|
static_assert( std::is_same_v< typename Alepha::TaggedViolation< struct bob >::grade_type, Alepha::Violation > );
|
|
throw exc;
|
|
}
|
|
catch( const CatchException &ex )
|
|
{
|
|
std::cout << "Caught as `" << boost::core::demangle( typeid( CatchException ).name() ) << "` : ";
|
|
if constexpr( std::is_base_of_v< std::exception, CatchException > ) std::cout << ex.what();
|
|
else std::cout << ex.message();
|
|
std::cout << std::endl;
|
|
|
|
if constexpr( std::is_base_of_v< Alepha::AnyTaggedException, CatchException > )
|
|
{
|
|
std::cout << "Tag type: `" << boost::core::demangle( ex.tag().name() ) << '`' << std::endl;
|
|
}
|
|
//std::cout << "Local tag type: `" << typeid( std::type_identity< struct tag > ).name() << '`' << std::endl;
|
|
}
|
|
}
|
|
|
|
template< typename BuildException, typename CatchException >
|
|
bool
|
|
catchable()
|
|
{
|
|
try
|
|
{
|
|
throw Alepha::build_exception< BuildException >( "This is my allocation exception" );
|
|
}
|
|
catch( const CatchException &ex ) { std::cerr << "Caught" << std::endl; return true; }
|
|
catch( ... ) { std::cerr << "Not caught" << std::endl; return false; }
|
|
}
|
|
|
|
auto tests= Alepha::Utility::enroll <=[]
|
|
{
|
|
"smoke"_test <=[] () -> bool
|
|
{
|
|
testException< std::bad_alloc >();
|
|
testException< Alepha::TaggedError< tag > >();
|
|
testException< Alepha::AnyTaggedError >();
|
|
testException< std::exception >();
|
|
testException< Alepha::Exception >();
|
|
testException< Alepha::Error >();
|
|
|
|
return true;
|
|
};
|
|
|
|
"catch.std::bad_alloc"_test <=catchable< Alepha::TaggedAllocationError< tag >, std::bad_alloc >;
|
|
"catch.std::exception"_test <=catchable< Alepha::TaggedAllocationError< tag >, std::exception >;
|
|
"catch.Alepha::Exception"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::Exception >;
|
|
"catch.Alepha::AnyTaggedException"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::AnyTaggedException >;
|
|
"catch.Alepha::TaggedException"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::TaggedException< tag > >;
|
|
"catch.Alepha::Error"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::Error >;
|
|
"catch.Alepha::AnyTaggedError"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::AnyTaggedError >;
|
|
"catch.Alepha::TaggedError"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::TaggedError< tag > >;
|
|
"catch.Alepha::AllocationException"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::AllocationException >;
|
|
"catch.Alepha::AnyTaggedAllocationException"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::AnyTaggedAllocationException >;
|
|
"catch.Alepha::TaggedAllocationException"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::TaggedAllocationException< tag > >;
|
|
"catch.Alepha::AllocationError"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::AllocationError >;
|
|
"catch.Alepha::AnyTaggedAllocationError"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::AnyTaggedAllocationError >;
|
|
"catch.Alepha::TaggedAllocationError"_test <=catchable< Alepha::TaggedAllocationError< tag >, Alepha::TaggedAllocationError< tag > >;
|
|
|
|
"size_probe"_test <=[]
|
|
{
|
|
std::cout << "Size: " << sizeof( Alepha::build_exception< Alepha::TaggedAllocationError< tag > >( "Message" ) ) << std::endl;
|
|
};
|
|
};
|
|
}
|