Fix error: ISO C++ forbids in-class initialization of non-const static member 'm_started'

Backport fix for SIGSTKSZ
Merge pull request #2151 from fxcoudert/patch-1
2025-09-13 00:45:39 +02:00 · 2023-01-18 11:10:26 +01:00 · 2022-07-15 16:13:12 +02:00 · 2021-01-13 18:16:54 +01:00 · 2021-01-11 12:22:22 +01:00 · 2019-09-06 11:45:32 +02:00
35 changed files with 755 additions and 279 deletions
--- a/README.md
+++ b/README.md
@@ -3,9 +3,9 @@
 [![Github Releases](https://img.shields.io/github/release/philsquared/catch.svg)](https://github.com/philsquared/catch/releases)
 [![Build Status](https://travis-ci.org/philsquared/Catch.svg?branch=master)](https://travis-ci.org/philsquared/Catch)
 [![Build status](https://ci.appveyor.com/api/projects/status/hrtk60hv6tw6fght/branch/master?svg=true)](https://ci.appveyor.com/project/philsquared/catch/branch/master)
-[![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/UahInEdRRiojprDp)
+[![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/jG7wnHX9VAcxpSHy)

-<a href="https://github.com/philsquared/Catch/releases/download/v1.10.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.12.2/catch.hpp">The latest, single header, version can be downloaded directly using this link</a>

 ## What's the Catch?

--- a/conanfile.py
+++ b/conanfile.py
@@ -4,7 +4,7 @@ from conans import ConanFile

 class CatchConan(ConanFile):
    name = "Catch"
-    version = "1.10.0"
+    version = "1.12.2"
    description = "A modern, C++-native, header-only, framework for unit-tests, TDD and BDD"
    author = "philsquared"
    generators = "cmake"
@@ -14,3 +14,6 @@ class CatchConan(ConanFile):

    def package(self):
        self.copy(pattern="catch.hpp", src="single_include", dst="include")
+
+    def package_id(self):
+            self.info.header_only()
--- a/contrib/ParseAndAddCatchTests.cmake
+++ b/contrib/ParseAndAddCatchTests.cmake
@@ -36,6 +36,8 @@
 #    -- adds fixture class name to the test name                                                   #
 #    PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME (Default ON)                                        #
 #    -- adds cmake target name to the test name                                                    #
+#    PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS (Default OFF)                                      #
+#    -- causes CMake to rerun when file with tests changes so that new tests will be discovered    #
 #                                                                                                  #
 #==================================================================================================#

@@ -45,6 +47,7 @@ option(PARSE_CATCH_TESTS_VERBOSE "Print Catch to CTest parser debug messages" OF
 option(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS "Exclude tests with [!hide], [.] or [.foo] tags" OFF)
 option(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME "Add fixture class name to the test name" ON)
 option(PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME "Add target name to the test name" ON)
+option(PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS "Add test file to CMAKE_CONFIGURE_DEPENDS property" OFF)

 function(PrintDebugMessage)
    if(PARSE_CATCH_TESTS_VERBOSE)
@@ -85,6 +88,15 @@ function(ParseFile SourceFile TestTarget)
    # Find definition of test names
    string(REGEX MATCHALL "[ \t]*(CATCH_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^\)]+\\)+[ \t\n]*{+[ \t]*(//[^\n]*[Tt][Ii][Mm][Ee][Oo][Uu][Tt][ \t]*[0-9]+)*" Tests "${Contents}")

+    if(PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS AND Tests)
+      PrintDebugMessage("Adding ${SourceFile} to CMAKE_CONFIGURE_DEPENDS property")
+      set_property(
+        DIRECTORY
+        APPEND
+        PROPERTY CMAKE_CONFIGURE_DEPENDS ${SourceFile}
+      )
+    endif()
+
    foreach(TestName ${Tests})
        # Strip newlines
        string(REGEX REPLACE "\\\\\n|\n" "" TestName "${TestName}")
--- a/docs/assertions.md
+++ b/docs/assertions.md
@@ -57,7 +57,7 @@ This way `Approx` is constructed with reasonable defaults, covering most simple

 * __epsilon__ - epsilon serves to set the percentage by which a result can be erroneous, before it is rejected. By default set to `std::numeric_limits<float>::epsilon()*100`.
 * __margin__ - margin serves to set the the absolute value by which a result can be erroneous before it is rejected. By default set to `0.0`.
-* __scale__ - scale serves to adjust the base for comparison used by epsilon, can be used when  By default set to `1.0`.
+* __scale__ - scale serves to adjust the base for comparison used by epsilon. By default set to `1.0`.

 #### epsilon example
 ```cpp
@@ -77,7 +77,7 @@ Approx target = Approx(100).margin(5);
 ```

 #### scale
-Scale can be useful if the computation leading to the result worked on different scale, than is used by the results (and thus expected errors are on a different scale than would be expected based on the results alone).
+Scale can be useful if the computation leading to the result worked on different scale, than is used by the results (and thus expected errors are on a different scale than would be expected based on the results alone), i.e. an additional not scaling difference will be accepted, because | current - target | < eps_rel + eps_abs (while eps_rel = max(current, target) * epsilon, eps_abs = epsilon * scale) will be checked.


 ## Exceptions
@@ -138,4 +138,4 @@ For more details, along with workarounds, see the section on [the limitations pa

 ---

-[Home](Readme.md)
+[Home](Readme.md)
--- a/docs/build-systems.md
+++ b/docs/build-systems.md
@@ -15,7 +15,7 @@ The XML Reporter writes in an XML format that is specific to Catch.

 The advantage of this format is that it corresponds well to the way Catch works (especially the more unusual features, such as nested sections) and is a fully streaming format - that is it writes output as it goes, without having to store up all its results before it can start writing.

-The disadvantage is that, being specific to Catch, no existing build servers understand the format natively. It can be used as input to an XSLT transformation that could covert it to, say, HTML - although this loses the streaming advantage, of course.
+The disadvantage is that, being specific to Catch, no existing build servers understand the format natively. It can be used as input to an XSLT transformation that could convert it to, say, HTML - although this loses the streaming advantage, of course.

 ## JUnit Reporter
 ```-r junit```
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -125,7 +125,8 @@ Defining this flag speeds up compilation of test files by ~20%, by making 2 chan
 `CATCH_CONFIG_FAST_COMPILE` has to be either defined, or not defined, in all translation units that are linked into single test binary, or the behaviour of setting `-b` flag and throwing unexpected exceptions will be unpredictable.

 ## `CATCH_CONFIG_DISABLE_STRINGIFICATION`
-This toggle enables a workaround for VS 2017 bug. For details see [known limitations](limitations.md#Visual Studio 2017 -- raw string literal in assert fails to compile)
+This toggle enables a workaround for VS 2017 bug. For details see
+[known limitations](limitations.md#visual-studio-2017----raw-string-literal-in-assert-fails-to-compile).

 # Windows header clutter

--- a/docs/opensource-users.md
+++ b/docs/opensource-users.md
@@ -1,6 +1,6 @@
 # Open Source projects using Catch

-Catch is great for open source. With it's [liberal license](../LICENSE.txt) and single-header, dependency-free, distribution 
+Catch is great for open source. With its [liberal license](../LICENSE.txt) and single-header, dependency-free, distribution 
 it's easy to just drop the header into your project and start writing tests - what's not to like?

 As a result Catch is now being used in many Open Source projects, including some quite well known ones.
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -1,3 +1,43 @@
+# 1.12.2
+### Fixes
+* Fixed missing <cassert> include
+
+# 1.12.1
+
+### Fixes
+* Fixed deprecation warning in `ScopedMessage::~ScopedMessage`
+* All uses of `min` or `max` identifiers are now wrapped in parentheses
+  * This avoids problems when Windows headers define `min` and `max` macros
+
+
+
+# 1.12.0
+
+### Fixes
+* Fixed compilation for strict C++98 mode (ie not gnu++98) and older compilers (#1103)
+* `INFO` messages are included in the `xml` reporter output even without `-s` specified.
+
+
+
+# 1.11.0
+
+### Fixes
+* The original expression in `REQUIRE_FALSE( expr )` is now reporter properly as `!( expr )` (#1051)
+  * Previously the parentheses were missing and `x != y` would be expanded as `!x != x`
+* `Approx::Margin` is now inclusive (#952)
+  * Previously it was meant and documented as inclusive, but the check itself wasn't
+  * This means that `REQUIRE( 0.25f == Approx( 0.0f ).margin( 0.25f ) )` passes, instead of fails
+* `RandomNumberGenerator::result_type` is now unsigned (#1050)
+
+### Improvements
+* `__JETBRAINS_IDE__` macro handling is now CLion version specific (#1017)
+  * When CLion 2017.3 or newer is detected, `__COUNTER__` is used instead of
+* TeamCity reporter now explicitly flushes output stream after each report (#1057)
+  * On some platforms, output from redirected streams would show up only after the tests finished running
+* `ParseAndAddCatchTests` now can add test files as dependency to CMake configuration
+  * This means you do not have to manually rerun CMake configuration step to detect new tests
+
+
 # 1.10.0

 ### Fixes
--- a/docs/test-cases-and-sections.md
+++ b/docs/test-cases-and-sections.md
@@ -38,19 +38,19 @@ All tag names beginning with non-alphanumeric characters are reserved by Catch.

 * `[!throws]`	- lets Catch know that this test is likely to throw an exception even if successful. This causes the test to be excluded when running with `-e` or `--nothrow`.

-* `[!mayfail]` - doesn't fail the test if any given assertion fails (but still reports it). This can be useful to flag a work-in-progress, or a known issue that you don't want to immediately fix but still want to track in the your tests.
+* `[!mayfail]` - doesn't fail the test if any given assertion fails (but still reports it). This can be useful to flag a work-in-progress, or a known issue that you don't want to immediately fix but still want to track in your tests.

 * `[!shouldfail]` - like `[!mayfail]` but *fails* the test if it *passes*. This can be useful if you want to be notified of accidental, or third-party, fixes.

 * `[!nonportable]` - Indicates that behaviour may vary between platforms or compilers.

-* `[#<filename>]` - running with `-#` or `--filenames-as-tags` causes Catch to add the filename, prefixed with `#` (and with any extension stripped) as a tag. e.g. tests in testfile.cpp would all be tagged `[#testfile]`.
+* `[#<filename>]` - running with `-#` or `--filenames-as-tags` causes Catch to add the filename, prefixed with `#` (and with any extension stripped), as a tag to all contained tests, e.g. tests in testfile.cpp would all be tagged `[#testfile]`.

 * `[@<alias>]` - tag aliases all begin with `@` (see below).

 ## Tag aliases

-Between tag expressions and wildcarded test names (as well as combinations of the two) quite complex patterns can be constructed to direct which test cases are run. If a complex pattern is used often it is convenient to be able to create an alias for the expression. this can be done, in code, using the following form:
+Between tag expressions and wildcarded test names (as well as combinations of the two) quite complex patterns can be constructed to direct which test cases are run. If a complex pattern is used often it is convenient to be able to create an alias for the expression. This can be done, in code, using the following form:

 	CATCH_REGISTER_TAG_ALIAS( <alias string>, <tag expression> )

--- a/docs/tutorial.md
+++ b/docs/tutorial.md
@@ -1,6 +1,6 @@
 # Getting Catch

-The simplest way to get Catch is to download the latest [single header version](https://raw.githubusercontent.com/philsquared/Catch/master/single_include/catch.hpp). The single header is generated by merging a set of individual headers but it is still just normal source code in a header file.
+The simplest way to get Catch is to download the latest [single header version](https://github.com/philsquared/Catch/releases/download/v1.12.2/catch.hpp). The single header is generated by merging a set of individual headers but it is still just normal source code in a header file.

 The full source for Catch, including test projects, documentation, and other things, is hosted on GitHub. [http://catch-lib.net](http://catch-lib.net) will redirect you there.

--- a/include/internal/catch_approx.hpp
+++ b/include/internal/catch_approx.hpp
@@ -57,7 +57,8 @@ namespace Detail {
            if (relativeOK) {
                return true;
            }
-            return std::fabs(lhs_v - rhs.m_value) < rhs.m_margin;
+
+            return std::fabs(lhs_v - rhs.m_value) <= rhs.m_margin;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
@@ -130,7 +131,7 @@ namespace Detail {
            if (relativeOK) {
                return true;
            }
-            return std::fabs(lhs - rhs.m_value) < rhs.m_margin;
+            return std::fabs(lhs - rhs.m_value) <= rhs.m_margin;
        }

        friend bool operator == ( Approx const& lhs, double rhs ) {
--- a/include/internal/catch_assertionresult.hpp
+++ b/include/internal/catch_assertionresult.hpp
@@ -66,7 +66,7 @@ namespace Catch {

    std::string AssertionResult::getExpression() const {
        if( isFalseTest( m_info.resultDisposition ) )
-            return '!' + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
+            return "!(" + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + ")";
        else
            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
    }
--- a/include/internal/catch_commandline.hpp
+++ b/include/internal/catch_commandline.hpp
@@ -224,10 +224,6 @@ namespace Catch {
            .describe( "should output be colourised" )
            .bind( &setUseColour, "yes|no" );

-        cli["--use-colour"]
-            .describe( "should output be colourised" )
-            .bind( &setUseColour, "yes|no" );
-
        cli["--libidentify"]
            .describe( "report name and version according to libidentify standard" )
            .bind( &ConfigData::libIdentify );
--- a/include/internal/catch_compiler_capabilities.h
+++ b/include/internal/catch_compiler_capabilities.h
@@ -163,7 +163,7 @@
 ////////////////////////////////////////////////////////////////////////////////

 // Use variadic macros if the compiler supports them
-#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
+#if ( defined _MSC_VER && _MSC_VER >= 1400 && !defined __EDGE__) || \
    ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
    ( defined __GNUC__ && __GNUC__ >= 3 ) || \
    ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
@@ -177,7 +177,12 @@
    ( defined __GNUC__  && ( __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \
    ( defined __clang__ && __clang_major__ >= 3 )

-#define CATCH_INTERNAL_CONFIG_COUNTER
+// Use of __COUNTER__ is suppressed during code analysis in CLion/AppCode 2017.2.x and former,
+// because __COUNTER__ is not properly handled by it.
+// This does not affect compilation
+#if ( !defined __JETBRAINS_IDE__ || __JETBRAINS_IDE__ >= 20170300L )
+    #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif

 #endif

@@ -258,10 +263,7 @@
 #if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11)
 #   define CATCH_CONFIG_CPP11_UNIQUE_PTR
 #endif
-// Use of __COUNTER__ is suppressed if __JETBRAINS_IDE__ is #defined (meaning we're being parsed by a JetBrains IDE for
-// analytics) because, at time of writing, __COUNTER__ is not properly handled by it.
-// This does not affect compilation
-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) && !defined(__JETBRAINS_IDE__)
+#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
 #   define CATCH_CONFIG_COUNTER
 #endif
 #if defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_NO_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_NO_CPP11)
--- a/include/internal/catch_debugger.h
+++ b/include/internal/catch_debugger.h
@@ -27,6 +27,9 @@ namespace Catch{
        #define CATCH_TRAP() \
                __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
                : : : "memory","r0","r3","r4" ) /* NOLINT */
+    #elif defined(__aarch64__)
+        // Backport of https://github.com/catchorg/Catch2/commit/a25c1a24af8bffd35727a888a307ff0280cf9387
+        #define CATCH_TRAP() __asm__(".inst 0xd4200000")
    #else
        #define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ )
    #endif
--- a/include/internal/catch_evaluate.hpp
+++ b/include/internal/catch_evaluate.hpp
@@ -38,10 +38,12 @@ namespace Internal {
    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };

    template<typename T>
-    T& removeConst(T const &t) { return const_cast<T&>(t); }
+    T& opCast(T const& t) { return const_cast<T&>(t); }
+
+// nullptr_t support based on pull request #154 from Konstantin Baumann
 #ifdef CATCH_CONFIG_CPP11_NULLPTR
-    inline std::nullptr_t removeConst(std::nullptr_t) { return nullptr; }
-#endif
+    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
+#endif // CATCH_CONFIG_CPP11_NULLPTR


    // So the compare overloads can be operator agnostic we convey the operator as a template
@@ -52,90 +54,161 @@ namespace Internal {
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsEqualTo> {
        static bool evaluate( T1 const& lhs, T2 const& rhs) {
-            return bool(removeConst(lhs) == removeConst(rhs) );
+            return bool( opCast( lhs ) ==  opCast( rhs ) );
        }
    };
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsNotEqualTo> {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool(removeConst(lhs) != removeConst(rhs) );
+            return bool( opCast( lhs ) != opCast( rhs ) );
        }
    };
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsLessThan> {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool(removeConst(lhs) < removeConst(rhs) );
+            return bool( opCast( lhs ) < opCast( rhs ) );
        }
    };
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsGreaterThan> {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool(removeConst(lhs) > removeConst(rhs) );
+            return bool( opCast( lhs ) > opCast( rhs ) );
        }
    };
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool(removeConst(lhs) >= removeConst(rhs) );
+            return bool( opCast( lhs ) >= opCast( rhs ) );
        }
    };
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool(removeConst(lhs) <= removeConst(rhs) );
+            return bool( opCast( lhs ) <= opCast( rhs ) );
        }
    };

-    // Special case for comparing a pointer to an int (deduced for p==0)
-    template<typename T>
-    struct Evaluator<int const&, T* const&, IsEqualTo> {
-        static bool evaluate( int lhs, T* rhs) {
-            return reinterpret_cast<void const*>( lhs ) ==  rhs;
-        }
-    };
-    template<typename T>
-    struct Evaluator<T* const&, int const&, IsEqualTo> {
-        static bool evaluate( T* lhs, int rhs) {
-            return lhs == reinterpret_cast<void const*>( rhs );
-        }
-    };
-    template<typename T>
-    struct Evaluator<int const&, T* const&, IsNotEqualTo> {
-        static bool evaluate( int lhs, T* rhs) {
-            return reinterpret_cast<void const*>( lhs ) !=  rhs;
-        }
-    };
-    template<typename T>
-    struct Evaluator<T* const&, int const&, IsNotEqualTo> {
-        static bool evaluate( T* lhs, int rhs) {
-            return lhs != reinterpret_cast<void const*>( rhs );
-        }
-    };
+    template<Operator Op, typename T1, typename T2>
+    bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }

-    template<typename T>
-    struct Evaluator<long const&, T* const&, IsEqualTo> {
-        static bool evaluate( long lhs, T* rhs) {
-            return reinterpret_cast<void const*>( lhs ) ==  rhs;
-        }
-    };
-    template<typename T>
-    struct Evaluator<T* const&, long const&, IsEqualTo> {
-        static bool evaluate( T* lhs, long rhs) {
-            return lhs == reinterpret_cast<void const*>( rhs );
-        }
-    };
-    template<typename T>
-    struct Evaluator<long const&, T* const&, IsNotEqualTo> {
-        static bool evaluate( long lhs, T* rhs) {
-            return reinterpret_cast<void const*>( lhs ) !=  rhs;
-        }
-    };
-    template<typename T>
-    struct Evaluator<T* const&, long const&, IsNotEqualTo> {
-        static bool evaluate( T* lhs, long rhs) {
-            return lhs != reinterpret_cast<void const*>( rhs );
-        }
-    };
+    // This level of indirection allows us to specialise for integer types
+    // to avoid signed/ unsigned warnings
+
+    // "base" overload
+    template<Operator Op, typename T1, typename T2>
+    bool compare( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }
+
+    // unsigned X to int
+    template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+
+    // unsigned X to long
+    template<Operator Op> bool compare( unsigned int lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+
+    // int to unsigned X
+    template<Operator Op> bool compare( int lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+
+    // long to unsigned X
+    template<Operator Op> bool compare( long lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+
+    // pointer to long (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+    // pointer to int (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+    // long long to unsigned X
+    template<Operator Op> bool compare( long long lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned long long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+
+    // unsigned long long to X
+    template<Operator Op> bool compare( unsigned long long lhs, int rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, long rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, long long rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, char rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+
+    // pointer to long long (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( long long lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, long long rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+#endif // CATCH_CONFIG_CPP11_LONG_LONG
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+    // pointer to nullptr_t (when comparing against nullptr)
+    template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( nullptr, rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, nullptr );
+    }
+#endif // CATCH_CONFIG_CPP11_NULLPTR

 } // end of namespace Internal
 } // end of namespace Catch
--- a/include/internal/catch_expression_lhs.hpp
+++ b/include/internal/catch_expression_lhs.hpp
@@ -111,7 +111,7 @@ public:

    void endExpression() const {
        m_rb
-            .setResultType(  Internal::Evaluator<LhsT, RhsT, Op>::evaluate( m_lhs, m_rhs ) )
+            .setResultType( Internal::compare<Op>( m_lhs, m_rhs ) )
            .endExpression( *this );
    }

--- a/include/internal/catch_fatal_condition.hpp
+++ b/include/internal/catch_fatal_condition.hpp
@@ -9,10 +9,12 @@
 #ifndef TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
 #define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED

+#include <cassert>
+#include <stdexcept>

 namespace Catch {

-    // Report the error condition
+    //! Signals fatal error message to the run context
    inline void reportFatal( std::string const& message ) {
        IContext& context = Catch::getCurrentContext();
        IResultCapture* resultCapture = context.getResultCapture();
@@ -27,8 +29,31 @@ namespace Catch {
 #  if !defined ( CATCH_CONFIG_WINDOWS_SEH )

 namespace Catch {
-    struct FatalConditionHandler {
-        void reset() {}
+    class FatalConditionHandler {
+        bool m_started;
+
+        // Install/disengage implementation for specific platform.
+        // Should be if-defed to work on current platform, can assume
+        // engage-disengage 1:1 pairing.
+        void engage_platform() {}
+        void disengage_platform() {}
+
+    public:
+        // Should also have platform-specific implementations as needed
+        FatalConditionHandler() : m_started(false) {}
+        ~FatalConditionHandler() {}
+
+        void engage() {
+            assert(!m_started && "Handler cannot be installed twice.");
+            m_started = true;
+            engage_platform();
+        }
+
+        void disengage() {
+            assert(m_started && "Handler cannot be uninstalled without being installed first");
+            m_started = false;
+            disengage_platform();
+        }
    };
 }

@@ -48,53 +73,72 @@ namespace Catch {
        { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
    };

-    struct FatalConditionHandler {
-
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-            for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
-                if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
-                    reportFatal(signalDefs[i].name);
-                }
+    static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
+        for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+            if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
+                reportFatal(signalDefs[i].name);
            }
-            // If its not an exception we care about, pass it along.
-            // This stops us from eating debugger breaks etc.
-            return EXCEPTION_CONTINUE_SEARCH;
        }
+        // If its not an exception we care about, pass it along.
+        // This stops us from eating debugger breaks etc.
+        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
-            guaranteeSize = 32 * 1024;
-            exceptionHandlerHandle = CATCH_NULL;
+    // Since we do not support multiple instantiations, we put these
+    // into global variables and rely on cleaning them up in outlined
+    // constructors/destructors
+    static PVOID exceptionHandlerHandle = CATCH_NULL;
+
+    class FatalConditionHandler {
+        bool m_started;
+
+        // Install/disengage implementation for specific platform.
+        // Should be if-defed to work on current platform, can assume
+        // engage-disengage 1:1 pairing.
+
+        void engage_platform() {
            // Register as first handler in current chain
            exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
-            // Pass in guarantee size to be filled
-            SetThreadStackGuarantee(&guaranteeSize);
-        }
-
-        static void reset() {
-            if (isSet) {
-                // Unregister handler and restore the old guarantee
-                RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-                SetThreadStackGuarantee(&guaranteeSize);
-                exceptionHandlerHandle = CATCH_NULL;
-                isSet = false;
+            if (!exceptionHandlerHandle) {
+                throw std::runtime_error("Could not register vectored exception handler");
            }
        }

-        ~FatalConditionHandler() {
-            reset();
+        void disengage_platform() {
+            if (!RemoveVectoredExceptionHandler(exceptionHandlerHandle)) {
+                throw std::runtime_error("Could not unregister vectored exception handler");
+            }
+            exceptionHandlerHandle = CATCH_NULL;
        }
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };

-    bool FatalConditionHandler::isSet = false;
-    ULONG FatalConditionHandler::guaranteeSize = 0;
-    PVOID FatalConditionHandler::exceptionHandlerHandle = CATCH_NULL;
+    public:
+        FatalConditionHandler() : m_started(false) {
+            ULONG guaranteeSize = static_cast<ULONG>(32 * 1024);
+            if (!SetThreadStackGuarantee(&guaranteeSize)) {
+                // We do not want to fully error out, because needing
+                // the stack reserve should be rare enough anyway.
+                Catch::cerr()
+                    << "Failed to reserve piece of stack."
+                    << " Stack overflows will not be reported successfully.";
+            }
+        }
+
+        // We do not attempt to unset the stack guarantee, because
+        // Windows does not support lowering the stack size guarantee.
+        ~FatalConditionHandler() {}
+
+        void engage() {
+            assert(!m_started && "Handler cannot be installed twice.");
+            m_started = true;
+            engage_platform();
+        }
+
+        void disengage() {
+            assert(m_started && "Handler cannot be uninstalled without being installed first");
+            m_started = false;
+            disengage_platform();
+        }
+    };

 } // namespace Catch

@@ -105,8 +149,31 @@ namespace Catch {
 #  if !defined(CATCH_CONFIG_POSIX_SIGNALS)

 namespace Catch {
-    struct FatalConditionHandler {
-        void reset() {}
+    class FatalConditionHandler {
+        bool m_started;
+
+        // Install/disengage implementation for specific platform.
+        // Should be if-defed to work on current platform, can assume
+        // engage-disengage 1:1 pairing.
+        void engage_platform() {}
+        void disengage_platform() {}
+
+    public:
+        // Should also have platform-specific implementations as needed
+        FatalConditionHandler() : m_started(false) {}
+        ~FatalConditionHandler() {}
+
+        void engage() {
+            assert(!m_started && "Handler cannot be installed twice.");
+            m_started = true;
+            engage_platform();
+        }
+
+        void disengage() {
+            assert(m_started && "Handler cannot be uninstalled without being installed first");
+            m_started = false;
+            disengage_platform();
+        }
    };
 }

@@ -131,29 +198,56 @@ namespace Catch {
            { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
    };

-    struct FatalConditionHandler {
+// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
+// which is zero initialization, but not explicit. We want to avoid
+// that.
+#if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif

-        static bool isSet;
-        static struct sigaction oldSigActions [sizeof(signalDefs)/sizeof(SignalDefs)];
-        static stack_t oldSigStack;
-        static char altStackMem[SIGSTKSZ];
+    static char* altStackMem = CATCH_NULL;
+    static std::size_t altStackSize = 0;
+    static stack_t oldSigStack;
+    static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)];

-        static void handleSignal( int sig ) {
-            std::string name = "<unknown signal>";
-            for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
-                SignalDefs &def = signalDefs[i];
-                if (sig == def.id) {
-                    name = def.name;
-                    break;
-                }
-            }
-            reset();
-            reportFatal(name);
-            raise( sig );
+    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], CATCH_NULL);
        }
+        // Return the old stack
+        sigaltstack(&oldSigStack, CATCH_NULL);
+    }

-        FatalConditionHandler() {
-            isSet = true;
+    static void handleSignal( int sig ) {
+        char const * name = "<unknown signal>";
+        for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+            SignalDefs &def = signalDefs[i];
+            if (sig == def.id) {
+                name = def.name;
+                break;
+            }
+        }
+        // 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 );
+    }
+
+    class FatalConditionHandler {
+        bool m_started;
+
+        // Install/disengage implementation for specific platform.
+        // Should be if-defed to work on current platform, can assume
+        // engage-disengage 1:1 pairing.
+
+        void engage_platform() {
            stack_t sigStack;
            sigStack.ss_sp = altStackMem;
            sigStack.ss_size = SIGSTKSZ;
@@ -168,28 +262,42 @@ namespace Catch {
            }
        }

+        void disengage_platform() {
+            restorePreviousSignalHandlers();
+        }
+
+    public:
+        FatalConditionHandler() : m_started(false) {
+            assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
+            if (altStackSize == 0) {
+                altStackSize = SIGSTKSZ;
+            }
+            altStackMem = new char[altStackSize]();
+        }

        ~FatalConditionHandler() {
-            reset();
+            delete[] altStackMem;
+            // We signal that another instance can be constructed by zeroing
+            // out the pointer.
+            altStackMem = CATCH_NULL;
        }
-        static void reset() {
-            if( isSet ) {
-                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
-                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
-                    sigaction(signalDefs[i].id, &oldSigActions[i], CATCH_NULL);
-                }
-                // Return the old stack
-                sigaltstack(&oldSigStack, CATCH_NULL);
-                isSet = false;
-            }
+
+        void engage() {
+            assert(!m_started && "Handler cannot be installed twice.");
+            m_started = true;
+            engage_platform();
+        }
+
+        void disengage() {
+            assert(m_started && "Handler cannot be uninstalled without being installed first");
+            m_started = false;
+            disengage_platform();
        }
    };

-    bool FatalConditionHandler::isSet = false;
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
-    stack_t FatalConditionHandler::oldSigStack = {};
-    char FatalConditionHandler::altStackMem[SIGSTKSZ] = {};
-
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif

 } // namespace Catch

@@ -197,4 +305,21 @@ namespace Catch {

 #endif // not Windows

+namespace Catch {
+
+    //! Simple RAII guard for (dis)engaging the FatalConditionHandler
+    class FatalConditionHandlerGuard {
+        FatalConditionHandler* m_handler;
+    public:
+        FatalConditionHandlerGuard(FatalConditionHandler* handler):
+            m_handler(handler) {
+            m_handler->engage();
+        }
+        ~FatalConditionHandlerGuard() {
+            m_handler->disengage();
+        }
+    };
+
+} // end namespace Catch
+
 #endif // TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
--- a/include/internal/catch_message.hpp
+++ b/include/internal/catch_message.hpp
@@ -37,11 +37,18 @@ namespace Catch {
    : m_info( other.m_info )
    {}

+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17
+#endif
    ScopedMessage::~ScopedMessage() {
        if ( !std::uncaught_exception() ){
            getResultCapture().popScopedMessage(m_info);
        }
    }
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif


 } // end namespace Catch
--- a/include/internal/catch_result_builder.hpp
+++ b/include/internal/catch_result_builder.hpp
@@ -16,6 +16,8 @@
 #include "catch_interfaces_registry_hub.h"
 #include "catch_wildcard_pattern.hpp"

+#include <cassert>
+
 namespace Catch {

    ResultBuilder::ResultBuilder(   char const* macroName,
--- a/include/internal/catch_run_context.hpp
+++ b/include/internal/catch_run_context.hpp
@@ -22,7 +22,7 @@
 #include "catch_result_builder.h"
 #include "catch_fatal_condition.hpp"

-
+#include <cassert>
 #include <set>
 #include <string>

@@ -363,9 +363,8 @@ namespace Catch {
        }

        void invokeActiveTestCase() {
-            FatalConditionHandler fatalConditionHandler; // Handle signals
+            FatalConditionHandlerGuard _(&m_fatalConditionhandler);
            m_activeTestCase->invoke();
-            fatalConditionHandler.reset();
        }

    private:
@@ -403,6 +402,7 @@ namespace Catch {
        std::vector<SectionEndInfo> m_unfinishedSections;
        std::vector<ITracker*> m_activeSections;
        TrackerContext m_trackerContext;
+        FatalConditionHandler m_fatalConditionhandler;
        size_t m_prevPassed;
        bool m_shouldReportUnexpected;
    };
--- a/include/internal/catch_test_case_registry_impl.hpp
+++ b/include/internal/catch_test_case_registry_impl.hpp
@@ -22,14 +22,14 @@
 namespace Catch {

    struct RandomNumberGenerator {
-        typedef std::ptrdiff_t result_type;
+        typedef unsigned int result_type;

        result_type operator()( result_type n ) const { return std::rand() % n; }

 #ifdef CATCH_CONFIG_CPP11_SHUFFLE
-        static constexpr result_type min() { return 0; }
-        static constexpr result_type max() { return 1000000; }
-        result_type operator()() const { return std::rand() % max(); }
+        static constexpr result_type (min)() { return 0; }
+        static constexpr result_type (max)() { return 1000000; }
+        result_type operator()() const { return std::rand() % (max)(); }
 #endif
        template<typename V>
        static void shuffle( V& vector ) {
--- a/include/internal/catch_version.hpp
+++ b/include/internal/catch_version.hpp
@@ -38,7 +38,7 @@ namespace Catch {
    }

    inline Version libraryVersion() {
-        static Version version( 1, 10, 0, "", 0 );
+        static Version version( 1, 12, 2, "", 0 );
        return version;
    }

--- a/include/reporters/catch_reporter_console.hpp
+++ b/include/reporters/catch_reporter_console.hpp
@@ -13,6 +13,7 @@
 #include "../internal/catch_reporter_registrars.hpp"
 #include "../internal/catch_console_colour.hpp"

+#include <cassert>
 #include <cfloat>
 #include <cstdio>

--- a/include/reporters/catch_reporter_teamcity.hpp
+++ b/include/reporters/catch_reporter_teamcity.hpp
@@ -14,6 +14,7 @@
 // file can be distributed as a single header that works with the main
 // Catch single header.

+#include <cassert>
 #include <cstring>

 #ifdef __clang__
@@ -141,6 +142,7 @@ namespace Catch {
                           << "]\n";
                }
            }
+            stream.flush();
            return true;
        }

@@ -154,6 +156,7 @@ namespace Catch {
            StreamingReporterBase::testCaseStarting( testInfo );
            stream << "##teamcity[testStarted name='"
                << escape( testInfo.name ) << "']\n";
+            stream.flush();
        }

        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
@@ -169,6 +172,7 @@ namespace Catch {
            stream << "##teamcity[testFinished name='"
                    << escape( testCaseStats.testInfo.name ) << "' duration='"
                    << m_testTimer.getElapsedMilliseconds() << "']\n";
+            stream.flush();
        }

    private:
--- a/include/reporters/catch_reporter_xml.hpp
+++ b/include/reporters/catch_reporter_xml.hpp
@@ -97,12 +97,12 @@ namespace Catch {

            bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();

-            if( includeResults ) {
+            if( includeResults || result.getResultType() == ResultWas::Warning ) {
                // Print any info messages in <Info> tags.
                for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
                     it != itEnd;
                     ++it ) {
-                    if( it->type == ResultWas::Info ) {
+                    if( it->type == ResultWas::Info && includeResults ) {
                        m_xml.scopedElement( "Info" )
                                .writeText( it->message );
                    } else if ( it->type == ResultWas::Warning ) {
--- a/projects/SelfTest/ApproxTests.cpp
+++ b/projects/SelfTest/ApproxTests.cpp
@@ -24,6 +24,8 @@ TEST_CASE
    REQUIRE( Approx( d ) == 1.23 );
    REQUIRE( Approx( d ) != 1.22 );
    REQUIRE( Approx( d ) != 1.24 );
+
+    REQUIRE( 0 == Approx(0) );
 }

 ///////////////////////////////////////////////////////////////////////////////
@@ -146,11 +148,22 @@ TEST_CASE( "Approximate PI", "[Approx][PI]" )
 TEST_CASE( "Absolute margin", "[Approx]" ) {
    REQUIRE( 104.0 != Approx(100.0) );
    REQUIRE( 104.0 == Approx(100.0).margin(5) );
+    REQUIRE( 104.0 == Approx(100.0).margin(4) );
    REQUIRE( 104.0 != Approx(100.0).margin(3) );
    REQUIRE( 100.3 != Approx(100.0) );
    REQUIRE( 100.3 == Approx(100.0).margin(0.5) );
 }

+TEST_CASE("Approx with exactly-representable margin", "[Approx]") {
+    CHECK( 0.25f == Approx(0.0f).margin(0.25f) );
+
+    CHECK( 0.0f == Approx(0.25f).margin(0.25f) );
+    CHECK( 0.5f == Approx(0.25f).margin(0.25f) );
+
+    CHECK( 245.0f == Approx(245.25f).margin(0.25f) );
+    CHECK( 245.5f == Approx(245.25f).margin(0.25f) );
+}
+
 ////////////////////////////////////////////////////////////////////////////////

 #if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
--- a/projects/SelfTest/Baselines/console.std.approved.txt
+++ b/projects/SelfTest/Baselines/console.std.approved.txt
@@ -58,6 +58,8 @@ with expansion:

 ConditionTests.cpp:<line number>: FAILED:
  CHECK_FALSE( true )
+with expansion:
+  !true

 ConditionTests.cpp:<line number>: FAILED:
  CHECK( !trueValue )
@@ -76,8 +78,6 @@ with expansion:

 ConditionTests.cpp:<line number>: FAILED:
  CHECK_FALSE( 1 == 1 )
-with expansion:
-  !(1 == 1)

 -------------------------------------------------------------------------------
 A METHOD_AS_TEST_CASE based test run that fails
@@ -956,6 +956,6 @@ with expansion:
  "first" == "second"

 ===============================================================================
-test cases: 170 | 121 passed | 45 failed |  4 failed as expected
-assertions: 973 | 864 passed | 88 failed | 21 failed as expected
+test cases: 171 | 122 passed | 45 failed |  4 failed as expected
+assertions: 980 | 871 passed | 88 failed | 21 failed as expected

--- a/projects/SelfTest/Baselines/console.sw.approved.txt
+++ b/projects/SelfTest/Baselines/console.sw.approved.txt
@@ -202,6 +202,8 @@ with expansion:

 ConditionTests.cpp:<line number>: FAILED:
  CHECK_FALSE( true )
+with expansion:
+  !true

 ConditionTests.cpp:<line number>: FAILED:
  CHECK( !trueValue )
@@ -220,8 +222,6 @@ with expansion:

 ConditionTests.cpp:<line number>: FAILED:
  CHECK_FALSE( 1 == 1 )
-with expansion:
-  !(1 == 1)

 -------------------------------------------------------------------------------
 'Not' checks that should succeed
@@ -246,6 +246,8 @@ with expansion:
 ConditionTests.cpp:<line number>:
 PASSED:
  REQUIRE_FALSE( false )
+with expansion:
+  !false

 ConditionTests.cpp:<line number>:
 PASSED:
@@ -268,8 +270,6 @@ with expansion:
 ConditionTests.cpp:<line number>:
 PASSED:
  REQUIRE_FALSE( 1 == 2 )
-with expansion:
-  !(1 == 2)

 -------------------------------------------------------------------------------
 (unimplemented) static bools can be evaluated
@@ -457,6 +457,12 @@ PASSED:
 with expansion:
  104.0 == Approx( 100.0 )

+ApproxTests.cpp:<line number>:
+PASSED:
+  REQUIRE( 104.0 == Approx(100.0).margin(4) )
+with expansion:
+  104.0 == Approx( 100.0 )
+
 ApproxTests.cpp:<line number>:
 PASSED:
  REQUIRE( 104.0 != Approx(100.0).margin(3) )
@@ -552,6 +558,42 @@ with expansion:
  "this string contains 'abc' as a substring" ( contains: "not there" or
  contains: "string" )

+-------------------------------------------------------------------------------
+Approx with exactly-representable margin
+-------------------------------------------------------------------------------
+ApproxTests.cpp:<line number>
+...............................................................................
+
+ApproxTests.cpp:<line number>:
+PASSED:
+  CHECK( 0.25f == Approx(0.0f).margin(0.25f) )
+with expansion:
+  0.25f == Approx( 0.0 )
+
+ApproxTests.cpp:<line number>:
+PASSED:
+  CHECK( 0.0f == Approx(0.25f).margin(0.25f) )
+with expansion:
+  0.0f == Approx( 0.25 )
+
+ApproxTests.cpp:<line number>:
+PASSED:
+  CHECK( 0.5f == Approx(0.25f).margin(0.25f) )
+with expansion:
+  0.5f == Approx( 0.25 )
+
+ApproxTests.cpp:<line number>:
+PASSED:
+  CHECK( 245.0f == Approx(245.25f).margin(0.25f) )
+with expansion:
+  245.0f == Approx( 245.25 )
+
+ApproxTests.cpp:<line number>:
+PASSED:
+  CHECK( 245.5f == Approx(245.25f).margin(0.25f) )
+with expansion:
+  245.5f == Approx( 245.25 )
+
 -------------------------------------------------------------------------------
 Approximate PI
 -------------------------------------------------------------------------------
@@ -6846,6 +6888,12 @@ PASSED:
 with expansion:
  Approx( 1.23 ) != 1.24

+ApproxTests.cpp:<line number>:
+PASSED:
+  REQUIRE( 0 == Approx(0) )
+with expansion:
+  0 == Approx( 0.0 )
+
 Write to std::cerr
 -------------------------------------------------------------------------------
 Standard error is reported and redirected
@@ -9576,6 +9624,6 @@ MiscTests.cpp:<line number>:
 PASSED:

 ===============================================================================
-test cases: 170 | 119 passed | 47 failed |  4 failed as expected
-assertions: 978 | 864 passed | 93 failed | 21 failed as expected
+test cases: 171 | 120 passed | 47 failed |  4 failed as expected
+assertions: 985 | 871 passed | 93 failed | 21 failed as expected

--- a/projects/SelfTest/Baselines/console.swa4.approved.txt
+++ b/projects/SelfTest/Baselines/console.swa4.approved.txt
@@ -202,6 +202,8 @@ with expansion:

 ConditionTests.cpp:<line number>: FAILED:
  CHECK_FALSE( true )
+with expansion:
+  !true

 ===============================================================================
 test cases:  7 |  4 passed | 1 failed | 2 failed as expected
--- a/projects/SelfTest/Baselines/junit.sw.approved.txt
+++ b/projects/SelfTest/Baselines/junit.sw.approved.txt
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuitesspanner>
-  <testsuite name="<exe-name>" errors="13" failures="81" tests="979" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+  <testsuite name="<exe-name>" errors="13" failures="81" tests="986" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
    <testcase classname="global" name="# A test name that starts with a #" time="{duration}"/>
    <testcase classname="#748 - captures with unexpected exceptions" name="outside assertions" time="{duration}">
      <error type="TEST_CASE">
@@ -99,6 +99,7 @@ ExceptionTests.cpp:<line number>
    </testcase>
    <testcase classname="global" name="Anonymous test case 1" time="{duration}"/>
    <testcase classname="global" name="AnyOf matcher" time="{duration}"/>
+    <testcase classname="global" name="Approx with exactly-representable margin" time="{duration}"/>
    <testcase classname="global" name="Approximate PI" time="{duration}"/>
    <testcase classname="global" name="Approximate comparisons with different epsilons" time="{duration}"/>
    <testcase classname="global" name="Approximate comparisons with floats" time="{duration}"/>
--- a/projects/SelfTest/Baselines/xml.sw.approved.txt
+++ b/projects/SelfTest/Baselines/xml.sw.approved.txt
@@ -181,7 +181,7 @@
      </Expression>
      <Expression success="false" type="CHECK_FALSE" filename="projects/<exe-name>/ConditionTests.cpp" >
        <Original>
-          !true
+          !(true)
        </Original>
        <Expanded>
          !true
@@ -197,7 +197,7 @@
      </Expression>
      <Expression success="false" type="CHECK_FALSE" filename="projects/<exe-name>/ConditionTests.cpp" >
        <Original>
-          !trueValue
+          !(trueValue)
        </Original>
        <Expanded>
          !true
@@ -213,7 +213,7 @@
      </Expression>
      <Expression success="false" type="CHECK_FALSE" filename="projects/<exe-name>/ConditionTests.cpp" >
        <Original>
-          !1 == 1
+          !(1 == 1)
        </Original>
        <Expanded>
          !(1 == 1)
@@ -248,7 +248,7 @@
      </Expression>
      <Expression success="true" type="REQUIRE_FALSE" filename="projects/<exe-name>/ConditionTests.cpp" >
        <Original>
-          !false
+          !(false)
        </Original>
        <Expanded>
          !false
@@ -264,7 +264,7 @@
      </Expression>
      <Expression success="true" type="REQUIRE_FALSE" filename="projects/<exe-name>/ConditionTests.cpp" >
        <Original>
-          !falseValue
+          !(falseValue)
        </Original>
        <Expanded>
          !false
@@ -280,7 +280,7 @@
      </Expression>
      <Expression success="true" type="REQUIRE_FALSE" filename="projects/<exe-name>/ConditionTests.cpp" >
        <Original>
-          !1 == 2
+          !(1 == 2)
        </Original>
        <Expanded>
          !(1 == 2)
@@ -360,7 +360,7 @@
        </Expression>
        <Expression success="true" type="REQUIRE_FALSE" filename="projects/<exe-name>/TrickyTests.cpp" >
          <Original>
-            !is_true&lt;false>::value
+            !(is_true&lt;false>::value)
          </Original>
          <Expanded>
            !false
@@ -462,6 +462,14 @@
          104.0 == Approx( 100.0 )
        </Expanded>
      </Expression>
+      <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/ApproxTests.cpp" >
+        <Original>
+          104.0 == Approx(100.0).margin(4)
+        </Original>
+        <Expanded>
+          104.0 == Approx( 100.0 )
+        </Expanded>
+      </Expression>
      <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/ApproxTests.cpp" >
        <Original>
          104.0 != Approx(100.0).margin(3)
@@ -565,6 +573,49 @@
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
+    <TestCase name="Approx with exactly-representable margin" tags="[Approx]" filename="projects/<exe-name>/ApproxTests.cpp" >
+      <Expression success="true" type="CHECK" filename="projects/<exe-name>/ApproxTests.cpp" >
+        <Original>
+          0.25f == Approx(0.0f).margin(0.25f)
+        </Original>
+        <Expanded>
+          0.25f == Approx( 0.0 )
+        </Expanded>
+      </Expression>
+      <Expression success="true" type="CHECK" filename="projects/<exe-name>/ApproxTests.cpp" >
+        <Original>
+          0.0f == Approx(0.25f).margin(0.25f)
+        </Original>
+        <Expanded>
+          0.0f == Approx( 0.25 )
+        </Expanded>
+      </Expression>
+      <Expression success="true" type="CHECK" filename="projects/<exe-name>/ApproxTests.cpp" >
+        <Original>
+          0.5f == Approx(0.25f).margin(0.25f)
+        </Original>
+        <Expanded>
+          0.5f == Approx( 0.25 )
+        </Expanded>
+      </Expression>
+      <Expression success="true" type="CHECK" filename="projects/<exe-name>/ApproxTests.cpp" >
+        <Original>
+          245.0f == Approx(245.25f).margin(0.25f)
+        </Original>
+        <Expanded>
+          245.0f == Approx( 245.25 )
+        </Expanded>
+      </Expression>
+      <Expression success="true" type="CHECK" filename="projects/<exe-name>/ApproxTests.cpp" >
+        <Original>
+          245.5f == Approx(245.25f).margin(0.25f)
+        </Original>
+        <Expanded>
+          245.5f == Approx( 245.25 )
+        </Expanded>
+      </Expression>
+      <OverallResult success="true"/>
+    </TestCase>
    <TestCase name="Approximate PI" tags="[Approx][PI]" filename="projects/<exe-name>/ApproxTests.cpp" >
      <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/ApproxTests.cpp" >
        <Original>
@@ -2708,7 +2759,7 @@
      </Expression>
      <Expression success="true" type="REQUIRE_FALSE" filename="projects/<exe-name>/ApproxTests.cpp" >
        <Original>
-          !d >= Approx( 1.24 )
+          !(d >= Approx( 1.24 ))
        </Original>
        <Expanded>
          !(1.23 >= Approx( 1.24 ))
@@ -2968,7 +3019,7 @@
      </Expression>
      <Expression success="true" type="REQUIRE_FALSE" filename="projects/<exe-name>/ApproxTests.cpp" >
        <Original>
-          !d &lt;= Approx( 1.22 )
+          !(d &lt;= Approx( 1.22 ))
        </Original>
        <Expanded>
          !(1.23 &lt;= Approx( 1.22 ))
@@ -4726,7 +4777,7 @@ re>"
      </Expression>
      <Expression success="true" type="CHECK_FALSE" filename="projects/<exe-name>/TrickyTests.cpp" >
        <Original>
-          !False
+          !(False)
        </Original>
        <Expanded>
          !0
@@ -7325,6 +7376,14 @@ A string sent directly to stderr
          Approx( 1.23 ) != 1.24
        </Expanded>
      </Expression>
+      <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/ApproxTests.cpp" >
+        <Original>
+          0 == Approx(0)
+        </Original>
+        <Expanded>
+          0 == Approx( 0.0 )
+        </Expanded>
+      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="Standard error is reported and redirected" tags="[.][hide][messages]" filename="projects/<exe-name>/MessageTests.cpp" >
@@ -9709,7 +9768,7 @@ spanner      <OverallResult success="true"/>
      <Section name="replace no chars" filename="projects/<exe-name>/TestMain.cpp" >
        <Expression success="true" type="CHECK_FALSE" filename="projects/<exe-name>/TestMain.cpp" >
          <Original>
-            !replaceInPlace( letters, "x", "z" )
+            !(replaceInPlace( letters, "x", "z" ))
          </Original>
          <Expanded>
            !false
@@ -10179,7 +10238,7 @@ spanner      <OverallResult success="true"/>
      </Section>
      <OverallResult success="true"/>
    </TestCase>
-    <OverallResults successes="864" failures="94" expectedFailures="21"/>
+    <OverallResults successes="871" failures="94" expectedFailures="21"/>
  </Group>
-  <OverallResults successes="864" failures="93" expectedFailures="21"/>
+  <OverallResults successes="871" failures="93" expectedFailures="21"/>
 </Catch>
--- a/scripts/updateVcpkgPackage.py
+++ b/scripts/updateVcpkgPackage.py
@@ -8,7 +8,7 @@ from releaseCommon import Version

 print(catchPath)

-default_path = '../vcpkg/ports/catch/'
+default_path = '../vcpkg/ports/catch-classic/'

 def adjusted_path(path):
    return os.path.join(catchPath, path)
@@ -65,7 +65,7 @@ def update_portfile(path, header_hash, licence_hash):
        for line in lines:
            # Update the version
            if 'set(CATCH_VERSION' in line:
-                line = 'set(CATCH_VERSION v{})'.format(v.getVersionString())
+                line = 'set(CATCH_VERSION v{})\n'.format(v.getVersionString())

            # Determine which file we are updating
            if 'vcpkg_download_distfile' in line:
--- a/single_include/catch.hpp
+++ b/single_include/catch.hpp
@@ -1,6 +1,6 @@
 /*
- *  Catch v1.10.0
- *  Generated: 2017-08-26 15:16:46.676990
+ *  Catch v1.12.2
+ *  Generated: 2018-05-14 15:10:01.112442
 *  ----------------------------------------------------------
 *  This file has been merged from multiple headers. Please don't edit it directly
 *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
@@ -228,7 +228,12 @@
    ( defined __GNUC__  && ( __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \
    ( defined __clang__ && __clang_major__ >= 3 )

-#define CATCH_INTERNAL_CONFIG_COUNTER
+// Use of __COUNTER__ is suppressed during code analysis in CLion/AppCode 2017.2.x and former,
+// because __COUNTER__ is not properly handled by it.
+// This does not affect compilation
+#if ( !defined __JETBRAINS_IDE__ || __JETBRAINS_IDE__ >= 20170300L )
+    #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif

 #endif

@@ -309,10 +314,7 @@
 #if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11)
 #   define CATCH_CONFIG_CPP11_UNIQUE_PTR
 #endif
-// Use of __COUNTER__ is suppressed if __JETBRAINS_IDE__ is #defined (meaning we're being parsed by a JetBrains IDE for
-// analytics) because, at time of writing, __COUNTER__ is not properly handled by it.
-// This does not affect compilation
-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) && !defined(__JETBRAINS_IDE__)
+#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
 #   define CATCH_CONFIG_COUNTER
 #endif
 #if defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_NO_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_NO_CPP11)
@@ -1318,10 +1320,12 @@ namespace Internal {
    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };

    template<typename T>
-    T& removeConst(T const &t) { return const_cast<T&>(t); }
+    T& opCast(T const& t) { return const_cast<T&>(t); }
+
+// nullptr_t support based on pull request #154 from Konstantin Baumann
 #ifdef CATCH_CONFIG_CPP11_NULLPTR
-    inline std::nullptr_t removeConst(std::nullptr_t) { return nullptr; }
-#endif
+    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
+#endif // CATCH_CONFIG_CPP11_NULLPTR

    // So the compare overloads can be operator agnostic we convey the operator as a template
    // enum, which is used to specialise an Evaluator for doing the comparison.
@@ -1331,90 +1335,161 @@ namespace Internal {
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsEqualTo> {
        static bool evaluate( T1 const& lhs, T2 const& rhs) {
-            return bool(removeConst(lhs) == removeConst(rhs) );
+            return bool( opCast( lhs ) ==  opCast( rhs ) );
        }
    };
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsNotEqualTo> {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool(removeConst(lhs) != removeConst(rhs) );
+            return bool( opCast( lhs ) != opCast( rhs ) );
        }
    };
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsLessThan> {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool(removeConst(lhs) < removeConst(rhs) );
+            return bool( opCast( lhs ) < opCast( rhs ) );
        }
    };
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsGreaterThan> {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool(removeConst(lhs) > removeConst(rhs) );
+            return bool( opCast( lhs ) > opCast( rhs ) );
        }
    };
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool(removeConst(lhs) >= removeConst(rhs) );
+            return bool( opCast( lhs ) >= opCast( rhs ) );
        }
    };
    template<typename T1, typename T2>
    struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool(removeConst(lhs) <= removeConst(rhs) );
+            return bool( opCast( lhs ) <= opCast( rhs ) );
        }
    };

-    // Special case for comparing a pointer to an int (deduced for p==0)
-    template<typename T>
-    struct Evaluator<int const&, T* const&, IsEqualTo> {
-        static bool evaluate( int lhs, T* rhs) {
-            return reinterpret_cast<void const*>( lhs ) ==  rhs;
-        }
-    };
-    template<typename T>
-    struct Evaluator<T* const&, int const&, IsEqualTo> {
-        static bool evaluate( T* lhs, int rhs) {
-            return lhs == reinterpret_cast<void const*>( rhs );
-        }
-    };
-    template<typename T>
-    struct Evaluator<int const&, T* const&, IsNotEqualTo> {
-        static bool evaluate( int lhs, T* rhs) {
-            return reinterpret_cast<void const*>( lhs ) !=  rhs;
-        }
-    };
-    template<typename T>
-    struct Evaluator<T* const&, int const&, IsNotEqualTo> {
-        static bool evaluate( T* lhs, int rhs) {
-            return lhs != reinterpret_cast<void const*>( rhs );
-        }
-    };
+    template<Operator Op, typename T1, typename T2>
+    bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }

-    template<typename T>
-    struct Evaluator<long const&, T* const&, IsEqualTo> {
-        static bool evaluate( long lhs, T* rhs) {
-            return reinterpret_cast<void const*>( lhs ) ==  rhs;
-        }
-    };
-    template<typename T>
-    struct Evaluator<T* const&, long const&, IsEqualTo> {
-        static bool evaluate( T* lhs, long rhs) {
-            return lhs == reinterpret_cast<void const*>( rhs );
-        }
-    };
-    template<typename T>
-    struct Evaluator<long const&, T* const&, IsNotEqualTo> {
-        static bool evaluate( long lhs, T* rhs) {
-            return reinterpret_cast<void const*>( lhs ) !=  rhs;
-        }
-    };
-    template<typename T>
-    struct Evaluator<T* const&, long const&, IsNotEqualTo> {
-        static bool evaluate( T* lhs, long rhs) {
-            return lhs != reinterpret_cast<void const*>( rhs );
-        }
-    };
+    // This level of indirection allows us to specialise for integer types
+    // to avoid signed/ unsigned warnings
+
+    // "base" overload
+    template<Operator Op, typename T1, typename T2>
+    bool compare( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }
+
+    // unsigned X to int
+    template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+
+    // unsigned X to long
+    template<Operator Op> bool compare( unsigned int lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+
+    // int to unsigned X
+    template<Operator Op> bool compare( int lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+
+    // long to unsigned X
+    template<Operator Op> bool compare( long lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+
+    // pointer to long (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+    // pointer to int (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+    // long long to unsigned X
+    template<Operator Op> bool compare( long long lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned long long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+
+    // unsigned long long to X
+    template<Operator Op> bool compare( unsigned long long lhs, int rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, long rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, long long rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, char rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+
+    // pointer to long long (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( long long lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, long long rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+#endif // CATCH_CONFIG_CPP11_LONG_LONG
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+    // pointer to nullptr_t (when comparing against nullptr)
+    template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( nullptr, rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, nullptr );
+    }
+#endif // CATCH_CONFIG_CPP11_NULLPTR

 } // end of namespace Internal
 } // end of namespace Catch
@@ -1835,7 +1910,7 @@ public:

    void endExpression() const {
        m_rb
-            .setResultType(  Internal::Evaluator<LhsT, RhsT, Op>::evaluate( m_lhs, m_rhs ) )
+            .setResultType( Internal::compare<Op>( m_lhs, m_rhs ) )
            .endExpression( *this );
    }

@@ -2756,7 +2831,8 @@ namespace Detail {
            if (relativeOK) {
                return true;
            }
-            return std::fabs(lhs_v - rhs.m_value) < rhs.m_margin;
+
+            return std::fabs(lhs_v - rhs.m_value) <= rhs.m_margin;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
@@ -2828,7 +2904,7 @@ namespace Detail {
            if (relativeOK) {
                return true;
            }
-            return std::fabs(lhs - rhs.m_value) < rhs.m_margin;
+            return std::fabs(lhs - rhs.m_value) <= rhs.m_margin;
        }

        friend bool operator == ( Approx const& lhs, double rhs ) {
@@ -5279,10 +5355,6 @@ namespace Catch {
            .describe( "should output be colourised" )
            .bind( &setUseColour, "yes|no" );

-        cli["--use-colour"]
-            .describe( "should output be colourised" )
-            .bind( &setUseColour, "yes|no" );
-
        cli["--libidentify"]
            .describe( "report name and version according to libidentify standard" )
            .bind( &ConfigData::libIdentify );
@@ -6527,6 +6599,7 @@ namespace Catch {

 #endif // not Windows

+#include <cassert>
 #include <set>
 #include <string>

@@ -7215,14 +7288,14 @@ namespace Catch {
 namespace Catch {

    struct RandomNumberGenerator {
-        typedef std::ptrdiff_t result_type;
+        typedef unsigned int result_type;

        result_type operator()( result_type n ) const { return std::rand() % n; }

 #ifdef CATCH_CONFIG_CPP11_SHUFFLE
-        static constexpr result_type min() { return 0; }
-        static constexpr result_type max() { return 1000000; }
-        result_type operator()() const { return std::rand() % max(); }
+        static constexpr result_type (min)() { return 0; }
+        static constexpr result_type (max)() { return 1000000; }
+        result_type operator()() const { return std::rand() % (max)(); }
 #endif
        template<typename V>
        static void shuffle( V& vector ) {
@@ -8136,7 +8209,7 @@ namespace Catch {

    std::string AssertionResult::getExpression() const {
        if( isFalseTest( m_info.resultDisposition ) )
-            return '!' + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
+            return "!(" + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + ")";
        else
            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
    }
@@ -8394,7 +8467,7 @@ namespace Catch {
    }

    inline Version libraryVersion() {
-        static Version version( 1, 10, 0, "", 0 );
+        static Version version( 1, 12, 2, "", 0 );
        return version;
    }

@@ -8429,11 +8502,18 @@ namespace Catch {
    : m_info( other.m_info )
    {}

+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17
+#endif
    ScopedMessage::~ScopedMessage() {
        if ( !std::uncaught_exception() ){
            getResultCapture().popScopedMessage(m_info);
        }
    }
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif

 } // end namespace Catch

@@ -9092,6 +9172,8 @@ std::string toString( std::nullptr_t ) {
 // #included from: catch_result_builder.hpp
 #define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED

+#include <cassert>
+
 namespace Catch {

    ResultBuilder::ResultBuilder(   char const* macroName,
@@ -10208,12 +10290,12 @@ namespace Catch {

            bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();

-            if( includeResults ) {
+            if( includeResults || result.getResultType() == ResultWas::Warning ) {
                // Print any info messages in <Info> tags.
                for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
                     it != itEnd;
                     ++it ) {
-                    if( it->type == ResultWas::Info ) {
+                    if( it->type == ResultWas::Info && includeResults ) {
                        m_xml.scopedElement( "Info" )
                                .writeText( it->message );
                    } else if ( it->type == ResultWas::Warning ) {
@@ -10585,6 +10667,7 @@ namespace Catch {
 // #included from: ../reporters/catch_reporter_console.hpp
 #define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED

+#include <cassert>
 #include <cfloat>
 #include <cstdio>

--- a/test_package/conanfile.py
+++ b/test_package/conanfile.py
@@ -10,7 +10,7 @@ class CatchConanTest(ConanFile):
    settings = "os", "compiler", "arch", "build_type"
    username = getenv("CONAN_USERNAME", "philsquared")
    channel = getenv("CONAN_CHANNEL", "testing")
-    requires = "Catch/1.10.0@%s/%s" % (username, channel)
+    requires = "Catch/1.12.2@%s/%s" % (username, channel)

    def build(self):
        cmake = CMake(self)
Author	SHA1	Message	Date
Benoit Blanchon	908c370f24	Fix error: ISO C++ forbids in-class initialization of non-const static member 'm_started'	2023-01-18 11:10:26 +01:00
Golubchikov Mihail	6c6cfe126a	Backport fix for SIGSTKSZ	2022-07-15 16:13:12 +02:00
Martin Hořeňovský	72df457bab	Merge pull request #2151 from fxcoudert/patch-1 Update catch_debugger.h for Apple Silicon	2021-01-13 18:16:54 +01:00
FX Coudert	bb6d08323f	Update catch_debugger.h	2021-01-11 12:22:22 +01:00
Vadim Zeitlin	64a533551d	Enable variadic macros support for MSVS 2005 as it has them Fix the test for MSVC version: variadic macros support is available since MSVS 2005, a.k.a. MSVC 8, using _MSC_VER=1400.	2019-09-06 11:45:32 +02:00
Mapping Suite	c32f275a00	Fix link to catch.hpp in tutorial.md	2018-12-18 18:19:29 +01:00
Martin Hořeňovský	6860c8def0	v1.12.2	2018-05-14 15:15:28 +02:00
Martin Hořeňovský	3255ee6312	Add missing <cassert> includes Until recently we were probably getting it from some transitive include, but it broke. Because all files should include what they use anyway, adding `#include <cassert>` to all files that use `assert()` without including it is the best solution. Fixes #1249	2018-04-22 20:36:41 +02:00
Martin Hořeňovský	74effafca7	v1.12.1	2018-03-02 21:22:10 +01:00
Martin Hořeňovský	7d0cfd27ce	Fix deprecation warning in ~ScopedMessage	2018-02-25 21:29:01 +01:00
Martin Hořeňovský	3fe4d394a5	Wrap all uses in min and max in extra parentheses This prevents `min` and `max` macros from windows headers (!@#$) from breaking compilation. Related to #1191	2018-02-23 13:06:52 +01:00
Martin Hořeňovský	b97e9a2f8b	Update path for catch-classic vcpkg's portfile	2018-01-12 11:06:09 +01:00
Martin Hořeňovský	34f7cfe046	v1.12.0	2018-01-12 09:59:21 +01:00
Martin Hořeňovský	07b9bda1d2	Revert backport of new evaluate layer to fix C++98 compilation The backport fixed some bugs (ie #981), but caused strict C++98 (and MSVC 9) compilers to fail. This means that we will reintroduce some issues but get back compatibility with obsolete compilers. People using newer ones can keep using Catch2. This reverts commit `b6e7c9bd7a`. This reverts commit `b7bd52cc98`. Should fix #1103	2017-12-07 20:02:47 +01:00
Phil Nash	84e8b696b1	Include Info messages in xml reporter even without -s	2017-12-06 16:11:12 +00:00
Pfiffikus	2d91035404	Update assertions.md scale more detailed explained; have to be adapted to PR #1068 if necessary	2017-11-01 13:32:08 +01:00
Martin Hořeňovský	2a3606f8e3	v1.11.0	2017-10-31 13:55:48 +01:00
Martin Hořeňovský	a6cf19abff	Make Approx::margin inclusive Fixes #952, related to #980	2017-10-30 21:33:29 +01:00
Pfiffikus	06586b7180	Update test-cases-and-sections.md some clarification and typo correction	2017-10-26 13:57:18 +02:00
Clare Macrae	93b3d2cb8f	Fix very minor typo it's -> its	2017-10-24 20:00:27 +02:00
Pfiffikus	a90473df28	Update build-systems.md typo correction	2017-10-24 19:59:59 +02:00
Sebastian Grottel	c9d9699ca8	adds flushes to the output stream of teamcity reporter, making the test output more responsive.	2017-10-17 16:42:05 +02:00
Sebastian Grottel	296955c437	`RandomNumberGenerator::result_type` should be unsigned (#1050 ) `result_type` must be unsigned: http://en.cppreference.com/w/cpp/concept/UniformRandomBitGenerator Using a signed type causes an infinite loop working with MS Visual Studio 2017, targetting: v140, WindowsTargetPlatformVersion 10.0.15063.0, Debug, x64	2017-10-15 18:30:40 +02:00
dvirtz	664cbf702c	added PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS option	2017-10-15 17:58:39 +02:00
Martin Hořeňovský	fb6700df54	Fix documentation crosslink in configuration.md	2017-10-14 08:36:44 +02:00
Phil Nash	da6c2a6914	Fixed expansion of _FALSE binary expression - see #1051	2017-10-13 19:44:20 +01:00
Dmitry Kozhevnikov	9c07718b5f	Update handling of __JETBRAINS_IDE__ macro 1. Use it to conditionally define CATCH_INTERNAL_CONFIG_COUNTER, not CATCH_CONFIG_COUNTER, as __JETBRAINS_IDE__ is similar to compiler-provided macros, not to user-provided ones. 2. Since __COUNTER__ will work starting with CLion 2017.3, use it when possible (and hopefully remove this check altogether at some point).	2017-09-07 18:00:04 +02:00
solvingj	5ca44b6872	Minor - added header-only flag in conan See header-only guidelines: http://conanio.readthedocs.io/en/latest/howtos/header_only.html?highlight=header%20only Its borderline cosmetic, but it does have a purpose.	2017-08-28 12:18:54 +02:00
Sam Bristow	a04bd6d436	Remove duplicate CLI option The "use-colour" option was accidentally duplicated as part of commit `feaf355` (Implemented libidentify support).	2017-08-28 12:16:23 +02:00
Martin Hořeňovský	784f6dfb34	Fix updateVcpkgPackage	2017-08-27 11:43:55 +02:00