v1.7.1 build

This reverts commit 39753558eb.

README.md

@@ -1,10 +1,10 @@
 ![catch logo](catch-logo-small.png)
 
-*v1.7.0*
+*v1.7.1*
 
 Build status (on Travis CI) [![Build Status](https://travis-ci.org/philsquared/Catch.svg?branch=master)](https://travis-ci.org/philsquared/Catch)
 
-<a href="https://github.com/philsquared/Catch/releases/download/v1.7.0/catch.hpp">The latest, single header, version can be downloaded directly using this link</a>
+<a href="https://github.com/philsquared/Catch/releases/download/v1.7.1/catch.hpp">The latest, single header, version can be downloaded directly using this link</a>
 
 ## What's the Catch?
 

docs/Readme.md

@@ -12,6 +12,7 @@ Before looking at this material be sure to read the [tutorial](tutorial.md)
 * [Configuration](configuration.md)
 * [String Conversions](tostring.md)
 * [Why are my tests slow to compile?](slow-compiles.md)
+* [Known limitations](limitations.md)
 
 Other
 

docs/assertions.md

@@ -78,6 +78,20 @@ Expects that an exception of the _specified type_ is thrown during evaluation of
 
 Expects that no exception is thrown during evaluation of the expression.
 
+
+Please note that the `THROW` family of assertions expects to be passed a single expression, not a statement or series of statements. If you want to check a more complicated sequence of operations, you can use a C++11 lambda function.
+
+```cpp
+REQUIRE_NOTHROW([&](){
+    int i = 1;
+    int j = 2;
+    auto k = i + j;
+    if (k == 3) {
+        throw 1;
+    }
+}());
+```
+
 ## Matcher expressions
 
 To support Matchers a slightly different form is used. Matchers will be more fully documented elsewhere. *Note that Matchers are still at early stage development and are subject to change.*

docs/configuration.md

@@ -1,6 +1,6 @@
 Catch is designed to "just work" as much as possible. For most people the only configuration needed is telling Catch which source file should host all the implementation code (```CATCH_CONFIG_MAIN```).
 
-Nonetheless there are still some occasions where finer control is needed. For these occasions Catch exposes a small set of macros for configuring how it is built.
+Nonetheless there are still some occasions where finer control is needed. For these occasions Catch exposes a set of macros for configuring how it is built.
 
 #  main()/ implementation
 
@@ -70,6 +70,15 @@ You may also suppress any of these features by using the `_NO_` form, e.g. `CATC
 
 All C++11 support can be disabled with `CATCH_CONFIG_NO_CPP11`
 
+# Other toggles
+
+    CATCH_CONFIG_COUNTER                    // Use __COUNTER__ to generate unique names for test cases
+    CATCH_CONFIG_WINDOWS_SEH                // Enable SEH handling on Windows
+
+Currently Catch enables `CATCH_CONFIG_WINDOWS_SEH` only when compiled with MSVC, because some versions of MinGW do not have the necessary Win32 API supports.
+
+Just as with the C++11 conformance toggles, these toggles can be disabled by using `_NO_` form of the toggle, e.g. `CATCH_CONFIG_NO_WINDOWS_SEH`.
+
 # Windows header clutter
 
 On Windows Catch includes `windows.h`. To minimize global namespace clutter in the implementation file, it defines `NOMINMAX` and `WIN32_LEAN_AND_MEAN` before including it. You can control this behaviour via two macros:

docs/limitations.md

@@ -0,0 +1,94 @@
+# Known limitations
+
+Catch has some known limitations, that we are not planning to change. Some of these are caused by our desire to support C++98 compilers, some of these are caused by our desire to keep Catch crossplatform, some exist because their priority is seen as low compared to the development effort they would need and some other yet are compiler/runtime bugs.
+
+## Features
+This section outlines some missing features, what is their status and their possible workarounds.
+
+### Thread safe assertions
+Because threading support in standard C++98 is limited (well, non-existent), assertion macros in Catch are not thread safe. This does not mean that you cannot use threads inside Catch's test, but that only single thread can interact with Catch's assertions and other macros.
+
+This means that this is ok
+```cpp
+    std::vector<std::thread> threads;
+    std::atomic<int> cnt{ 0 };
+    for (int i = 0; i < 4; ++i) {
+        threads.emplace_back([&]() {
+            ++cnt; ++cnt; ++cnt; ++cnt;
+        });
+    }
+    for (auto& t : threads) { t.join(); }
+    REQUIRE(cnt == 16);
+```
+because only one thread passes the `REQUIRE` macro and this is not
+```cpp
+    std::vector<std::thread> threads;
+    std::atomic<int> cnt{ 0 };
+    for (int i = 0; i < 4; ++i) {
+        threads.emplace_back([&]() {
+            ++cnt; ++cnt; ++cnt; ++cnt;
+            CHECK(cnt == 16);
+        });
+    }
+    for (auto& t : threads) { t.join(); }
+    REQUIRE(cnt == 16);
+```
+
+
+_This limitation is highly unlikely to be lifted before Catch 2 is released._
+
+### Process isolation in a test
+Catch does not support running tests in isolated (forked) processes. While this might in the future, the fact that Windows does not support forking and only allows full-on process creation and the desire to keep code as similar as possible across platforms, mean that this is likely to take significant development time, that is not currently available.
+
+### Running multiple tests in parallel
+Catch's test execution is strictly serial. If you find yourself with a test suite that takes too long to run and you want to make it parallel, there are 2 feasible solutions
+ * You can split your tests into multiple binaries and then run these binaries in parallel.
+ * You can have Catch list contained test cases and then run the same test binary multiple times in parallel, passing each instance list of test cases it should run.
+
+Both of these solutions have their problems, but should let you wring parallelism out of your test suite.
+
+## 3rd party bugs
+This section outlines known bugs in 3rd party components (this means compilers, standard libraries, standard runtimes).
+
+### Visual Studio 2013 -- do-while loop withing range based for fails to compile (C2059)
+There is a known bug in Visual Studio 2013 (VC 12), that causes compilation error if range based for is followed by an assertion macro, without enclosing the block in braces. This snippet is sufficient to trigger the error
+```cpp
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+TEST_CASE("Syntax error with VC12") {
+    for ( auto x : { 1 , 2, 3 } )
+        REQUIRE( x < 3.14 );
+}
+```
+An easy workaround is possible, use braces:
+```cpp
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+TEST_CASE("No longer a syntax error with VC12") {
+    for ( auto x : { 1 , 2, 3 } ) {
+        REQUIRE( x < 3.14 );
+    }
+}
+```
+
+### Clang/G++ -- skipping leaf sections after an exception
+Some versions of `libc++` and `libstdc++` (or their runtimes) have a bug with `std::uncaught_exception()` getting stuck returning `true` after rethrow, even if there are no active exceptions. One such case is this snippet, which skipped the sections "a" and "b", when compiled against `libcxxrt` from master
+```cpp
+#define CATCH_CONFIG_MAIN
+#include <catch.hpp>
+
+TEST_CASE("a") {
+    CHECK_THROWS(throw 3);
+}
+
+TEST_CASE("b") {
+    int i = 0;
+    SECTION("a") { i = 1; }
+    SECTION("b") { i = 2; }
+    CHECK(i > 0);
+}
+```
+
+If you are seeing a problem like this, i.e. a weird test paths that trigger only under Clang with `libc++`, or only under very specific version of `libstdc++`, it is very likely you are seeing this. The only known workaround is to use a fixed version of your standard library.

docs/release-notes.md

@@ -1,4 +1,19 @@
-# 1.7.0
+# 1.7.1
+
+### Fixes:
+* Fixed inconsistency in defining `NOMINMAX` and `WIN32_LEAN_AND_MEAN` inside `catch.hpp`.
+* Fixed SEH-related compilation error under older MinGW compilers, by making Windows SEH handling opt-in for compilers other than MSVC.
+  * For specifics, look into the [documentation](docs/configuration.md).
+* Fixed compilation error under MinGW caused by improper compiler detection.
+* Fixed XML reporter sometimes leaving an empty output file when a test ends with signal/structured exception.
+* Fixed XML reporter not reporting captured stdout/stderr.
+* Fixed possible infinite recursion in Windows SEH.
+* Fixed possible compilation error caused by Catch's operator overloads being ambiguous in regards to user-defined templated operators.
+
+# Older versions
+Release notes were not maintained prior to v1.6.0, but you should be able to work them out from the Git history
+
+## 1.7.0
 
 ### Features/ Changes:
 * Catch now runs significantly faster for passing tests
@@ -25,12 +40,6 @@
 * Catch's CMakeLists now generates projects with warnings enabled.
 
 
-
-
-
-# Older versions
-Release notes were not maintained prior to v1.6.0, but you should be able to work them out from the Git history
-
 ## 1.6.1
 
 ### Features/ Changes:

include/internal/catch_compiler_capabilities.h

@@ -26,6 +26,7 @@
 
 // CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported?
 // CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
+// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
 // ****************
 // Note to maintainers: if new toggles are added please document them
 // in configuration.md, too
@@ -109,6 +110,8 @@
 // Visual C++
 #ifdef _MSC_VER
 
+#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+
 #if (_MSC_VER >= 1600)
 #   define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
 #   define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
@@ -233,6 +236,9 @@
 # if defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_NO_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_NO_CPP11)
 #  define CATCH_CONFIG_CPP11_TYPE_TRAITS
 # endif
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH)
+#   define CATCH_CONFIG_WINDOWS_SEH
+#endif
 
 #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS

include/internal/catch_expression_lhs.hpp

@@ -29,45 +29,45 @@ public:
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsEqualTo, RhsT const&>
-    operator == ( RhsT const& rhs ) const {
+    operator == ( RhsT const& rhs ) {
         return captureExpression<Internal::IsEqualTo>( rhs );
     }
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsNotEqualTo, RhsT const&>
-    operator != ( RhsT const& rhs ) const {
+    operator != ( RhsT const& rhs ) {
         return captureExpression<Internal::IsNotEqualTo>( rhs );
     }
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsLessThan, RhsT const&>
-    operator < ( RhsT const& rhs ) const {
+    operator < ( RhsT const& rhs ) {
         return captureExpression<Internal::IsLessThan>( rhs );
     }
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsGreaterThan, RhsT const&>
-    operator > ( RhsT const& rhs ) const {
+    operator > ( RhsT const& rhs ) {
         return captureExpression<Internal::IsGreaterThan>( rhs );
     }
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsLessThanOrEqualTo, RhsT const&>
-    operator <= ( RhsT const& rhs ) const {
+    operator <= ( RhsT const& rhs ) {
         return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
     }
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsGreaterThanOrEqualTo, RhsT const&>
-    operator >= ( RhsT const& rhs ) const {
+    operator >= ( RhsT const& rhs ) {
         return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
     }
 
-    BinaryExpression<T, Internal::IsEqualTo, bool> operator == ( bool rhs ) const {
+    BinaryExpression<T, Internal::IsEqualTo, bool> operator == ( bool rhs ) {
         return captureExpression<Internal::IsEqualTo>( rhs );
     }
 
-    BinaryExpression<T, Internal::IsNotEqualTo, bool> operator != ( bool rhs ) const {
+    BinaryExpression<T, Internal::IsNotEqualTo, bool> operator != ( bool rhs ) {
         return captureExpression<Internal::IsNotEqualTo>( rhs );
     }
 

include/internal/catch_fatal_condition.hpp

@@ -22,13 +22,17 @@ namespace Catch {
 } // namespace Catch
 
 #if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+#include "catch_windows_h_proxy.h"
 
-#define NOMINMAX
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#undef WIN32_LEAN_AND_MEAN
-#undef NOMINMAX
+#  if !defined ( CATCH_CONFIG_WINDOWS_SEH )
 
+namespace Catch {
+    struct FatalConditionHandler {
+        void reset() {}        
+    };
+}
+
+#  else // CATCH_CONFIG_WINDOWS_SEH is defined
 
 namespace Catch {
 
@@ -49,6 +53,7 @@ namespace Catch {
         static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
             for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
                 if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
+                    reset();
                     reportFatal(signalDefs[i].name);
                 }
             }
@@ -57,22 +62,25 @@ namespace Catch {
             return EXCEPTION_CONTINUE_SEARCH;
         }
 
+        FatalConditionHandler() {
+            isSet = true;
             // 32k seems enough for Catch to handle stack overflow,
             // but the value was found experimentally, so there is no strong guarantee
-        FatalConditionHandler():m_isSet(true), m_guaranteeSize(32 * 1024), m_exceptionHandlerHandle(CATCH_NULL) {
+            guaranteeSize = 32 * 1024;
+            exceptionHandlerHandle = CATCH_NULL;
             // Register as first handler in current chain
-            m_exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+            exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
             // Pass in guarantee size to be filled
-            SetThreadStackGuarantee(&m_guaranteeSize);
+            SetThreadStackGuarantee(&guaranteeSize);
         }
 
-        void reset() {
-            if (m_isSet) {
+        static void reset() {
+            if (isSet) {
                 // Unregister handler and restore the old guarantee
-                RemoveVectoredExceptionHandler(m_exceptionHandlerHandle);
-                SetThreadStackGuarantee(&m_guaranteeSize);
-                m_exceptionHandlerHandle = CATCH_NULL;
-                m_isSet = false;
+                RemoveVectoredExceptionHandler(exceptionHandlerHandle);
+                SetThreadStackGuarantee(&guaranteeSize);
+                exceptionHandlerHandle = CATCH_NULL;
+                isSet = false;
             }
         }
 
@@ -80,13 +88,19 @@ namespace Catch {
             reset();
         }
     private:
-        bool m_isSet;
-        ULONG m_guaranteeSize;
-        PVOID m_exceptionHandlerHandle;
+        static bool isSet;
+        static ULONG guaranteeSize;
+        static PVOID exceptionHandlerHandle;
     };
 
+    bool FatalConditionHandler::isSet = false;
+    ULONG FatalConditionHandler::guaranteeSize = 0;
+    PVOID FatalConditionHandler::exceptionHandlerHandle = CATCH_NULL;
+
 } // namespace Catch
 
+#  endif // CATCH_CONFIG_WINDOWS_SEH
+
 #else // Not Windows - assumed to be POSIX compatible //////////////////////////
 
 #include <signal.h>

include/internal/catch_version.hpp

@@ -37,7 +37,7 @@ namespace Catch {
         return os;
     }
 
-    Version libraryVersion( 1, 7, 0, "", 0 );
+    Version libraryVersion( 1, 7, 1, "", 0 );
 
 }
 

include/internal/catch_xmlwriter.hpp

@@ -153,12 +153,13 @@ namespace Catch {
             newlineIfNecessary();
             m_indent = m_indent.substr( 0, m_indent.size()-2 );
             if( m_tagIsOpen ) {
-                stream() << "/>\n";
+                stream() << "/>";
                 m_tagIsOpen = false;
             }
             else {
-                stream() << m_indent << "</" << m_tags.back() << ">\n";
+                stream() << m_indent << "</" << m_tags.back() << ">";
             }
+            stream() << std::endl;
             m_tags.pop_back();
             return *this;
         }

include/reporters/catch_reporter_junit.hpp

@@ -26,7 +26,7 @@ namespace Catch {
             std::time(&rawtime);
             const size_t timeStampSize = sizeof("2017-01-16T17:06:45Z");
 
-#ifdef CATCH_PLATFORM_WINDOWS
+#ifdef _MSC_VER
             std::tm timeInfo = {};
             gmtime_s(&timeInfo, &rawtime);
 #else
@@ -37,7 +37,7 @@ namespace Catch {
             char timeStamp[timeStampSize];
             const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
 
-#ifdef CATCH_PLATFORM_WINDOWS
+#ifdef _MSC_VER
             std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
 #else
             std::strftime(timeStamp, timeStampSize, fmt, timeInfo);

include/reporters/catch_reporter_xml.hpp

@@ -164,6 +164,11 @@ namespace Catch {
             if ( m_config->showDurations() == ShowDurations::Always )
                 e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
 
+            if( !testCaseStats.stdOut.empty() )
+                m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), false );
+            if( !testCaseStats.stdErr.empty() )
+                m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), false );
+
             m_xml.endElement();
         }
 

projects/SelfTest/Baselines/xml.sw.approved.txt

@@ -6799,7 +6799,14 @@ re>"
       <OverallResult success="true"/>
     </TestCase>
     <TestCase name="Sends stuff to stdout and stderr">
-      <OverallResult success="true"/>
+      <OverallResult success="true">
+        <StdOut>
+A string sent directly to stdout
+        </StdOut>
+        <StdErr>
+A string sent directly to stderr
+        </StdErr>
+      </OverallResult>
     </TestCase>
     <TestCase name="Some simple comparisons between doubles">
       <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/ApproxTests.cpp" >
@@ -6859,7 +6866,12 @@ re>"
       <Section name="two">
         <OverallResults successes="0" failures="1" expectedFailures="0"/>
       </Section>
-      <OverallResult success="false"/>
+      <OverallResult success="false">
+        <StdOut>
+Message from section one
+Message from section two
+        </StdOut>
+      </OverallResult>
     </TestCase>
     <TestCase name="StartsWith string matcher">
       <Expression success="false" type="CHECK_THAT" filename="projects/<exe-name>/MiscTests.cpp" >
@@ -6908,7 +6920,12 @@ re>"
       <OverallResult success="true"/>
     </TestCase>
     <TestCase name="Strings can be rendered with colour">
-      <OverallResult success="true"/>
+      <OverallResult success="true">
+        <StdOut>
+hello
+hello
+        </StdOut>
+      </OverallResult>
     </TestCase>
     <TestCase name="Tabs and newlines show in output">
       <Expression success="false" type="CHECK" filename="projects/<exe-name>/MiscTests.cpp" >

single_include/catch.hpp

@@ -1,6 +1,6 @@
 /*
- *  Catch v1.7.0
- *  Generated: 2017-02-01 21:32:13.239291
+ *  Catch v1.7.1
+ *  Generated: 2017-02-07 09:44:56.263047
  *  ----------------------------------------------------------
  *  This file has been merged from multiple headers. Please don't edit it directly
  *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
@@ -81,6 +81,7 @@
 
 // CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported?
 // CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
+// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
 // ****************
 // Note to maintainers: if new toggles are added please document them
 // in configuration.md, too
@@ -160,6 +161,8 @@
 // Visual C++
 #ifdef _MSC_VER
 
+#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+
 #if (_MSC_VER >= 1600)
 #   define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
 #   define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
@@ -284,6 +287,9 @@
 # if defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_NO_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_NO_CPP11)
 #  define CATCH_CONFIG_CPP11_TYPE_TRAITS
 # endif
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH)
+#   define CATCH_CONFIG_WINDOWS_SEH
+#endif
 
 #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
@@ -1878,45 +1884,45 @@ public:
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsEqualTo, RhsT const&>
-    operator == ( RhsT const& rhs ) const {
+    operator == ( RhsT const& rhs ) {
         return captureExpression<Internal::IsEqualTo>( rhs );
     }
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsNotEqualTo, RhsT const&>
-    operator != ( RhsT const& rhs ) const {
+    operator != ( RhsT const& rhs ) {
         return captureExpression<Internal::IsNotEqualTo>( rhs );
     }
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsLessThan, RhsT const&>
-    operator < ( RhsT const& rhs ) const {
+    operator < ( RhsT const& rhs ) {
         return captureExpression<Internal::IsLessThan>( rhs );
     }
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsGreaterThan, RhsT const&>
-    operator > ( RhsT const& rhs ) const {
+    operator > ( RhsT const& rhs ) {
         return captureExpression<Internal::IsGreaterThan>( rhs );
     }
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsLessThanOrEqualTo, RhsT const&>
-    operator <= ( RhsT const& rhs ) const {
+    operator <= ( RhsT const& rhs ) {
         return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
     }
 
     template<typename RhsT>
     BinaryExpression<T, Internal::IsGreaterThanOrEqualTo, RhsT const&>
-    operator >= ( RhsT const& rhs ) const {
+    operator >= ( RhsT const& rhs ) {
         return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
     }
 
-    BinaryExpression<T, Internal::IsEqualTo, bool> operator == ( bool rhs ) const {
+    BinaryExpression<T, Internal::IsEqualTo, bool> operator == ( bool rhs ) {
         return captureExpression<Internal::IsEqualTo>( rhs );
     }
 
-    BinaryExpression<T, Internal::IsNotEqualTo, bool> operator != ( bool rhs ) const {
+    BinaryExpression<T, Internal::IsNotEqualTo, bool> operator != ( bool rhs ) {
         return captureExpression<Internal::IsNotEqualTo>( rhs );
     }
 
@@ -6117,12 +6123,40 @@ namespace Catch {
 } // namespace Catch
 
 #if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+// #included from: catch_windows_h_proxy.h
 
+#define TWOBLUECUBES_CATCH_WINDOWS_H_PROXY_H_INCLUDED
+
+#ifdef CATCH_DEFINES_NOMINMAX
 #  define NOMINMAX
+#endif
+#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
 #  define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifdef __AFXDLL
+#include <AfxWin.h>
+#else
 #include <windows.h>
-#undef WIN32_LEAN_AND_MEAN
+#endif
+
+#ifdef CATCH_DEFINES_NOMINMAX
 #  undef NOMINMAX
+#endif
+#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
+#  undef WIN32_LEAN_AND_MEAN
+#endif
+
+
+#  if !defined ( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+    struct FatalConditionHandler {
+        void reset() {}
+    };
+}
+
+#  else // CATCH_CONFIG_WINDOWS_SEH is defined
 
 namespace Catch {
 
@@ -6143,6 +6177,7 @@ namespace Catch {
         static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
             for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
                 if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
+                    reset();
                     reportFatal(signalDefs[i].name);
                 }
             }
@@ -6151,22 +6186,25 @@ namespace Catch {
             return EXCEPTION_CONTINUE_SEARCH;
         }
 
+        FatalConditionHandler() {
+            isSet = true;
             // 32k seems enough for Catch to handle stack overflow,
             // but the value was found experimentally, so there is no strong guarantee
-        FatalConditionHandler():m_isSet(true), m_guaranteeSize(32 * 1024), m_exceptionHandlerHandle(CATCH_NULL) {
+            guaranteeSize = 32 * 1024;
+            exceptionHandlerHandle = CATCH_NULL;
             // Register as first handler in current chain
-            m_exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+            exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
             // Pass in guarantee size to be filled
-            SetThreadStackGuarantee(&m_guaranteeSize);
+            SetThreadStackGuarantee(&guaranteeSize);
         }
 
-        void reset() {
-            if (m_isSet) {
+        static void reset() {
+            if (isSet) {
                 // Unregister handler and restore the old guarantee
-                RemoveVectoredExceptionHandler(m_exceptionHandlerHandle);
-                SetThreadStackGuarantee(&m_guaranteeSize);
-                m_exceptionHandlerHandle = CATCH_NULL;
-                m_isSet = false;
+                RemoveVectoredExceptionHandler(exceptionHandlerHandle);
+                SetThreadStackGuarantee(&guaranteeSize);
+                exceptionHandlerHandle = CATCH_NULL;
+                isSet = false;
             }
         }
 
@@ -6174,13 +6212,19 @@ namespace Catch {
             reset();
         }
     private:
-        bool m_isSet;
-        ULONG m_guaranteeSize;
-        PVOID m_exceptionHandlerHandle;
+        static bool isSet;
+        static ULONG guaranteeSize;
+        static PVOID exceptionHandlerHandle;
     };
 
+    bool FatalConditionHandler::isSet = false;
+    ULONG FatalConditionHandler::guaranteeSize = 0;
+    PVOID FatalConditionHandler::exceptionHandlerHandle = CATCH_NULL;
+
 } // namespace Catch
 
+#  endif // CATCH_CONFIG_WINDOWS_SEH
+
 #else // Not Windows - assumed to be POSIX compatible //////////////////////////
 
 #include <signal.h>
@@ -7440,30 +7484,6 @@ namespace Catch {
 
 #if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
 
-// #included from: catch_windows_h_proxy.h
-
-#define TWOBLUECUBES_CATCH_WINDOWS_H_PROXY_H_INCLUDED
-
-#ifdef CATCH_DEFINES_NOMINMAX
-#  define NOMINMAX
-#endif
-#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-#endif
-
-#ifdef __AFXDLL
-#include <AfxWin.h>
-#else
-#include <windows.h>
-#endif
-
-#ifdef CATCH_DEFINES_NOMINMAX
-#  undef NOMINMAX
-#endif
-#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
-#  undef WIN32_LEAN_AND_MEAN
-#endif
-
 namespace Catch {
 namespace {
 
@@ -7989,7 +8009,7 @@ namespace Catch {
         return os;
     }
 
-    Version libraryVersion( 1, 7, 0, "", 0 );
+    Version libraryVersion( 1, 7, 1, "", 0 );
 
 }
 
@@ -9506,12 +9526,13 @@ namespace Catch {
             newlineIfNecessary();
             m_indent = m_indent.substr( 0, m_indent.size()-2 );
             if( m_tagIsOpen ) {
-                stream() << "/>\n";
+                stream() << "/>";
                 m_tagIsOpen = false;
             }
             else {
-                stream() << m_indent << "</" << m_tags.back() << ">\n";
+                stream() << m_indent << "</" << m_tags.back() << ">";
             }
+            stream() << std::endl;
             m_tags.pop_back();
             return *this;
         }
@@ -9757,6 +9778,11 @@ namespace Catch {
             if ( m_config->showDurations() == ShowDurations::Always )
                 e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
 
+            if( !testCaseStats.stdOut.empty() )
+                m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), false );
+            if( !testCaseStats.stdErr.empty() )
+                m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), false );
+
             m_xml.endElement();
         }
 
@@ -9804,7 +9830,7 @@ namespace Catch {
             std::time(&rawtime);
             const size_t timeStampSize = sizeof("2017-01-16T17:06:45Z");
 
-#ifdef CATCH_PLATFORM_WINDOWS
+#ifdef _MSC_VER
             std::tm timeInfo = {};
             gmtime_s(&timeInfo, &rawtime);
 #else
@@ -9815,7 +9841,7 @@ namespace Catch {
             char timeStamp[timeStampSize];
             const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
 
-#ifdef CATCH_PLATFORM_WINDOWS
+#ifdef _MSC_VER
             std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
 #else
             std::strftime(timeStamp, timeStampSize, fmt, timeInfo);