Flush AND sleep

Refactor pipe-based redirect to not always create new thread and pipe
WIP: rebase pipe redirect onto current redirect interface
2025-09-26 22:35:40 +02:00 · 2024-09-15 20:46:24 +02:00 · 2024-09-15 20:22:40 +02:00 · 2024-09-13 19:17:39 +02:00
14 changed files with 387 additions and 221 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,7 +33,7 @@ if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 endif()

 project(Catch2
-  VERSION 3.7.1 # CML version placeholder, don't delete
+  VERSION 3.7.0 # CML version placeholder, don't delete
  LANGUAGES CXX
  # HOMEPAGE_URL is not supported until CMake version 3.12, which
  # we do not target yet.
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -2,7 +2,6 @@

 # Release notes
 **Contents**<br>
-[3.7.1](#371)<br>
 [3.7.0](#370)<br>
 [3.6.0](#360)<br>
 [3.5.4](#354)<br>
@@ -65,26 +64,6 @@
 [Even Older versions](#even-older-versions)<br>


-## 3.7.1
-
-### Improvements
-* Applied the JUnit reporter's optimization from last release to the SonarQube reporter
-* Suppressed `-Wuseless-cast` in `CHECK_THROWS_MATCHES` (#2904)
-* Standardize exit codes for various failures
-  * Running no tests is now guaranteed to exit with 2 (without the `--allow-running-no-tests` flag)
-  * All tests skipped is now always 4 (...)
-  * Assertion failures are now always 42
-  * and so on
-
-### Fixes
-* Fixed out-of-bounds access when the arg parser encounters single `-` as an argument (#2905)
-
-### Miscellaneous
-* Added `catch_config_prefix_messages.hpp` to meson build (#2903)
-* `catch_discover_tests` now supports skipped tests (#2873)
-  * You can get the old behaviour by calling `catch_discover_tests` with `SKIP_IS_FAILURE` option.
-
-
 ## 3.7.0

 ### Improvements
--- a/extras/Catch.cmake
+++ b/extras/Catch.cmake
@@ -38,7 +38,6 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
                         [OUTPUT_PREFIX prefix]
                         [OUTPUT_SUFFIX suffix]
                         [DISCOVERY_MODE <POST_BUILD|PRE_TEST>]
-                         [SKIP_IS_FAILURE]
    )

  ``catch_discover_tests`` sets up a post-build command on the test executable
@@ -132,7 +131,7 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
    of test cases from the test executable and when the tests are executed themselves.
    This requires cmake/ctest >= 3.22.

-  ``DISCOVERY_MODE mode``
+  `DISCOVERY_MODE mode``
    Provides control over when ``catch_discover_tests`` performs test discovery.
    By default, ``POST_BUILD`` sets up a post-build command to perform test discovery
    at build time. In certain scenarios, like cross-compiling, this ``POST_BUILD``
@@ -144,9 +143,6 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
    ``CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE`` variable if it is not passed when
    calling ``catch_discover_tests``. This provides a mechanism for globally selecting
    a preferred test discovery behavior without having to modify each call site.
-    
-  ``SKIP_IS_FAILURE``
-    Disables skipped test detection.

 #]=======================================================================]

@@ -155,7 +151,7 @@ function(catch_discover_tests TARGET)

  cmake_parse_arguments(
    ""
-    "SKIP_IS_FAILURE"
+    ""
    "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX;DISCOVERY_MODE"
    "TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS;DL_FRAMEWORK_PATHS"
    ${ARGN}
@@ -196,9 +192,6 @@ function(catch_discover_tests TARGET)
    TARGET ${TARGET}
    PROPERTY CROSSCOMPILING_EMULATOR
  )
-  if (NOT _SKIP_IS_FAILURE)
-    set(_PROPERTIES ${_PROPERTIES} SKIP_RETURN_CODE 4)
-  endif()

  if(_DISCOVERY_MODE STREQUAL "POST_BUILD")
    add_custom_command(
--- a/extras/catch_amalgamated.cpp
+++ b/extras/catch_amalgamated.cpp
@@ -6,8 +6,8 @@

 // SPDX-License-Identifier: BSL-1.0

-//  Catch v3.7.1
-//  Generated: 2024-09-17 10:36:45.608896
+//  Catch v3.7.0
+//  Generated: 2024-08-14 12:04:53.604337
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -627,7 +627,7 @@ std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {

 namespace Catch {

-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const& _lazyExpression):
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
        lazyExpression(_lazyExpression),
        resultType(_resultType) {}

@@ -1170,13 +1170,7 @@ namespace Catch {
 namespace Catch {

    namespace {
-        static constexpr int TestFailureExitCode = 42;
-        static constexpr int UnspecifiedErrorExitCode = 1;
-        static constexpr int AllTestsSkippedExitCode = 4;
-        static constexpr int NoTestsRunExitCode = 2;
-        static constexpr int UnmatchedTestSpecExitCode = 3;
-        static constexpr int InvalidTestSpecExitCode = 5;
-
+        const int MaxExitCode = 255;

        IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
@@ -1340,7 +1334,8 @@ namespace Catch {
    }

    int Session::applyCommandLine( int argc, char const * const * argv ) {
-        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
+        if( m_startupExceptions )
+            return 1;

        auto result = m_cli.parse( Clara::Args( argc, argv ) );

@@ -1356,7 +1351,7 @@ namespace Catch {
                << TextFlow::Column( result.errorMessage() ).indent( 2 )
                << "\n\n";
            errStream->stream() << "Run with -? for usage\n\n" << std::flush;
-            return UnspecifiedErrorExitCode;
+            return MaxExitCode;
        }

        if( m_configData.showHelp )
@@ -1426,7 +1421,8 @@ namespace Catch {
    }

    int Session::runInternal() {
-        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
+        if( m_startupExceptions )
+            return 1;

        if (m_configData.showHelp || m_configData.libIdentify) {
            return 0;
@@ -1437,7 +1433,7 @@ namespace Catch {
                          << ") must be greater than the shard index ("
                          << m_configData.shardIndex << ")\n"
                          << std::flush;
-            return UnspecifiedErrorExitCode;
+            return 1;
        }

        CATCH_TRY {
@@ -1460,7 +1456,7 @@ namespace Catch {
                for ( auto const& spec : invalidSpecs ) {
                    reporter->reportInvalidTestSpec( spec );
                }
-                return InvalidTestSpecExitCode;
+                return 1;
            }


@@ -1474,29 +1470,29 @@ namespace Catch {

            if ( tests.hadUnmatchedTestSpecs()
                && m_config->warnAboutUnmatchedTestSpecs() ) {
-                // UnmatchedTestSpecExitCode
-                return UnmatchedTestSpecExitCode;
+                return 3;
            }

            if ( totals.testCases.total() == 0
                && !m_config->zeroTestsCountAsSuccess() ) {
-                return NoTestsRunExitCode;
+                return 2;
            }

            if ( totals.testCases.total() > 0 &&
                 totals.testCases.total() == totals.testCases.skipped
                && !m_config->zeroTestsCountAsSuccess() ) {
-                return AllTestsSkippedExitCode;
+                return 4;
            }

-            if ( totals.assertions.failed ) { return TestFailureExitCode; }
-            return 0;
-
+            // Note that on unices only the lower 8 bits are usually used, clamping
+            // the return value to 255 prevents false negative when some multiple
+            // of 256 tests has failed
+            return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed));
        }
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
        catch( std::exception& ex ) {
            Catch::cerr() << ex.what() << '\n' << std::flush;
-            return UnspecifiedErrorExitCode;
+            return MaxExitCode;
        }
 #endif
    }
@@ -1532,26 +1528,26 @@ namespace Catch {
        static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type),
                      "The size of the TestCaseProperties is different from the assumed size");

-        constexpr TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
+        TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
            return static_cast<TestCaseProperties>(
                static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
            );
        }

-        constexpr TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
+        TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
            lhs = static_cast<TestCaseProperties>(
                static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
            );
            return lhs;
        }

-        constexpr TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
+        TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
            return static_cast<TestCaseProperties>(
                static_cast<TCP_underlying_type>(lhs) & static_cast<TCP_underlying_type>(rhs)
            );
        }

-        constexpr bool applies(TestCaseProperties tcp) {
+        bool applies(TestCaseProperties tcp) {
            static_assert(static_cast<TCP_underlying_type>(TestCaseProperties::None) == 0,
                          "TestCaseProperties::None must be equal to 0");
            return tcp != TestCaseProperties::None;
@@ -1590,7 +1586,7 @@ namespace Catch {
            return "Anonymous test case " + std::to_string(++counter);
        }

-        constexpr StringRef extractFilenamePart(StringRef filename) {
+        StringRef extractFilenamePart(StringRef filename) {
            size_t lastDot = filename.size();
            while (lastDot > 0 && filename[lastDot - 1] != '.') {
                --lastDot;
@@ -1608,7 +1604,7 @@ namespace Catch {
        }

        // Returns the upper bound on size of extra tags ([#file]+[.])
-        constexpr size_t sizeOfExtraTags(StringRef filepath) {
+        size_t sizeOfExtraTags(StringRef filepath) {
            // [.] is 3, [#] is another 3
            const size_t extras = 3 + 3;
            return extractFilenamePart(filepath).size() + extras;
@@ -1769,6 +1765,10 @@ namespace Catch {
        return lhs.tags < rhs.tags;
    }

+    TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const {
+        return *m_info;
+    }
+
 } // end namespace Catch


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

    namespace {
        static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
-            return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
+            return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
        }
    } // end unnamed namespace

@@ -2280,7 +2280,7 @@ namespace Catch {
    }

    Version const& libraryVersion() {
-        static Version version( 3, 7, 1, "", 0 );
+        static Version version( 3, 7, 0, "", 0 );
        return version;
    }

@@ -2536,8 +2536,8 @@ namespace Catch {
    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
    }
-    void AssertionHandler::handleMessage(ResultWas::OfType resultType, std::string&& message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, CATCH_MOVE(message), m_reaction );
+    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef message) {
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
    }

    auto AssertionHandler::allowThrows() const -> bool {
@@ -2683,7 +2683,7 @@ namespace Catch {
                                { TokenType::Argument,
                                  next.substr( delimiterPos + 1, next.size() ) } );
                        } else {
-                            if ( next.size() > 1 && next[1] != '-' && next.size() > 2 ) {
+                            if ( next[1] != '-' && next.size() > 2 ) {
                                // Combined short args, e.g. "-ab" for "-a -b"
                                for ( size_t i = 1; i < next.size(); ++i ) {
                                    m_tokenBuffer.push_back(
@@ -3656,6 +3656,12 @@ namespace Catch {
        return *Context::currentContext;
    }

+    void Context::setResultCapture( IResultCapture* resultCapture ) {
+        m_resultCapture = resultCapture;
+    }
+
+    void Context::setConfig( IConfig const* config ) { m_config = config; }
+
    SimplePcg32& sharedRng() {
        static SimplePcg32 s_rng;
        return s_rng;
@@ -5541,6 +5547,26 @@ ReporterSpec::ReporterSpec(



+namespace Catch {
+
+    bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    bool isJustInfo( int flags ) {
+        return flags == ResultWas::Info;
+    }
+
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+    }
+
+    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+
+
+
 #include <cstdio>
 #include <sstream>
 #include <vector>
@@ -6206,13 +6232,13 @@ namespace Catch {
    void RunContext::handleMessage(
            AssertionInfo const& info,
            ResultWas::OfType resultType,
-            std::string&& message,
+            StringRef message,
            AssertionReaction& reaction
    ) {
        m_lastAssertionInfo = info;

        AssertionResultData data( resultType, LazyExpression( false ) );
-        data.message = CATCH_MOVE( message );
+        data.message = static_cast<std::string>(message);
        AssertionResult assertionResult{ m_lastAssertionInfo,
                                         CATCH_MOVE( data ) };

@@ -7127,7 +7153,7 @@ namespace Catch {
            TestType m_testAsFunction;

        public:
-            constexpr TestInvokerAsFunction( TestType testAsFunction ) noexcept:
+            TestInvokerAsFunction( TestType testAsFunction ) noexcept:
                m_testAsFunction( testAsFunction ) {}

            void invoke() const override { m_testAsFunction(); }
@@ -7862,16 +7888,36 @@ namespace {
        os.flags(f);
    }

-    constexpr bool shouldNewline(XmlFormatting fmt) {
+    bool shouldNewline(XmlFormatting fmt) {
        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline));
    }

-    constexpr bool shouldIndent(XmlFormatting fmt) {
+    bool shouldIndent(XmlFormatting fmt) {
        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent));
    }

 } // anonymous namespace

+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) |
+            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
+        );
+    }
+
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) &
+            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
+        );
+    }
+
+
+    XmlEncode::XmlEncode( StringRef str, ForWhat forWhat )
+    :   m_str( str ),
+        m_forWhat( forWhat )
+    {}
+
    void XmlEncode::encodeTo( std::ostream& os ) const {
        // Apostrophe escaping not necessary if we always use " to write attributes
        // (see: http://www.w3.org/TR/xml/#syntax)
@@ -11004,9 +11050,9 @@ namespace Catch {
        if (!rootName.empty())
            name = rootName + '/' + name;

-        if ( sectionNode.stats.assertions.total() > 0
+        if ( sectionNode.hasAnyAssertions()
            || !sectionNode.stdOut.empty()
-            || !sectionNode.stdErr.empty() ) {
+            ||  !sectionNode.stdErr.empty() ) {
            XmlWriter::ScopedElement e = xml.scopedElement("testCase");
            xml.writeAttribute("name"_sr, name);
            xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
--- a/extras/catch_amalgamated.hpp
+++ b/extras/catch_amalgamated.hpp
@@ -6,8 +6,8 @@

 // SPDX-License-Identifier: BSL-1.0

-//  Catch v3.7.1
-//  Generated: 2024-09-17 10:36:40.974985
+//  Catch v3.7.0
+//  Generated: 2024-08-14 12:04:53.220567
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -555,15 +555,10 @@ namespace Catch {
        friend void cleanUpContext();

    public:
-        constexpr IResultCapture* getResultCapture() const {
-            return m_resultCapture;
-        }
-        constexpr IConfig const* getConfig() const { return m_config; }
-        constexpr void setResultCapture( IResultCapture* resultCapture ) {
-            m_resultCapture = resultCapture;
-        }
-        constexpr void setConfig( IConfig const* config ) { m_config = config; }
-
+        IResultCapture* getResultCapture() const { return m_resultCapture; }
+        IConfig const* getConfig() const { return m_config; }
+        void setResultCapture( IResultCapture* resultCapture );
+        void setConfig( IConfig const* config );
    };

    Context& getCurrentMutableContext();
@@ -674,6 +669,7 @@ namespace Catch {
 #define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED

 #include <string>
+#include <chrono>



@@ -823,10 +819,8 @@ namespace Catch {

    }; };

-    constexpr bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    constexpr bool isJustInfo( int flags ) { return flags == ResultWas::Info; }
+    bool isOk( ResultWas::OfType resultType );
+    bool isJustInfo( int flags );


    // ResultDisposition::Flags enum
@@ -838,18 +832,11 @@ namespace Catch {
        SuppressFail = 0x08         // Failures are reported but do not fail the test
    }; };

-    constexpr ResultDisposition::Flags operator|( ResultDisposition::Flags lhs,
-                                        ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) |
-                                                      static_cast<int>( rhs ) );
-    }
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );

-    constexpr bool isFalseTest( int flags ) {
-        return ( flags & ResultDisposition::FalseTest ) != 0;
-    }
-    constexpr bool shouldSuppressFailure( int flags ) {
-        return ( flags & ResultDisposition::SuppressFail ) != 0;
-    }
+    bool shouldContinueOnFailure( int flags );
+    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
+    bool shouldSuppressFailure( int flags );

 } // end namespace Catch

@@ -1067,7 +1054,7 @@ namespace Catch {
        virtual void handleMessage
                (   AssertionInfo const& info,
                    ResultWas::OfType resultType,
-                    std::string&& message,
+                    StringRef message,
                    AssertionReaction& reaction ) = 0;
        virtual void handleUnexpectedExceptionNotThrown
                (   AssertionInfo const& info,
@@ -1315,7 +1302,7 @@ namespace Catch {
            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
            int high_severe = 0;    // more than 3 times IQR above Q3

-            constexpr int total() const {
+            int total() const {
                return low_severe + low_mild + high_mild + high_severe;
            }
        };
@@ -3280,13 +3267,13 @@ namespace Catch {
        ITransientExpression const* m_transientExpression = nullptr;
        bool m_isNegated;
    public:
-        constexpr LazyExpression( bool isNegated ):
+        LazyExpression( bool isNegated ):
            m_isNegated(isNegated)
        {}
-        constexpr LazyExpression(LazyExpression const& other) = default;
+        LazyExpression(LazyExpression const& other) = default;
        LazyExpression& operator = ( LazyExpression const& ) = delete;

-        constexpr explicit operator bool() const {
+        explicit operator bool() const {
            return m_transientExpression != nullptr;
        }

@@ -4025,7 +4012,7 @@ namespace Catch {
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

 ///////////////////////////////////////////////////////////////////////////////
@@ -5285,9 +5272,6 @@ namespace Catch {
        bool m_isBinaryExpression;
        bool m_result;

-    protected:
-        ~ITransientExpression() = default;
-
    public:
        constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
        constexpr auto getResult() const -> bool { return m_result; }
@@ -5299,13 +5283,17 @@ namespace Catch {
            m_result( result )
        {}

-        constexpr ITransientExpression( ITransientExpression const& ) = default;
-        constexpr ITransientExpression& operator=( ITransientExpression const& ) = default;
+        ITransientExpression() = default;
+        ITransientExpression(ITransientExpression const&) = default;
+        ITransientExpression& operator=(ITransientExpression const&) = default;

        friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) {
            expr.streamReconstructedExpression(out);
            return out;
        }
+
+    protected:
+        ~ITransientExpression() = default;
    };

    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
@@ -5614,12 +5602,12 @@ namespace Catch {


        template<typename T>
-        constexpr void handleExpr( ExprLhs<T> const& expr ) {
+        void handleExpr( ExprLhs<T> const& expr ) {
            handleExpr( expr.makeUnaryExpr() );
        }
        void handleExpr( ITransientExpression const& expr );

-        void handleMessage(ResultWas::OfType resultType, std::string&& message);
+        void handleMessage(ResultWas::OfType resultType, StringRef message);

        void handleExceptionThrownAsExpected();
        void handleUnexpectedExceptionNotThrown();
@@ -5675,6 +5663,8 @@ namespace Catch {

 #endif

+#define INTERNAL_CATCH_REACT( handler ) handler.complete();
+
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
    do { /* NOLINT(bugprone-infinite-loop) */ \
@@ -5687,7 +5677,7 @@ namespace Catch {
            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); /* NOLINT(bugprone-chained-comparison) */ \
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( (void)0, (false) && static_cast<const bool&>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.

@@ -5715,7 +5705,7 @@ namespace Catch {
        catch( ... ) { \
            catchAssertionHandler.handleUnexpectedInflightException(); \
        } \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

 ///////////////////////////////////////////////////////////////////////////////
@@ -5736,7 +5726,7 @@ namespace Catch {
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

 ///////////////////////////////////////////////////////////////////////////////
@@ -5760,7 +5750,7 @@ namespace Catch {
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )


@@ -5784,7 +5774,7 @@ namespace Catch {
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

 #endif // CATCH_CONFIG_DISABLE
@@ -5985,8 +5975,7 @@ template<typename C>
 class TestInvokerAsMethod : public ITestInvoker {
    void (C::*m_testAsMethod)();
 public:
-    constexpr TestInvokerAsMethod( void ( C::*testAsMethod )() ) noexcept:
-        m_testAsMethod( testAsMethod ) {}
+    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}

    void invoke() const override {
        C obj;
@@ -6007,8 +5996,7 @@ class TestInvokerFixture : public ITestInvoker {
    Detail::unique_ptr<C> m_fixture = nullptr;

 public:
-    constexpr TestInvokerFixture( void ( C::*testAsMethod )() const ) noexcept:
-        m_testAsMethod( testAsMethod ) {}
+    TestInvokerFixture( void ( C::*testAsMethod )() const) noexcept : m_testAsMethod( testAsMethod ) {}

    void prepareTestCase() override {
        m_fixture = Detail::make_unique<C>();
@@ -7148,7 +7136,7 @@ namespace Catch {
        TestCaseInfo* m_info;
        ITestInvoker* m_invoker;
    public:
-        constexpr TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
+        TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
            m_info(info), m_invoker(invoker) {}

        void prepareTestCase() const {
@@ -7163,9 +7151,7 @@ namespace Catch {
            m_invoker->invoke();
        }

-        constexpr TestCaseInfo const& getTestCaseInfo() const {
-            return *m_info;
-        }
+        TestCaseInfo const& getTestCaseInfo() const;
    };

    Detail::unique_ptr<TestCaseInfo>
@@ -7228,7 +7214,7 @@ namespace Catch {
        class ExceptionTranslator : public IExceptionTranslator {
        public:

-            constexpr ExceptionTranslator( std::string(*translateFunction)( T const& ) )
+            ExceptionTranslator( std::string(*translateFunction)( T const& ) )
            : m_translateFunction( translateFunction )
            {}

@@ -7330,7 +7316,7 @@ namespace Catch {

 #define CATCH_VERSION_MAJOR 3
 #define CATCH_VERSION_MINOR 7
-#define CATCH_VERSION_PATCH 1
+#define CATCH_VERSION_PATCH 0

 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED

@@ -8057,7 +8043,7 @@ namespace Catch {
        struct ExtendedMultResult {
            T upper;
            T lower;
-            constexpr bool operator==( ExtendedMultResult const& rhs ) const {
+            bool operator==( ExtendedMultResult const& rhs ) const {
                return upper == rhs.upper && lower == rhs.lower;
            }
        };
@@ -8175,7 +8161,6 @@ namespace Catch {
         * get by simple casting ([0, ..., INT_MAX, INT_MIN, ..., -1])
         */
        template <typename OriginalType, typename UnsignedType>
-        constexpr
        std::enable_if_t<std::is_signed<OriginalType>::value, UnsignedType>
        transposeToNaturalOrder( UnsignedType in ) {
            static_assert(
@@ -8196,7 +8181,6 @@ namespace Catch {

        template <typename OriginalType,
                  typename UnsignedType>
-        constexpr
        std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
            transposeToNaturalOrder(UnsignedType in) {
            static_assert(
@@ -8248,24 +8232,24 @@ class uniform_integer_distribution {
    // distribution will be reused many times and this is an optimization.
    UnsignedIntegerType m_rejection_threshold = 0;

-    static constexpr UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) {
+    UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) const {
        // This overflows and returns 0 if a == 0 and b == TYPE_MAX.
        // We handle that later when generating the number.
        return transposeTo(b) - transposeTo(a) + 1;
    }

-    static constexpr UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
+    static UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
        // distance == 0 means that we will return all possible values from
        // the type's range, and that we shouldn't reject anything.
        if ( ab_distance == 0 ) { return 0; }
        return ( ~ab_distance + 1 ) % ab_distance;
    }

-    static constexpr UnsignedIntegerType transposeTo(IntegerType in) {
+    static UnsignedIntegerType transposeTo(IntegerType in) {
        return Detail::transposeToNaturalOrder<IntegerType>(
            static_cast<UnsignedIntegerType>( in ) );
    }
-    static constexpr IntegerType transposeBack(UnsignedIntegerType in) {
+    static IntegerType transposeBack(UnsignedIntegerType in) {
        return static_cast<IntegerType>(
            Detail::transposeToNaturalOrder<IntegerType>(in) );
    }
@@ -8273,7 +8257,7 @@ class uniform_integer_distribution {
 public:
    using result_type = IntegerType;

-    constexpr uniform_integer_distribution( IntegerType a, IntegerType b ):
+    uniform_integer_distribution( IntegerType a, IntegerType b ):
        m_a( transposeTo(a) ),
        m_ab_distance( computeDistance(a, b) ),
        m_rejection_threshold( computeRejectionThreshold(m_ab_distance) ) {
@@ -8281,7 +8265,7 @@ public:
    }

    template <typename Generator>
-    constexpr result_type operator()( Generator& g ) {
+    result_type operator()( Generator& g ) {
        // All possible values of result_type are valid.
        if ( m_ab_distance == 0 ) {
            return transposeBack( Detail::fillBitsFrom<UnsignedIntegerType>( g ) );
@@ -8299,8 +8283,8 @@ public:
        return transposeBack(m_a + emul.upper);
    }

-    constexpr result_type a() const { return transposeBack(m_a); }
-    constexpr result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
+    result_type a() const { return transposeBack(m_a); }
+    result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
 };

 } // end namespace Catch
@@ -9758,7 +9742,6 @@ namespace Catch {
                  typename Sentinel,
                  typename T,
                  typename Comparator>
-        constexpr
        ForwardIter find_sentinel( ForwardIter start,
                                   Sentinel sentinel,
                                   T const& value,
@@ -9774,7 +9757,6 @@ namespace Catch {
                  typename Sentinel,
                  typename T,
                  typename Comparator>
-        constexpr
        std::ptrdiff_t count_sentinel( ForwardIter start,
                                       Sentinel sentinel,
                                       T const& value,
@@ -9788,7 +9770,6 @@ namespace Catch {
        }

        template <typename ForwardIter, typename Sentinel>
-        constexpr
        std::enable_if_t<!std::is_same<ForwardIter, Sentinel>::value,
                         std::ptrdiff_t>
        sentinel_distance( ForwardIter iter, const Sentinel sentinel ) {
@@ -9801,8 +9782,8 @@ namespace Catch {
        }

        template <typename ForwardIter>
-        constexpr std::ptrdiff_t sentinel_distance( ForwardIter first,
-                                                    ForwardIter last ) {
+        std::ptrdiff_t sentinel_distance( ForwardIter first,
+                                          ForwardIter last ) {
            return std::distance( first, last );
        }

@@ -9811,11 +9792,11 @@ namespace Catch {
                  typename ForwardIter2,
                  typename Sentinel2,
                  typename Comparator>
-        constexpr bool check_element_counts( ForwardIter1 first_1,
-                                             const Sentinel1 end_1,
-                                             ForwardIter2 first_2,
-                                             const Sentinel2 end_2,
-                                             Comparator cmp ) {
+        bool check_element_counts( ForwardIter1 first_1,
+                                   const Sentinel1 end_1,
+                                   ForwardIter2 first_2,
+                                   const Sentinel2 end_2,
+                                   Comparator cmp ) {
            auto cursor = first_1;
            while ( cursor != end_1 ) {
                if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
@@ -9845,11 +9826,11 @@ namespace Catch {
                  typename ForwardIter2,
                  typename Sentinel2,
                  typename Comparator>
-        constexpr bool is_permutation( ForwardIter1 first_1,
-                                       const Sentinel1 end_1,
-                                       ForwardIter2 first_2,
-                                       const Sentinel2 end_2,
-                                       Comparator cmp ) {
+        bool is_permutation( ForwardIter1 first_1,
+                             const Sentinel1 end_1,
+                             ForwardIter2 first_2,
+                             const Sentinel2 end_2,
+                             Comparator cmp ) {
            // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
            // TODO: Comparator has to be "both sides", e.g. a == b => b == a
            // This skips shared prefix of the two ranges
@@ -10505,7 +10486,7 @@ namespace Catch {
        void handleMessage
                (   AssertionInfo const& info,
                    ResultWas::OfType resultType,
-                    std::string&& message,
+                    StringRef message,
                    AssertionReaction& reaction ) override;
        void handleUnexpectedExceptionNotThrown
                (   AssertionInfo const& info,
@@ -11290,25 +11271,16 @@ namespace Catch {

 #include <iosfwd>
 #include <vector>
-#include <cstdint>

 namespace Catch {
-    enum class XmlFormatting : std::uint8_t {
+    enum class XmlFormatting {
        None = 0x00,
        Indent = 0x01,
        Newline = 0x02,
    };

-    constexpr XmlFormatting operator|( XmlFormatting lhs, XmlFormatting rhs ) {
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) |
-                                           static_cast<std::uint8_t>( rhs ) );
-    }
-
-    constexpr XmlFormatting operator&( XmlFormatting lhs, XmlFormatting rhs ) {
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) &
-                                           static_cast<std::uint8_t>( rhs ) );
-    }
-
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);

    /**
     * Helper for XML-encoding text (escaping angle brackets, quotes, etc)
@@ -11320,9 +11292,7 @@ namespace Catch {
    public:
        enum ForWhat { ForTextNodes, ForAttributes };

-        constexpr XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes ):
-            m_str( str ), m_forWhat( forWhat ) {}
-
+        XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes );

        void encodeTo( std::ostream& os ) const;

@@ -11485,7 +11455,7 @@ namespace Catch {
        ArgT && m_arg;
        MatcherT const& m_matcher;
    public:
-        constexpr MatchExpr( ArgT && arg, MatcherT const& matcher )
+        MatchExpr( ArgT && arg, MatcherT const& matcher )
        :   ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
            m_arg( CATCH_FORWARD(arg) ),
            m_matcher( matcher )
@@ -11515,8 +11485,7 @@ namespace Catch {
    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );

    template<typename ArgT, typename MatcherT>
-    constexpr MatchExpr<ArgT, MatcherT>
-    makeMatchExpr( ArgT&& arg, MatcherT const& matcher ) {
+    auto makeMatchExpr( ArgT && arg, MatcherT const& matcher ) -> MatchExpr<ArgT, MatcherT> {
        return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher );
    }

@@ -11530,7 +11499,7 @@ namespace Catch {
        INTERNAL_CATCH_TRY { \
            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher ) ); \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )


@@ -11540,10 +11509,7 @@ namespace Catch {
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
-                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
                static_cast<void>(__VA_ARGS__ ); \
-                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( exceptionType const& ex ) { \
@@ -11554,7 +11520,7 @@ namespace Catch {
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )


@@ -12623,14 +12589,12 @@ namespace Catch {

        public:
            template <typename TargetRangeLike2, typename Equality2>
-            constexpr
            RangeEqualsMatcher( TargetRangeLike2&& range,
                                Equality2&& predicate ):
                m_desired( CATCH_FORWARD( range ) ),
                m_predicate( CATCH_FORWARD( predicate ) ) {}

            template <typename RangeLike>
-            constexpr
            bool match( RangeLike&& rng ) const {
                auto rng_start = begin( rng );
                const auto rng_end = end( rng );
@@ -12663,14 +12627,12 @@ namespace Catch {

        public:
            template <typename TargetRangeLike2, typename Equality2>
-            constexpr
            UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
                                         Equality2&& predicate ):
                m_desired( CATCH_FORWARD( range ) ),
                m_predicate( CATCH_FORWARD( predicate ) ) {}

            template <typename RangeLike>
-            constexpr
            bool match( RangeLike&& rng ) const {
                using std::begin;
                using std::end;
@@ -12694,7 +12656,6 @@ namespace Catch {
         * Uses `std::equal_to` to do the comparison
         */
        template <typename RangeLike>
-        constexpr
        std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
                         RangeEqualsMatcher<RangeLike, std::equal_to<>>>
        RangeEquals( RangeLike&& range ) {
@@ -12708,7 +12669,6 @@ namespace Catch {
         * Uses to provided predicate `predicate` to do the comparisons
         */
        template <typename RangeLike, typename Equality>
-        constexpr
        RangeEqualsMatcher<RangeLike, Equality>
        RangeEquals( RangeLike&& range, Equality&& predicate ) {
            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
@@ -12721,7 +12681,6 @@ namespace Catch {
         * Uses `std::equal_to` to do the comparison
         */
        template <typename RangeLike>
-        constexpr
        std::enable_if_t<
            !Detail::is_matcher<RangeLike>::value,
            UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
@@ -12736,7 +12695,6 @@ namespace Catch {
         * Uses to provided predicate `predicate` to do the comparisons
         */
        template <typename RangeLike, typename Equality>
-        constexpr
        UnorderedRangeEqualsMatcher<RangeLike, Equality>
        UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
@@ -13911,7 +13869,7 @@ namespace Catch {
        : CumulativeReporterBase(CATCH_MOVE(config))
        , xml(m_stream) {
            m_preferences.shouldRedirectStdOut = true;
-            m_preferences.shouldReportAllAssertions = false;
+            m_preferences.shouldReportAllAssertions = true;
            m_shouldStoreSuccesfulAssertions = false;
        }

--- a/meson.build
+++ b/meson.build
@@ -8,7 +8,7 @@
 project(
  'catch2',
  'cpp',
-  version: '3.7.1', # CML version placeholder, don't delete
+  version: '3.7.0', # CML version placeholder, don't delete
  license: 'BSL-1.0',
  meson_version: '>=0.54.1',
 )
--- a/src/catch2/catch_session.cpp
+++ b/src/catch2/catch_session.cpp
@@ -34,13 +34,7 @@
 namespace Catch {

    namespace {
-        static constexpr int TestFailureExitCode = 42;
-        static constexpr int UnspecifiedErrorExitCode = 1;
-        static constexpr int AllTestsSkippedExitCode = 4;
-        static constexpr int NoTestsRunExitCode = 2;
-        static constexpr int UnmatchedTestSpecExitCode = 3;
-        static constexpr int InvalidTestSpecExitCode = 5;
-
+        const int MaxExitCode = 255;

        IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
@@ -204,7 +198,8 @@ namespace Catch {
    }

    int Session::applyCommandLine( int argc, char const * const * argv ) {
-        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
+        if( m_startupExceptions )
+            return 1;

        auto result = m_cli.parse( Clara::Args( argc, argv ) );

@@ -220,7 +215,7 @@ namespace Catch {
                << TextFlow::Column( result.errorMessage() ).indent( 2 )
                << "\n\n";
            errStream->stream() << "Run with -? for usage\n\n" << std::flush;
-            return UnspecifiedErrorExitCode;
+            return MaxExitCode;
        }

        if( m_configData.showHelp )
@@ -290,7 +285,8 @@ namespace Catch {
    }

    int Session::runInternal() {
-        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
+        if( m_startupExceptions )
+            return 1;

        if (m_configData.showHelp || m_configData.libIdentify) {
            return 0;
@@ -301,7 +297,7 @@ namespace Catch {
                          << ") must be greater than the shard index ("
                          << m_configData.shardIndex << ")\n"
                          << std::flush;
-            return UnspecifiedErrorExitCode;
+            return 1;
        }

        CATCH_TRY {
@@ -324,7 +320,7 @@ namespace Catch {
                for ( auto const& spec : invalidSpecs ) {
                    reporter->reportInvalidTestSpec( spec );
                }
-                return InvalidTestSpecExitCode;
+                return 1;
            }


@@ -338,29 +334,29 @@ namespace Catch {

            if ( tests.hadUnmatchedTestSpecs()
                && m_config->warnAboutUnmatchedTestSpecs() ) {
-                // UnmatchedTestSpecExitCode
-                return UnmatchedTestSpecExitCode;
+                return 3;
            }

            if ( totals.testCases.total() == 0
                && !m_config->zeroTestsCountAsSuccess() ) {
-                return NoTestsRunExitCode;
+                return 2;
            }

            if ( totals.testCases.total() > 0 &&
                 totals.testCases.total() == totals.testCases.skipped
                && !m_config->zeroTestsCountAsSuccess() ) {
-                return AllTestsSkippedExitCode;
+                return 4;
            }

-            if ( totals.assertions.failed ) { return TestFailureExitCode; }
-            return 0;
-
+            // Note that on unices only the lower 8 bits are usually used, clamping
+            // the return value to 255 prevents false negative when some multiple
+            // of 256 tests has failed
+            return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed));
        }
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
        catch( std::exception& ex ) {
            Catch::cerr() << ex.what() << '\n' << std::flush;
-            return UnspecifiedErrorExitCode;
+            return MaxExitCode;
        }
 #endif
    }
--- a/src/catch2/catch_version.cpp
+++ b/src/catch2/catch_version.cpp
@@ -36,7 +36,7 @@ namespace Catch {
    }

    Version const& libraryVersion() {
-        static Version version( 3, 7, 1, "", 0 );
+        static Version version( 3, 7, 0, "", 0 );
        return version;
    }

--- a/src/catch2/catch_version_macros.hpp
+++ b/src/catch2/catch_version_macros.hpp
@@ -10,6 +10,6 @@

 #define CATCH_VERSION_MAJOR 3
 #define CATCH_VERSION_MINOR 7
-#define CATCH_VERSION_PATCH 1
+#define CATCH_VERSION_PATCH 0

 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED
--- a/src/catch2/internal/catch_output_redirect.cpp
+++ b/src/catch2/internal/catch_output_redirect.cpp
@@ -17,12 +17,19 @@
 #include <iosfwd>
 #include <sstream>

-#if defined( CATCH_CONFIG_NEW_CAPTURE )
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <thread>
+#include <mutex>
+#endif
+
+#if defined( CATCH_CONFIG_NEW_CAPTURE ) || defined(CATCH_CONFIG_USE_ASYNC)
 #    if defined( _MSC_VER )
 #        include <io.h> //_dup and _dup2
+#        include <fcntl.h> // _O_BINARY
 #        define dup _dup
 #        define dup2 _dup2
 #        define fileno _fileno
+#        define close _close
 #    else
 #        include <unistd.h> // dup and dup2
 #    endif
@@ -48,13 +55,13 @@ namespace Catch {
         * that the underlying stream's rdbuf aren't changed by other
         * users.
         */
-        class RedirectedStreamNew {
+        class RedirectedStream {
            std::ostream& m_originalStream;
            std::ostream& m_redirectionStream;
            std::streambuf* m_prevBuf;

        public:
-            RedirectedStreamNew( std::ostream& originalStream,
+            RedirectedStream( std::ostream& originalStream,
                                 std::ostream& redirectionStream ):
                m_originalStream( originalStream ),
                m_redirectionStream( redirectionStream ),
@@ -72,7 +79,7 @@ namespace Catch {
         */
        class StreamRedirect : public OutputRedirect {
            ReusableStringStream m_redirectedOut, m_redirectedErr;
-            RedirectedStreamNew m_cout, m_cerr, m_clog;
+            RedirectedStream m_cout, m_cerr, m_clog;

        public:
            StreamRedirect():
@@ -244,6 +251,182 @@ namespace Catch {

 #endif // CATCH_CONFIG_NEW_CAPTURE

+
+#if defined( CATCH_CONFIG_USE_ASYNC )
+
+        static inline void pipe_or_throw( int descriptors[2] ) {
+#    if defined( _MSC_VER )
+            constexpr int defaultPipeSize{ 0 };
+
+            int result{ _pipe( descriptors, defaultPipeSize, _O_BINARY ) };
+#    else
+            int result{ pipe( descriptors ) };
+#    endif
+
+            if ( result ) {
+                CATCH_INTERNAL_ERROR( "pipe-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+        }
+
+        static inline size_t
+        read_or_throw( int descriptor, void* buffer, size_t size ) {
+#    if defined( _MSC_VER )
+            int result{
+                _read( descriptor, buffer, static_cast<unsigned>( size ) ) };
+#    else
+            ssize_t result{ read( descriptor, buffer, size ) };
+#    endif
+
+            if ( result == -1 ) {
+                CATCH_INTERNAL_ERROR( "read-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+
+            return static_cast<size_t>( result );
+        }
+
+        static inline void close_or_throw( int descriptor ) {
+            if ( close( descriptor ) ) {
+                CATCH_INTERNAL_ERROR( "close-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+        }
+
+        static inline int dup_or_throw( int descriptor ) {
+            int result{ dup( descriptor ) };
+
+            if ( result == -1 ) {
+                CATCH_INTERNAL_ERROR( "dup-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+
+            return result;
+        }
+
+        static inline int dup2_or_throw( int sourceDescriptor,
+                                         int destinationDescriptor ) {
+            int result{ dup2( sourceDescriptor, destinationDescriptor ) };
+
+            if ( result == -1 ) {
+                CATCH_INTERNAL_ERROR( "dup2-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+
+            return result;
+        }
+
+        static inline int fileno_or_throw( std::FILE* file ) {
+            int result{ fileno( file ) };
+
+            if ( result == -1 ) {
+                CATCH_INTERNAL_ERROR( "fileno-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+
+            return result;
+        }
+
+        static inline void fflush_or_throw( std::FILE* file ) {
+            if ( std::fflush( file ) ) {
+                CATCH_INTERNAL_ERROR( "fflush-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+        }
+
+        class StreamPipeHandler {
+            int m_originalFd = -1;
+            int m_pipeReadEnd = -1;
+            int m_pipeWriteEnd = -1;
+            FILE* m_targetStream;
+            std::mutex m_mutex;
+            std::string m_captured;
+            std::thread m_readThread;
+
+        public:
+            StreamPipeHandler( FILE* original ):
+                m_originalFd( dup_or_throw( fileno( original ) ) ),
+                m_targetStream(original)
+            {
+                CATCH_ENFORCE( m_originalFd >= 0, "Could not dup stream" );
+                int pipe_fds[2];
+                pipe_or_throw( pipe_fds );
+                m_pipeReadEnd = pipe_fds[0];
+                m_pipeWriteEnd = pipe_fds[1];
+
+                m_readThread = std::thread([this]() {
+                    constexpr size_t bufferSize = 4096;
+                    char buffer[bufferSize];
+                    size_t sizeRead;
+                    while ( ( sizeRead = read_or_throw(
+                                  m_pipeReadEnd, buffer, bufferSize ) ) != 0 ) {
+                        std::unique_lock<std::mutex> _( m_mutex );
+                        m_captured.append( buffer, sizeRead );
+                    }
+                });
+            }
+
+            ~StreamPipeHandler() {
+                close_or_throw( m_pipeWriteEnd );
+                m_readThread.join();
+            }
+
+            std::string getCapturedOutput() {
+                std::unique_lock<std::mutex> _( m_mutex );
+                return m_captured;
+            }
+
+            void clearCapturedOutput() {
+                std::unique_lock<std::mutex> _( m_mutex );
+                m_captured.clear();
+            }
+
+            void startCapture() {
+                fflush_or_throw( m_targetStream );
+                int ret = dup2_or_throw( m_pipeWriteEnd, fileno( m_targetStream ) );
+                CATCH_ENFORCE( ret >= 0,
+                               "dup2 pipe-write -> original stream failed " << errno );
+            }
+            void stopCapture() {
+                fflush_or_throw( m_targetStream );
+                int ret = dup2_or_throw( m_originalFd, fileno( m_targetStream ) );
+                CATCH_ENFORCE( ret >= 0,
+                               "dup2 of original fd -> original stream failed " << errno );
+            }
+        };
+
+        class PipeRedirect : public OutputRedirect {
+        private:
+            StreamPipeHandler m_stdout;
+            StreamPipeHandler m_stderr;
+        public:
+            PipeRedirect():
+                m_stdout(stdout),
+                m_stderr(stderr){}
+
+            void activateImpl() override {
+                m_stdout.startCapture();
+                m_stderr.startCapture();
+            }
+            void deactivateImpl() override {
+                m_stdout.stopCapture();
+                m_stderr.stopCapture();
+            }
+            std::string getStdout() override {
+                return m_stdout.getCapturedOutput();
+            }
+            std::string getStderr() override {
+                return m_stderr.getCapturedOutput();
+            }
+            void clearBuffers() override {
+                m_stdout.clearCapturedOutput();
+                m_stderr.clearCapturedOutput();
+            }
+        };
+
+#endif // CATCH_CONFIG_USE_ASYNC
+
+
    } // end namespace

    bool isRedirectAvailable( OutputRedirect::Kind kind ) {
@@ -255,6 +438,10 @@ namespace Catch {
 #if defined( CATCH_CONFIG_NEW_CAPTURE )
        case OutputRedirect::FileDescriptors:
            return true;
+#endif
+#if defined(CATCH_CONFIG_USE_ASYNC)
+        case OutputRedirect::Pipes:
+            return true;
 #endif
        default:
            return false;
@@ -267,7 +454,8 @@ namespace Catch {
 #if defined( CATCH_CONFIG_NEW_CAPTURE )
            return Detail::make_unique<FileRedirect>();
 #else
-            return Detail::make_unique<StreamRedirect>();
+            //return Detail::make_unique<StreamRedirect>();
+            return Detail::make_unique<PipeRedirect>();
 #endif
        } else {
            return Detail::make_unique<NoopRedirect>();
--- a/src/catch2/internal/catch_output_redirect.hpp
+++ b/src/catch2/internal/catch_output_redirect.hpp
@@ -25,8 +25,10 @@ namespace Catch {
            None,
            //! Redirect std::cout/std::cerr/std::clog streams internally
            Streams,
-            //! Redirect the stdout/stderr file descriptors into files
+            //! Redirect the stdout/stderr file descriptors into temp files
            FileDescriptors,
+            //! Redirect the stdout/stderr file descriptors into anonymous pipes
+            Pipes,
        };

        virtual ~OutputRedirect(); // = default;
--- a/src/catch2/internal/catch_xmlwriter.hpp
+++ b/src/catch2/internal/catch_xmlwriter.hpp
@@ -13,23 +13,22 @@

 #include <iosfwd>
 #include <vector>
-#include <cstdint>

 namespace Catch {
-    enum class XmlFormatting : std::uint8_t {
+    enum class XmlFormatting : uint8_t {
        None = 0x00,
        Indent = 0x01,
        Newline = 0x02,
    };

    constexpr XmlFormatting operator|( XmlFormatting lhs, XmlFormatting rhs ) {
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) |
-                                           static_cast<std::uint8_t>( rhs ) );
+        return static_cast<XmlFormatting>( static_cast<uint8_t>( lhs ) |
+                                           static_cast<uint8_t>( rhs ) );
    }

    constexpr XmlFormatting operator&( XmlFormatting lhs, XmlFormatting rhs ) {
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) &
-                                           static_cast<std::uint8_t>( rhs ) );
+        return static_cast<XmlFormatting>( static_cast<uint8_t>( lhs ) &
+                                           static_cast<uint8_t>( rhs ) );
    }


--- a/tests/SelfTest/UsageTests/Tricky.tests.cpp
+++ b/tests/SelfTest/UsageTests/Tricky.tests.cpp
@@ -308,10 +308,15 @@ TEST_CASE( "X/level/0/b", "[Tricky][fizz]" ){ SUCCEED(""); }
 TEST_CASE( "X/level/1/a", "[Tricky]" )      { SUCCEED(""); }
 TEST_CASE( "X/level/1/b", "[Tricky]" )      { SUCCEED(""); }

+#include <chrono>
+#include <thread>
+
 TEST_CASE( "has printf" ) {

    // This can cause problems as, currently, stdout itself is not redirected - only the cout (and cerr) buffer
    printf( "loose text artifact\n" );
+    fflush( stdout );
+    std::this_thread::sleep_for( std::chrono::seconds( 1 ) );
 }

 namespace {
--- a/tests/TestScripts/testBazelReporter.py
+++ b/tests/TestScripts/testBazelReporter.py
@@ -52,7 +52,7 @@ try:
    )
    stdout = ret.stdout
 except subprocess.SubprocessError as ex:
-    if ex.returncode == 42:
+    if ex.returncode == 1:
        # The test cases are allowed to fail.
        test_passing = False
        stdout = ex.stdout
Author	SHA1	Message	Date
Martin Hořeňovský	432695291a	Flush AND sleep	2024-09-15 20:46:24 +02:00
Martin Hořeňovský	e63f3cc817	Refactor pipe-based redirect to not always create new thread and pipe	2024-09-15 20:22:40 +02:00
Martin Hořeňovský	986ee2c793	WIP: rebase pipe redirect onto current redirect interface	2024-09-13 19:17:39 +02:00