@ -1,6 +1,6 @@
/*
/*
* Catch v1 .12 .2 * Catch v1 .12 .2
* Generated : 2018 - 05 - 14 15 : 10 : 01.112442 * Generated : 2023 - 01 - 17 08 : 45 : 40.979381
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* This file has been merged from multiple headers . Please don ' t edit it directly * This file has been merged from multiple headers . Please don ' t edit it directly
* Copyright ( c ) 2012 Two Blue Cubes Ltd . All rights reserved . * Copyright ( c ) 2012 Two Blue Cubes Ltd . All rights reserved .
@ -214,7 +214,7 @@
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Use variadic macros if the compiler supports them
// Use variadic macros if the compiler supports them
# if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \ # if ( defined _MSC_VER && _MSC_VER >= 1400 && !defined __EDGE__) || \
( defined __WAVE__ & & __WAVE_HAS_VARIADICS ) | | \
( defined __WAVE__ & & __WAVE_HAS_VARIADICS ) | | \
( defined __GNUC__ & & __GNUC__ > = 3 ) | | \
( defined __GNUC__ & & __GNUC__ > = 3 ) | | \
( ! defined __cplusplus & & __STDC_VERSION__ > = 199901L | | __cplusplus > = 201103L ) ( ! defined __cplusplus & & __STDC_VERSION__ > = 199901L | | __cplusplus > = 201103L )
@ -2129,6 +2129,9 @@ namespace Catch{
# define CATCH_TRAP() \ # define CATCH_TRAP() \
__asm__ ( " li r0, 20 \n sc \n nop \n li r0, 37 \n li r4, 2 \n sc \n nop \n " \
__asm__ ( " li r0, 20 \n sc \n nop \n li r0, 37 \n li r4, 2 \n sc \n nop \n " \
: : : " memory " , " r0 " , " r3 " , " r4 " ) /* NOLINT */ : : : " memory " , " r0 " , " r3 " , " r4 " ) /* NOLINT */
# elif defined(__aarch64__)
// Backport of https://github.com/catchorg/Catch2/commit/a25c1a24af8bffd35727a888a307ff0280cf9387
# define CATCH_TRAP() __asm__(".inst 0xd4200000")
# else # else
# define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ ) # define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ )
# endif # endif
@ -6392,18 +6395,21 @@ CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
// #included from: catch_fatal_condition.hpp
// #included from: catch_fatal_condition.hpp
# define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED # define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
# include <cassert>
# include <stdexcept>
namespace Catch { namespace Catch {
// Report the error condition
//! Signals fatal error message to the run context
inline void reportFatal ( std : : string const & message ) { inline void reportFatal ( std : : string const & message ) {
IContext & context = Catch : : getCurrentContext ( ) ; IContext & context = Catch : : getCurrentContext ( ) ;
IResultCapture * resultCapture = context . getResultCapture ( ) ; IResultCapture * resultCapture = context . getResultCapture ( ) ;
resultCapture - > handleFatalErrorCondition ( message ) ; resultCapture - > handleFatalErrorCondition ( message ) ;
} }
} // namespace Catch
} // namespace Catch
# if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
# if defined(CATCH_PLATFORM_WINDOWS) /////////////////////////////////////////
// #included from: catch_windows_h_proxy.h
// #included from: catch_windows_h_proxy.h
# define TWOBLUECUBES_CATCH_WINDOWS_H_PROXY_H_INCLUDED # define TWOBLUECUBES_CATCH_WINDOWS_H_PROXY_H_INCLUDED
@ -6429,176 +6435,307 @@ namespace Catch {
# endif # endif
# if !defined ( CATCH_CONFIG_WINDOWS_SEH )# if !defined(CATCH_CONFIG_WINDOWS_SEH)
namespace Catch { namespace Catch {
struct FatalConditionHandler { class FatalConditionHandler {
void reset ( ) { } bool m_started ;
} ;
} // Install/disengage implementation for specific platform.
// Should be if-defed to work on current platform, can assume
// engage-disengage 1:1 pairing.
void engage_platform ( ) { }
void disengage_platform ( ) { }
public :
// Should also have platform-specific implementations as needed
FatalConditionHandler ( ) : m_started ( false ) { }
~ FatalConditionHandler ( ) { }
void engage ( ) {
assert ( ! m_started & & " Handler cannot be installed twice. " ) ;
m_started = true ;
engage_platform ( ) ;
}
void disengage ( ) {
assert ( m_started & &
" Handler cannot be uninstalled without being installed first " ) ;
m_started = false ;
disengage_platform ( ) ;
}
} ;
} // namespace Catch
# else // CATCH_CONFIG_WINDOWS_SEH is defined
# else // CATCH_CONFIG_WINDOWS_SEH is defined
namespace Catch { namespace Catch {
struct SignalDefs { DWORD id ; const char * name ; } ; struct SignalDefs {
extern SignalDefs signalDefs [ ] ; DWORD id ;
// There is no 1-1 mapping between signals and windows exceptions.
const char * name ;
// Windows can easily distinguish between SO and SigSegV,
} ;
// but SigInt, SigTerm, etc are handled differently.
extern SignalDefs signalDefs [ ] ;
SignalDefs signalDefs [ ] = { // There is no 1-1 mapping between signals and windows exceptions.
{ EXCEPTION_ILLEGAL_INSTRUCTION , " SIGILL - Illegal instruction signal " } , // Windows can easily distinguish between SO and SigSegV,
{ EXCEPTION_STACK_OVERFLOW , " SIGSEGV - Stack overflow " } , // but SigInt, SigTerm, etc are handled differently.
{ EXCEPTION_ACCESS_VIOLATION , " SIGSEGV - Segmentation violation signal " } , SignalDefs signalDefs [ ] = {
{ EXCEPTION_INT_DIVIDE_BY_ZERO , " Divide by zero error " } , { EXCEPTION_ILLEGAL_INSTRUCTION , " SIGILL - Illegal instruction signal " } ,
} ; { EXCEPTION_STACK_OVERFLOW , " SIGSEGV - Stack overflow " } ,
{ EXCEPTION_ACCESS_VIOLATION , " SIGSEGV - Segmentation violation signal " } ,
{ EXCEPTION_INT_DIVIDE_BY_ZERO , " Divide by zero error " } ,
} ;
struct FatalConditionHandler { static LONG CALLBACK
handleVectoredException ( PEXCEPTION_POINTERS ExceptionInfo ) {
for ( int i = 0 ; i < sizeof ( signalDefs ) / sizeof ( SignalDefs ) ; + + i ) {
if ( ExceptionInfo - > ExceptionRecord - > ExceptionCode = = signalDefs [ i ] . id ) {
reportFatal ( signalDefs [ i ] . name ) ;
}
}
// If its not an exception we care about, pass it along.
// This stops us from eating debugger breaks etc.
return EXCEPTION_CONTINUE_SEARCH ;
}
static LONG CALLBACK handleVectoredException ( PEXCEPTION_POINTERS ExceptionInfo ) { // Since we do not support multiple instantiations, we put these
for ( int i = 0 ; i < sizeof ( signalDefs ) / sizeof ( SignalDefs ) ; + + i ) { // into global variables and rely on cleaning them up in outlined
if ( ExceptionInfo - > ExceptionRecord - > ExceptionCode = = signalDefs [ i ] . id ) { // constructors/destructors
reportFatal ( signalDefs [ i ] . name ) ; static PVOID exceptionHandlerHandle = CATCH_NULL ;
}
}
// If its not an exception we care about, pass it along.
// This stops us from eating debugger breaks etc.
return EXCEPTION_CONTINUE_SEARCH ;
}
FatalConditionHandler ( ) { class FatalConditionHandler {
isSet = true ; bool m_started ;
// 32k seems enough for Catch to handle stack overflow,
// but the value was found experimentally, so there is no strong guarantee
guaranteeSize = 32 * 1024 ;
exceptionHandlerHandle = CATCH_NULL ;
// Register as first handler in current chain
exceptionHandlerHandle = AddVectoredExceptionHandler ( 1 , handleVectoredException ) ;
// Pass in guarantee size to be filled
SetThreadStackGuarantee ( & guaranteeSize ) ;
}
static void reset ( ) { // Install/disengage implementation for specific platform.
if ( isSet ) { // Should be if-defed to work on current platform, can assume
// Unregister handler and restore the old guarantee
// engage-disengage 1:1 pairing.
RemoveVectoredExceptionHandler ( exceptionHandlerHandle ) ;
SetThreadStackGuarantee ( & guaranteeSize ) ;
exceptionHandlerHandle = CATCH_NULL ;
isSet = false ;
}
}
~ FatalConditionHandler ( ) { void engage_platform ( ) {
reset ( ) ; // Register as first handler in current chain
} exceptionHandlerHandle =
private : AddVectoredExceptionHandler ( 1 , handleVectoredException ) ;
static bool isSet ; if ( ! exceptionHandlerHandle ) {
static ULONG guaranteeSize ; throw std : : runtime_error ( " Could not register vectored exception handler " ) ;
static PVOID exceptionHandlerHandle ; }
} ; }
void disengage_platform ( ) {
if ( ! RemoveVectoredExceptionHandler ( exceptionHandlerHandle ) ) {
throw std : : runtime_error (
" Could not unregister vectored exception handler " ) ;
}
exceptionHandlerHandle = CATCH_NULL ;
}
bool FatalConditionHandler : : isSet = false ; public :
ULONG FatalConditionHandler : : guaranteeSize = 0 ; FatalConditionHandler ( ) : m_started ( false ) {
PVOID FatalConditionHandler : : exceptionHandlerHandle = CATCH_NULL ; ULONG guaranteeSize = static_cast < ULONG > ( 32 * 1024 ) ;
if ( ! SetThreadStackGuarantee ( & guaranteeSize ) ) {
// We do not want to fully error out, because needing
// the stack reserve should be rare enough anyway.
Catch : : cerr ( ) < < " Failed to reserve piece of stack. "
< < " Stack overflows will not be reported successfully. " ;
}
}
// We do not attempt to unset the stack guarantee, because
// Windows does not support lowering the stack size guarantee.
~ FatalConditionHandler ( ) { }
void engage ( ) {
assert ( ! m_started & & " Handler cannot be installed twice. " ) ;
m_started = true ;
engage_platform ( ) ;
}
void disengage ( ) {
assert ( m_started & &
" Handler cannot be uninstalled without being installed first " ) ;
m_started = false ;
disengage_platform ( ) ;
}
} ;
} // namespace Catch
} // namespace Catch
# endif // CATCH_CONFIG_WINDOWS_SEH
# endif // CATCH_CONFIG_WINDOWS_SEH
# else // Not Windows - assumed to be POSIX compatible //////////////////////////
# else // Not Windows - assumed to be POSIX compatible //////////////////////////
# if !defined(CATCH_CONFIG_POSIX_SIGNALS) # if !defined(CATCH_CONFIG_POSIX_SIGNALS)
namespace Catch { namespace Catch {
struct FatalConditionHandler { class FatalConditionHandler {
void reset ( ) { } bool m_started ;
} ;
}
# else // CATCH_CONFIG_POSIX_SIGNALS is defined
// Install/disengage implementation for specific platform.
// Should be if-defed to work on current platform, can assume
// engage-disengage 1:1 pairing.
void engage_platform ( ) { }
void disengage_platform ( ) { }
public :
// Should also have platform-specific implementations as needed
FatalConditionHandler ( ) : m_started ( false ) { }
~ FatalConditionHandler ( ) { }
void engage ( ) {
assert ( ! m_started & & " Handler cannot be installed twice. " ) ;
m_started = true ;
engage_platform ( ) ;
}
void disengage ( ) {
assert ( m_started & &
" Handler cannot be uninstalled without being installed first " ) ;
m_started = false ;
disengage_platform ( ) ;
}
} ;
} // namespace Catch
# else // CATCH_CONFIG_POSIX_SIGNALS is defined
# include <signal.h> # include <signal.h>
namespace Catch { namespace Catch {
struct SignalDefs { struct SignalDefs {
int id ; int id ;
const char * name ; const char * name ;
} ; } ;
extern SignalDefs signalDefs [ ] ; extern SignalDefs signalDefs [ ] ;
SignalDefs signalDefs [ ] = { SignalDefs signalDefs [ ] = {
{ SIGINT , " SIGINT - Terminal interrupt signal " } , { SIGINT , " SIGINT - Terminal interrupt signal " } ,
{ SIGILL , " SIGILL - Illegal instruction signal " } , { SIGILL , " SIGILL - Illegal instruction signal " } ,
{ SIGFPE , " SIGFPE - Floating point error signal " } , { SIGFPE , " SIGFPE - Floating point error signal " } ,
{ SIGSEGV , " SIGSEGV - Segmentation violation signal " } , { SIGSEGV , " SIGSEGV - Segmentation violation signal " } ,
{ SIGTERM , " SIGTERM - Termination request signal " } , { SIGTERM , " SIGTERM - Termination request signal " } ,
{ SIGABRT , " SIGABRT - Abort (abnormal termination) signal " } { SIGABRT , " SIGABRT - Abort (abnormal termination) signal " } } ;
} ;
// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
struct FatalConditionHandler { // which is zero initialization, but not explicit. We want to avoid
// that.
static bool isSet ; # if defined(__GNUC__)
static struct sigaction oldSigActions [ sizeof ( signalDefs ) / sizeof ( SignalDefs ) ] ; # pragma GCC diagnostic push
static stack_t oldSigStack ; # pragma GCC diagnostic ignored "-Wmissing-field-initializers"
static char altStackMem [ SIGSTKSZ ] ; # endif
static void handleSignal ( int sig ) { static char * altStackMem = CATCH_NULL ;
std : : string name = " <unknown signal> " ; static std : : size_t altStackSize = 0 ;
for ( std : : size_t i = 0 ; i < sizeof ( signalDefs ) / sizeof ( SignalDefs ) ; + + i ) { static stack_t oldSigStack ;
SignalDefs & def = signalDefs [ i ] ; static struct sigaction oldSigActions [ sizeof ( signalDefs ) / sizeof ( SignalDefs ) ] ;
if ( sig = = def . id ) {
name = def . name ; static void restorePreviousSignalHandlers ( ) {
break ; // We set signal handlers back to the previous ones. Hopefully
} // nobody overwrote them in the meantime, and doesn't expect
} // their signal handlers to live past ours given that they
reset ( ) ; // installed them after ours..
reportFatal ( name ) ; for ( std : : size_t i = 0 ; i < sizeof ( signalDefs ) / sizeof ( SignalDefs ) ; + + i ) {
raise ( sig ) ; sigaction ( signalDefs [ i ] . id , & oldSigActions [ i ] , CATCH_NULL ) ;
} }
// Return the old stack
sigaltstack ( & oldSigStack , CATCH_NULL ) ;
}
FatalConditionHandler ( ) { static void handleSignal ( int sig ) {
isSet = true ; char const * name = " <unknown signal> " ;
stack_t sigStack ; for ( std : : size_t i = 0 ; i < sizeof ( signalDefs ) / sizeof ( SignalDefs ) ; + + i ) {
sigStack . ss_sp = altStackMem ; SignalDefs & def = signalDefs [ i ] ;
sigStack . ss_size = SIGSTKSZ ; if ( sig = = def . id ) {
sigStack . ss_flags = 0 ; name = def . name ;
sigaltstack ( & sigStack , & oldSigStack ) ; break ;
struct sigaction sa = { 0 } ; }
}
// We need to restore previous signal handlers and let them do
// their thing, so that the users can have the debugger break
// when a signal is raised, and so on.
restorePreviousSignalHandlers ( ) ;
reportFatal ( name ) ;
raise ( sig ) ;
}
sa . sa_handler = handleSignal ; class FatalConditionHandler {
sa . sa_flags = SA_ONSTACK ; bool m_started ;
for ( std : : size_t i = 0 ; i < sizeof ( signalDefs ) / sizeof ( SignalDefs ) ; + + i ) {
sigaction ( signalDefs [ i ] . id , & sa , & oldSigActions [ i ] ) ;
}
}
~ FatalConditionHandler ( ) { // Install/disengage implementation for specific platform.
reset ( ) ; // Should be if-defed to work on current platform, can assume
} // engage-disengage 1:1 pairing.
static void reset ( ) {
if ( isSet ) { void engage_platform ( ) {
// Set signals back to previous values -- hopefully nobody overwrote them in the meantime
stack_t sigStack ;
for ( std : : size_t i = 0 ; i < sizeof ( signalDefs ) / sizeof ( SignalDefs ) ; + + i ) { sigStack . ss_sp = altStackMem ;
sigaction ( signalDefs [ i ] . id , & oldSigActions [ i ] , CATCH_NULL ) ; sigStack . ss_size = SIGSTKSZ ;
} sigStack . ss_flags = 0 ;
// Return the old stack
sigaltstack ( & sigStack , & oldSigStack ) ;
sigaltstack ( & oldSigStack , CATCH_NULL ) ; struct sigaction sa = { 0 } ;
isSet = false ;
} sa . sa_handler = handleSignal ;
} sa . sa_flags = SA_ONSTACK ;
} ; for ( std : : size_t i = 0 ; i < sizeof ( signalDefs ) / sizeof ( SignalDefs ) ; + + i ) {
sigaction ( signalDefs [ i ] . id , & sa , & oldSigActions [ i ] ) ;
}
}
void disengage_platform ( ) { restorePreviousSignalHandlers ( ) ; }
bool FatalConditionHandler : : isSet = false ; public :
struct sigaction FatalConditionHandler : : oldSigActions [ sizeof ( signalDefs ) / sizeof ( SignalDefs ) ] = { } ; FatalConditionHandler ( ) : m_started ( false ) {
stack_t FatalConditionHandler : : oldSigStack = { } ; assert ( ! altStackMem & &
char FatalConditionHandler : : altStackMem [ SIGSTKSZ ] = { } ; " Cannot initialize POSIX signal handler when one already exists " ) ;
if ( altStackSize = = 0 ) {
altStackSize = SIGSTKSZ ;
}
altStackMem = new char [ altStackSize ] ( ) ;
}
~ FatalConditionHandler ( ) {
delete [ ] altStackMem ;
// We signal that another instance can be constructed by zeroing
// out the pointer.
altStackMem = CATCH_NULL ;
}
void engage ( ) {
assert ( ! m_started & & " Handler cannot be installed twice. " ) ;
m_started = true ;
engage_platform ( ) ;
}
void disengage ( ) {
assert ( m_started & &
" Handler cannot be uninstalled without being installed first " ) ;
m_started = false ;
disengage_platform ( ) ;
}
} ;
# if defined(__GNUC__)
# pragma GCC diagnostic pop
# endif
} // namespace Catch
} // namespace Catch
# endif // CATCH_CONFIG_POSIX_SIGNALS
# endif // CATCH_CONFIG_POSIX_SIGNALS
# endif // not Windows
# endif // not Windows
namespace Catch {
//! Simple RAII guard for (dis)engaging the FatalConditionHandler
class FatalConditionHandlerGuard {
FatalConditionHandler * m_handler ;
public :
FatalConditionHandlerGuard ( FatalConditionHandler * handler )
: m_handler ( handler ) {
m_handler - > engage ( ) ;
}
~ FatalConditionHandlerGuard ( ) { m_handler - > disengage ( ) ; }
} ;
} // end namespace Catch
# include <cassert> # include <cassert>
# include <set> # include <set>
# include <string> # include <string>
@ -6938,9 +7075,8 @@ namespace Catch {
} }
void invokeActiveTestCase ( ) { void invokeActiveTestCase ( ) {
FatalConditionHandler fatalConditionHandler ; // Handle signals
FatalConditionHandlerGuard _ ( & m_fatalConditionhandler ) ;
m_activeTestCase - > invoke ( ) ; m_activeTestCase - > invoke ( ) ;
fatalConditionHandler . reset ( ) ;
} }
private : private :
@ -6978,6 +7114,7 @@ namespace Catch {
std : : vector < SectionEndInfo > m_unfinishedSections ; std : : vector < SectionEndInfo > m_unfinishedSections ;
std : : vector < ITracker * > m_activeSections ; std : : vector < ITracker * > m_activeSections ;
TrackerContext m_trackerContext ; TrackerContext m_trackerContext ;
FatalConditionHandler m_fatalConditionhandler ;
size_t m_prevPassed ; size_t m_prevPassed ;
bool m_shouldReportUnexpected ; bool m_shouldReportUnexpected ;
} ; } ;
