Update catch.hpp (fixes #1856)

See also catchorg/Catch2#2627

extras/tests/catch/catch.hpp

@@ -1,6 +1,6 @@
 /*
  *  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
  *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
@@ -214,7 +214,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // 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 __GNUC__ && __GNUC__ >= 3 ) || \
     ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
@@ -2129,6 +2129,9 @@ namespace Catch{
         #define CATCH_TRAP() \
                 __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
                 : : : "memory","r0","r3","r4" ) /* NOLINT */
+    #elif defined(__aarch64__)
+        // Backport of https://github.com/catchorg/Catch2/commit/a25c1a24af8bffd35727a888a307ff0280cf9387
+        #define CATCH_TRAP() __asm__(".inst 0xd4200000")
     #else
         #define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ )
     #endif
@@ -6392,18 +6395,21 @@ CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
 // #included from: catch_fatal_condition.hpp
 #define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
 
+#include <cassert>
+#include <stdexcept>
+
 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
 
-#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+#if defined(CATCH_PLATFORM_WINDOWS) /////////////////////////////////////////
 // #included from: catch_windows_h_proxy.h
 
 #define TWOBLUECUBES_CATCH_WINDOWS_H_PROXY_H_INCLUDED
@@ -6429,176 +6435,307 @@ namespace Catch {
 #endif
 
 
-#  if !defined ( CATCH_CONFIG_WINDOWS_SEH )
+#if !defined(CATCH_CONFIG_WINDOWS_SEH)
 
 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
+
+namespace Catch {
+
+struct SignalDefs {
+  DWORD id;
+  const char *name;
+};
+extern SignalDefs signalDefs[];
+// There is no 1-1 mapping between signals and windows exceptions.
+// Windows can easily distinguish between SO and SigSegV,
+// but SigInt, SigTerm, etc are handled differently.
+SignalDefs signalDefs[] = {
+    {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"},
+};
+
+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;
 }
 
-#  else // CATCH_CONFIG_WINDOWS_SEH is defined
+// Since we do not support multiple instantiations, we put these
+// into global variables and rely on cleaning them up in outlined
+// constructors/destructors
+static PVOID exceptionHandlerHandle = CATCH_NULL;
 
-namespace Catch {
+class FatalConditionHandler {
+  bool m_started;
 
-    struct SignalDefs { DWORD id; const char* name; };
+  // Install/disengage implementation for specific platform.
-    extern SignalDefs signalDefs[];
+  // Should be if-defed to work on current platform, can assume
-    // There is no 1-1 mapping between signals and windows exceptions.
+  // engage-disengage 1:1 pairing.
-    // Windows can easily distinguish between SO and SigSegV,
-    // but SigInt, SigTerm, etc are handled differently.
-    SignalDefs signalDefs[] = {
-        { 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 {
+  void engage_platform() {
+    // Register as first handler in current chain
+    exceptionHandlerHandle =
+        AddVectoredExceptionHandler(1, handleVectoredException);
+    if (!exceptionHandlerHandle) {
+      throw std::runtime_error("Could not register vectored exception handler");
+    }
+  }
 
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
+  void disengage_platform() {
-            for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+    if (!RemoveVectoredExceptionHandler(exceptionHandlerHandle)) {
-                if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
+      throw std::runtime_error(
-                    reportFatal(signalDefs[i].name);
+          "Could not unregister vectored exception handler");
-                }
+    }
-            }
+    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() {
+public:
-            isSet = true;
+  FatalConditionHandler() : m_started(false) {
-            // 32k seems enough for Catch to handle stack overflow,
+    ULONG guaranteeSize = static_cast<ULONG>(32 * 1024);
-            // but the value was found experimentally, so there is no strong guarantee
+    if (!SetThreadStackGuarantee(&guaranteeSize)) {
-            guaranteeSize = 32 * 1024;
+      // We do not want to fully error out, because needing
-            exceptionHandlerHandle = CATCH_NULL;
+      // the stack reserve should be rare enough anyway.
-            // Register as first handler in current chain
+      Catch::cerr() << "Failed to reserve piece of stack."
-            exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+                    << " Stack overflows will not be reported successfully.";
-            // Pass in guarantee size to be filled
+    }
-            SetThreadStackGuarantee(&guaranteeSize);
+  }
-        }
 
-        static void reset() {
+  // We do not attempt to unset the stack guarantee, because
-            if (isSet) {
+  // Windows does not support lowering the stack size guarantee.
-                // Unregister handler and restore the old guarantee
+  ~FatalConditionHandler() {}
-                RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-                SetThreadStackGuarantee(&guaranteeSize);
-                exceptionHandlerHandle = CATCH_NULL;
-                isSet = false;
-            }
-        }
 
-        ~FatalConditionHandler() {
+  void engage() {
-            reset();
+    assert(!m_started && "Handler cannot be installed twice.");
-        }
+    m_started = true;
-    private:
+    engage_platform();
-        static bool isSet;
+  }
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };
 
-    bool FatalConditionHandler::isSet = false;
+  void disengage() {
-    ULONG FatalConditionHandler::guaranteeSize = 0;
+    assert(m_started &&
-    PVOID FatalConditionHandler::exceptionHandlerHandle = CATCH_NULL;
+           "Handler cannot be uninstalled without being installed first");
+    m_started = false;
+    disengage_platform();
+  }
+};
 
 } // namespace Catch
 
-#  endif // CATCH_CONFIG_WINDOWS_SEH
+#endif // CATCH_CONFIG_WINDOWS_SEH
 
 #else // Not Windows - assumed to be POSIX compatible //////////////////////////
 
-#  if !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#if !defined(CATCH_CONFIG_POSIX_SIGNALS)
 
 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>
 
 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"}};
-    };
 
-    struct FatalConditionHandler {
+// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
+// which is zero initialization, but not explicit. We want to avoid
+// that.
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
 
-        static bool isSet;
+static char *altStackMem = CATCH_NULL;
-        static struct sigaction oldSigActions [sizeof(signalDefs)/sizeof(SignalDefs)];
+static std::size_t altStackSize = 0;
-        static stack_t oldSigStack;
+static stack_t oldSigStack;
-        static char altStackMem[SIGSTKSZ];
+static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)];
 
-        static void handleSignal( int sig ) {
+static void restorePreviousSignalHandlers() {
-            std::string name = "<unknown signal>";
+  // We set signal handlers back to the previous ones. Hopefully
-            for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+  // nobody overwrote them in the meantime, and doesn't expect
-                SignalDefs &def = signalDefs[i];
+  // their signal handlers to live past ours given that they
-                if (sig == def.id) {
+  // installed them after ours..
-                    name = def.name;
+  for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
-                    break;
+    sigaction(signalDefs[i].id, &oldSigActions[i], CATCH_NULL);
-                }
+  }
-            }
+  // Return the old stack
-            reset();
+  sigaltstack(&oldSigStack, CATCH_NULL);
-            reportFatal(name);
+}
-            raise( sig );
-        }
 
-        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 ) {
-                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
-                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
-                    sigaction(signalDefs[i].id, &oldSigActions[i], CATCH_NULL);
-                }
-                // Return the old stack
-                sigaltstack(&oldSigStack, CATCH_NULL);
-                isSet = false;
-            }
-        }
-    };
 
-    bool FatalConditionHandler::isSet = false;
+  void engage_platform() {
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
+    stack_t sigStack;
-    stack_t FatalConditionHandler::oldSigStack = {};
+    sigStack.ss_sp = altStackMem;
-    char FatalConditionHandler::altStackMem[SIGSTKSZ] = {};
+    sigStack.ss_size = SIGSTKSZ;
+    sigStack.ss_flags = 0;
+    sigaltstack(&sigStack, &oldSigStack);
+    struct sigaction sa = {0};
+
+    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(); }
+
+public:
+  FatalConditionHandler() : m_started(false) {
+    assert(!altStackMem &&
+           "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
 
-#  endif // CATCH_CONFIG_POSIX_SIGNALS
+#endif // CATCH_CONFIG_POSIX_SIGNALS
 
 #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 <set>
 #include <string>
@@ -6938,9 +7075,8 @@ namespace Catch {
         }
 
         void invokeActiveTestCase() {
-            FatalConditionHandler fatalConditionHandler; // Handle signals
+            FatalConditionHandlerGuard _(&m_fatalConditionhandler);
             m_activeTestCase->invoke();
-            fatalConditionHandler.reset();
         }
 
     private:
@@ -6978,6 +7114,7 @@ namespace Catch {
         std::vector<SectionEndInfo> m_unfinishedSections;
         std::vector<ITracker*> m_activeSections;
         TrackerContext m_trackerContext;
+        FatalConditionHandler m_fatalConditionhandler;
         size_t m_prevPassed;
         bool m_shouldReportUnexpected;
     };