1
0
forked from Alepha/Alepha
Files
Alepha/Exception.test/exception.cc

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;
};
};
}