From ec4b275c7dab0af781c8e2571021d4821736eef9 Mon Sep 17 00:00:00 2001

From: Michael Wallner <mike@php.net>

Date: Fri, 25 Jun 2021 08:17:53 +0200

Subject: [PATCH] fix gh issue #113

---

 ChangeLog-1.1.md              |   8 +

 docs/source/ChangeLog-1.1.rst |  12 +

 scripts/download_catch2.sh    |   5 +

 test/lib/catch.hpp            | 548 +++++++++++++++++++++-------------

 4 files changed, 368 insertions(+), 205 deletions(-)

 create mode 100755 scripts/download_catch2.sh

diff --git a/test/lib/catch.hpp b/test/lib/catch.hpp

index cf1fae15..36eaeb27 100644

--- a/test/lib/catch.hpp

+++ b/test/lib/catch.hpp

@@ -1,9 +1,9 @@

 /*

- *  Catch v2.13.0

- *  Generated: 2020-07-12 20:07:49.015950

+ *  Catch v2.13.6

+ *  Generated: 2021-04-16 18:23:38.044268

  *  ----------------------------------------------------------

  *  This file has been merged from multiple headers. Please don't edit it directly

- *  Copyright (c) 2020 Two Blue Cubes Ltd. All rights reserved.

+ *  Copyright (c) 2021 Two Blue Cubes Ltd. All rights reserved.

  *

  *  Distributed under the Boost Software License, Version 1.0. (See accompanying

  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

@@ -15,7 +15,7 @@

 #define CATCH_VERSION_MAJOR 2

 #define CATCH_VERSION_MINOR 13

-#define CATCH_VERSION_PATCH 0

+#define CATCH_VERSION_PATCH 6

 #ifdef __clang__

 #    pragma clang system_header

@@ -66,13 +66,16 @@

 #if !defined(CATCH_CONFIG_IMPL_ONLY)

 // start catch_platform.h

+// See e.g.:

+// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html

 #ifdef __APPLE__

-# include <TargetConditionals.h>

-# if TARGET_OS_OSX == 1

-#  define CATCH_PLATFORM_MAC

-# elif TARGET_OS_IPHONE == 1

-#  define CATCH_PLATFORM_IPHONE

-# endif

+#  include <TargetConditionals.h>

+#  if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \

+      (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)

+#    define CATCH_PLATFORM_MAC

+#  elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)

+#    define CATCH_PLATFORM_IPHONE

+#  endif

 #elif defined(linux) || defined(__linux) || defined(__linux__)

 #  define CATCH_PLATFORM_LINUX

@@ -132,13 +135,9 @@ namespace Catch {

 #endif

-#if defined(__cpp_lib_uncaught_exceptions)

-#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS

-#endif

-

-// We have to avoid both ICC and Clang, because they try to mask themselves

-// as gcc, and we want only GCC in this block

-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)

+// Only GCC compiler should be used in this block, so other compilers trying to

+// mask themselves as GCC should be ignored.

+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__)

 #    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )

 #    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )

@@ -162,7 +161,7 @@ namespace Catch {

 // ```

 //

 // Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.

-#  if !defined(__ibmxl__)

+#  if !defined(__ibmxl__) && !defined(__CUDACC__)

 #    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */

 #  endif

@@ -244,10 +243,6 @@ namespace Catch {

 #  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )

 #  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )

-#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer

-#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS

-#  endif

-

 // Universal Windows platform does not support SEH

 // Or console colours (or console at all...)

 #  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)

@@ -330,7 +325,10 @@ namespace Catch {

   // Check if byte is available and usable

   #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)

-  #    define CATCH_INTERNAL_CONFIG_CPP17_BYTE

+  #    include <cstddef>

+  #    if __cpp_lib_byte > 0

+  #      define CATCH_INTERNAL_CONFIG_CPP17_BYTE

+  #    endif

   #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)

   // Check if variant is available and usable

@@ -373,10 +371,6 @@ namespace Catch {

 #  define CATCH_CONFIG_CPP17_OPTIONAL

 #endif

-#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)

-#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS

-#endif

-

 #if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)

 #  define CATCH_CONFIG_CPP17_STRING_VIEW

 #endif

@@ -1105,7 +1099,7 @@ struct AutoReg : NonCopyable {

                     int index = 0;                                    \

                     constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\

                     using expander = int[];\

-                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \

+                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \

                 }\

             };\

             static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\

@@ -1151,7 +1145,7 @@ struct AutoReg : NonCopyable {

                     constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\

                     constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\

                     constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\

-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\

+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */\

                 }                                                     \

             };                                                        \

             static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \

@@ -1195,7 +1189,7 @@ struct AutoReg : NonCopyable {

             void reg_tests() {                                          \

                 int index = 0;                                    \

                 using expander = int[];                           \

-                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\

+                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\

             }                                                     \

         };\

         static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \

@@ -1229,7 +1223,7 @@ struct AutoReg : NonCopyable {

                     int index = 0;                                    \

                     constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\

                     using expander = int[];\

-                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \

+                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \

                 }\

             };\

             static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\

@@ -1278,7 +1272,7 @@ struct AutoReg : NonCopyable {

                     constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\

                     constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\

                     constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\

-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \

+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */ \

                 }\

             };\

             static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\

@@ -1325,7 +1319,7 @@ struct AutoReg : NonCopyable {

                 void reg_tests(){\

                     int index = 0;\

                     using expander = int[];\

-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \

+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \

                 }\

             };\

             static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\

@@ -1829,8 +1823,8 @@ namespace Catch {

 #endif

     namespace Detail {

-        template<typename InputIterator>

-        std::string rangeToString(InputIterator first, InputIterator last) {

+        template<typename InputIterator, typename Sentinel = InputIterator>

+        std::string rangeToString(InputIterator first, Sentinel last) {

             ReusableStringStream rss;

             rss << "{ ";

             if (first != last) {

@@ -7063,8 +7057,8 @@ namespace Catch {

                 double b2 = bias - z1;

                 double a1 = a(b1);

                 double a2 = a(b2);

-                auto lo = std::max(cumn(a1), 0);

-                auto hi = std::min(cumn(a2), n - 1);

+                auto lo = (std::max)(cumn(a1), 0);

+                auto hi = (std::min)(cumn(a2), n - 1);

                 return { point, resample[lo], resample[hi], confidence_level };

             }

@@ -7133,7 +7127,9 @@ namespace Catch {

             }

             template <typename Clock>

             EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {

-                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));

+                auto time_limit = (std::min)(

+                    resolution * clock_cost_estimation_tick_limit,

+                    FloatDuration<Clock>(clock_cost_estimation_time_limit));

                 auto time_clock = [](int k) {

                     return Detail::measure<Clock>([k] {

                         for (int i = 0; i < k; ++i) {

@@ -7611,6 +7607,10 @@ namespace TestCaseTracking {

         void addInitialFilters( std::vector<std::string> const& filters );

         void addNextFilters( std::vector<std::string> const& filters );

+        //! Returns filters active in this tracker

+        std::vector<std::string> const& getFilters() const;

+        //! Returns whitespace-trimmed name of the tracked section

+        std::string const& trimmedName() const;

     };

 } // namespace TestCaseTracking

@@ -7776,7 +7776,7 @@ namespace Catch {

                 double sb = stddev.point;

                 double mn = mean.point / n;

                 double mg_min = mn / 2.;

-                double sg = std::min(mg_min / 4., sb / std::sqrt(n));

+                double sg = (std::min)(mg_min / 4., sb / std::sqrt(n));

                 double sg2 = sg * sg;

                 double sb2 = sb * sb;

@@ -7795,7 +7795,7 @@ namespace Catch {

                     return (nc / n) * (sb2 - nc * sg2);

                 };

-                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;

+                return (std::min)(var_out(1), var_out((std::min)(c_max(0.), c_max(mg_min)))) / sb2;

             }

             bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {

@@ -7985,86 +7985,58 @@ namespace Catch {

 // start catch_fatal_condition.h

-// start catch_windows_h_proxy.h

-

-

-#if defined(CATCH_PLATFORM_WINDOWS)

-

-#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)

-#  define CATCH_DEFINED_NOMINMAX

-#  define NOMINMAX

-#endif

-#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)

-#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN

-#  define WIN32_LEAN_AND_MEAN

-#endif

-

-#ifdef __AFXDLL

-#include <AfxWin.h>

-#else

-#include <windows.h>

-#endif

-

-#ifdef CATCH_DEFINED_NOMINMAX

-#  undef NOMINMAX

-#endif

-#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN

-#  undef WIN32_LEAN_AND_MEAN

-#endif

-

-#endif // defined(CATCH_PLATFORM_WINDOWS)

-

-// end catch_windows_h_proxy.h

-#if defined( CATCH_CONFIG_WINDOWS_SEH )

+#include <cassert>

 namespace Catch {

-    struct FatalConditionHandler {

-

-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);

+    // Wrapper for platform-specific fatal error (signals/SEH) handlers

+    //

+    // Tries to be cooperative with other handlers, and not step over

+    // other handlers. This means that unknown structured exceptions

+    // are passed on, previous signal handlers are called, and so on.

+    //

+    // Can only be instantiated once, and assumes that once a signal

+    // is caught, the binary will end up terminating. Thus, there

+    class FatalConditionHandler {

+        bool m_started = false;

+

+        // 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();

-        static void reset();

         ~FatalConditionHandler();

-    private:

-        static bool isSet;

-        static ULONG guaranteeSize;

-        static PVOID exceptionHandlerHandle;

-    };

-

-} // namespace Catch

-

-#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )

-

-#include <signal.h>

-

-namespace Catch {

-

-    struct FatalConditionHandler {

-

-        static bool isSet;

-        static struct sigaction oldSigActions[];

-        static stack_t oldSigStack;

-        static char altStackMem[];

-

-        static void handleSignal( int sig );

+        void engage() {

+            assert(!m_started && "Handler cannot be installed twice.");

+            m_started = true;

+            engage_platform();

+        }

-        FatalConditionHandler();

-        ~FatalConditionHandler();

-        static void reset();

+        void disengage() {

+            assert(m_started && "Handler cannot be uninstalled without being installed first");

+            m_started = false;

+            disengage_platform();

+        }

     };

-} // namespace Catch

-

-#else

-

-namespace Catch {

-    struct FatalConditionHandler {

-        void reset();

+    //! 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();

+        }

     };

-}

-#endif

+} // end namespace Catch

 // end catch_fatal_condition.h

 #include <string>

@@ -8190,6 +8162,7 @@ namespace Catch {

         std::vector<SectionEndInfo> m_unfinishedSections;

         std::vector<ITracker*> m_activeSections;

         TrackerContext m_trackerContext;

+        FatalConditionHandler m_fatalConditionhandler;

         bool m_lastAssertionPassed = false;

         bool m_shouldReportUnexpected = true;

         bool m_includeSuccessfulResults;

@@ -10062,6 +10035,36 @@ namespace Catch {

 }

 // end catch_errno_guard.h

+// start catch_windows_h_proxy.h

+

+

+#if defined(CATCH_PLATFORM_WINDOWS)

+

+#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)

+#  define CATCH_DEFINED_NOMINMAX

+#  define NOMINMAX

+#endif

+#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)

+#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN

+#  define WIN32_LEAN_AND_MEAN

+#endif

+

+#ifdef __AFXDLL

+#include <AfxWin.h>

+#else

+#include <windows.h>

+#endif

+

+#ifdef CATCH_DEFINED_NOMINMAX

+#  undef NOMINMAX

+#endif

+#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN

+#  undef WIN32_LEAN_AND_MEAN

+#endif

+

+#endif // defined(CATCH_PLATFORM_WINDOWS)

+

+// end catch_windows_h_proxy.h

 #include <sstream>

 namespace Catch {

@@ -10578,7 +10581,7 @@ namespace Catch {

             // Extracts the actual name part of an enum instance

             // In other words, it returns the Blue part of Bikeshed::Colour::Blue

             StringRef extractInstanceName(StringRef enumInstance) {

-                // Find last occurence of ":"

+                // Find last occurrence of ":"

                 size_t name_start = enumInstance.size();

                 while (name_start > 0 && enumInstance[name_start - 1] != ':') {

                     --name_start;

@@ -10740,25 +10743,47 @@ namespace Catch {

 // end catch_exception_translator_registry.cpp

 // start catch_fatal_condition.cpp

-#if defined(__GNUC__)

-#    pragma GCC diagnostic push

-#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"

-#endif

+#include <algorithm>

+

+#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )

+

+namespace Catch {

+

+    // If neither SEH nor signal handling is required, the handler impls

+    // do not have to do anything, and can be empty.

+    void FatalConditionHandler::engage_platform() {}

+    void FatalConditionHandler::disengage_platform() {}

+    FatalConditionHandler::FatalConditionHandler() = default;

+    FatalConditionHandler::~FatalConditionHandler() = default;

+

+} // end namespace Catch

+

+#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS

+

+#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )

+#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"

+#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS

 #if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )

 namespace {

-    // Report the error condition

+    //! Signals fatal error message to the run context

     void reportFatal( char const * const message ) {

         Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );

     }

-}

-#endif // signals/SEH handling

+    //! Minimal size Catch2 needs for its own fatal error handling.

+    //! Picked anecdotally, so it might not be sufficient on all

+    //! platforms, and for all configurations.

+    constexpr std::size_t minStackSizeForErrors = 32 * 1024;

+} // end unnamed namespace

+

+#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS

 #if defined( CATCH_CONFIG_WINDOWS_SEH )

 namespace Catch {

+

     struct SignalDefs { DWORD id; const char* name; };

     // There is no 1-1 mapping between signals and windows exceptions.

@@ -10771,7 +10796,7 @@ namespace Catch {

         { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },

     };

-    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {

+    static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {

         for (auto const& def : signalDefs) {

             if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {

                 reportFatal(def.name);

@@ -10782,38 +10807,50 @@ namespace Catch {

         return EXCEPTION_CONTINUE_SEARCH;

     }

+    // 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 = nullptr;

+

+    // For MSVC, we reserve part of the stack memory for handling

+    // memory overflow structured exception.

     FatalConditionHandler::FatalConditionHandler() {

-        isSet = true;

-        // 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 = nullptr;

+        ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors);

+        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::~FatalConditionHandler() = default;

+

+    void FatalConditionHandler::engage_platform() {

         // Register as first handler in current chain

         exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);

-        // Pass in guarantee size to be filled

-        SetThreadStackGuarantee(&guaranteeSize);

+        if (!exceptionHandlerHandle) {

+            CATCH_RUNTIME_ERROR("Could not register vectored exception handler");

+        }

     }

-    void FatalConditionHandler::reset() {

-        if (isSet) {

-            RemoveVectoredExceptionHandler(exceptionHandlerHandle);

-            SetThreadStackGuarantee(&guaranteeSize);

-            exceptionHandlerHandle = nullptr;

-            isSet = false;

+    void FatalConditionHandler::disengage_platform() {

+        if (!RemoveVectoredExceptionHandler(exceptionHandlerHandle)) {

+            CATCH_RUNTIME_ERROR("Could not unregister vectored exception handler");

         }

+        exceptionHandlerHandle = nullptr;

     }

-    FatalConditionHandler::~FatalConditionHandler() {

-        reset();

-    }

+} // end namespace Catch

-bool FatalConditionHandler::isSet = false;

-ULONG FatalConditionHandler::guaranteeSize = 0;

-PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;

+#endif // CATCH_CONFIG_WINDOWS_SEH

-} // namespace Catch

+#if defined( CATCH_CONFIG_POSIX_SIGNALS )

-#elif defined( CATCH_CONFIG_POSIX_SIGNALS )

+#include <signal.h>

 namespace Catch {

@@ -10822,10 +10859,6 @@ namespace Catch {

         const char* name;

     };

-    // 32kb for the alternate stack seems to be sufficient. However, this value

-    // is experimentally determined, so that's not guaranteed.

-    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;

-

     static SignalDefs signalDefs[] = {

         { SIGINT,  "SIGINT - Terminal interrupt signal" },

         { SIGILL,  "SIGILL - Illegal instruction signal" },

@@ -10835,7 +10868,32 @@ namespace Catch {

         { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }

     };

-    void FatalConditionHandler::handleSignal( int sig ) {

+// 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 char* altStackMem = nullptr;

+    static std::size_t altStackSize = 0;

+    static stack_t oldSigStack{};

+    static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};

+

+    static void restorePreviousSignalHandlers() {

+        // 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

+        // installed them after ours..

+        for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {

+            sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);

+        }

+        // Return the old stack

+        sigaltstack(&oldSigStack, nullptr);

+    }

+

+    static void handleSignal( int sig ) {

         char const * name = "<unknown signal>";

         for (auto const& def : signalDefs) {

             if (sig == def.id) {

@@ -10843,16 +10901,33 @@ namespace Catch {

                 break;

             }

         }

-        reset();

-        reportFatal(name);

+        // 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 );

     }

     FatalConditionHandler::FatalConditionHandler() {

-        isSet = true;

+        assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");

+        if (altStackSize == 0) {

+            altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);

+        }

+        altStackMem = new char[altStackSize]();

+    }

+

+    FatalConditionHandler::~FatalConditionHandler() {

+        delete[] altStackMem;

+        // We signal that another instance can be constructed by zeroing

+        // out the pointer.

+        altStackMem = nullptr;

+    }

+

+    void FatalConditionHandler::engage_platform() {

         stack_t sigStack;

         sigStack.ss_sp = altStackMem;

-        sigStack.ss_size = sigStackSize;

+        sigStack.ss_size = altStackSize;

         sigStack.ss_flags = 0;

         sigaltstack(&sigStack, &oldSigStack);

         struct sigaction sa = { };

@@ -10864,40 +10939,17 @@ namespace Catch {

         }

     }

-    FatalConditionHandler::~FatalConditionHandler() {

-        reset();

-    }

+#if defined(__GNUC__)

+#    pragma GCC diagnostic pop

+#endif

-    void FatalConditionHandler::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], nullptr);

-            }

-            // Return the old stack

-            sigaltstack(&oldSigStack, nullptr);

-            isSet = false;

-        }

+    void FatalConditionHandler::disengage_platform() {

+        restorePreviousSignalHandlers();

     }

-    bool FatalConditionHandler::isSet = false;

-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};

-    stack_t FatalConditionHandler::oldSigStack = {};

-    char FatalConditionHandler::altStackMem[sigStackSize] = {};

-

-} // namespace Catch

-

-#else

-

-namespace Catch {

-    void FatalConditionHandler::reset() {}

-}

-

-#endif // signals/SEH handling

+} // end namespace Catch

-#if defined(__GNUC__)

-#    pragma GCC diagnostic pop

-#endif

+#endif // CATCH_CONFIG_POSIX_SIGNALS

 // end catch_fatal_condition.cpp

 // start catch_generators.cpp

@@ -11452,7 +11504,8 @@ namespace {

             return lhs == rhs;

         }

-        auto ulpDiff = std::abs(lc - rc);

+        // static cast as a workaround for IBM XLC

+        auto ulpDiff = std::abs(static_cast<FP>(lc - rc));

         return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;

     }

@@ -11626,7 +11679,6 @@ Floating::WithinRelMatcher WithinRel(float target) {

 } // namespace Matchers

 } // namespace Catch

-

 // end catch_matchers_floating.cpp

 // start catch_matchers_generic.cpp

@@ -12042,7 +12094,7 @@ namespace Catch {

         if (tmpnam_s(m_buffer)) {

             CATCH_RUNTIME_ERROR("Could not get a temp filename");

         }

-        if (fopen_s(&m_file, m_buffer, "w")) {

+        if (fopen_s(&m_file, m_buffer, "w+")) {

             char buffer[100];

             if (strerror_s(buffer, errno)) {

                 CATCH_RUNTIME_ERROR("Could not translate errno to a string");

@@ -12580,13 +12632,53 @@ namespace Catch {

                 // `SECTION`s.

                 // **The check for m_children.empty cannot be removed**.

                 // doing so would break `GENERATE` _not_ followed by `SECTION`s.

-                const bool should_wait_for_child =

-                    !m_children.empty() &&