Flush AND sleep

Most of these will not matter in practice due to C++14 imposing
significant limitations on what else we can make constexpr, and we cannot
have references outliving the constexpr context either way.

.github/workflows/mac-builds.yml

@@ -4,15 +4,10 @@ on: [push, pull_request]
 
 jobs:
   build:
-    # macos-12 updated to a toolchain that crashes when linking the
-    # test binary. This seems to be a known bug in that version,
-    # and will eventually get fixed in an update. After that, we can go
-    # back to newer macos images.
-    runs-on: macos-11
+    runs-on: macos-12
     strategy:
       matrix:
         cxx:
-          - g++-11
           - clang++
         build_type: [Debug, Release]
         std: [14, 17]
@@ -29,8 +24,6 @@ jobs:
       env:
         CXX: ${{matrix.cxx}}
         CXXFLAGS: ${{matrix.cxxflags}}
-      # Note: $GITHUB_WORKSPACE is distinct from ${{runner.workspace}}.
-      #       This is important
       run: |
         cmake -Bbuild -H$GITHUB_WORKSPACE \
               -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \

.gitignore

@@ -25,8 +25,9 @@ Build
 cmake-build-*
 benchmark-dir
 .conan/test_package/build
-.conan/test_package/CMakeUserPresets.json
+**/CMakeUserPresets.json
 bazel-*
+MODULE.bazel.lock
 build-fuzzers
 debug-build
 .vscode
@@ -36,3 +37,4 @@ msvc-sln*
 docs/doxygen
 *.cache
 compile_commands.json
+**/*.unapproved.txt

CMake/CatchMiscFunctions.cmake

@@ -68,6 +68,7 @@ function(add_warnings_to_targets targets)
           "-Wmissing-noreturn"
           "-Wmissing-prototypes"
           "-Wmissing-variable-declarations"
+          "-Wnon-virtual-dtor"
           "-Wnull-dereference"
           "-Wold-style-cast"
           "-Woverloaded-virtual"

CMakeLists.txt

@@ -33,7 +33,7 @@ if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 endif()
 
 project(Catch2
-  VERSION 3.5.4 # CML version placeholder, don't delete
+  VERSION 3.7.0 # CML version placeholder, don't delete
   LANGUAGES CXX
   # HOMEPAGE_URL is not supported until CMake version 3.12, which
   # we do not target yet.
@@ -76,8 +76,6 @@ endif()
 set(CATCH_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(SOURCES_DIR ${CATCH_DIR}/src/catch2)
 set(SELF_TEST_DIR ${CATCH_DIR}/tests/SelfTest)
-set(BENCHMARK_DIR ${CATCH_DIR}/tests/Benchmark)
-set(EXAMPLES_DIR ${CATCH_DIR}/examples)
 
 # We need to bring-in the variables defined there to this scope
 add_subdirectory(src)

MODULE.bazel

@@ -1,3 +1,3 @@
 module(name = "catch2")
 
-bazel_dep(name = "bazel_skylib", version = "1.5.0")
+bazel_dep(name = "bazel_skylib", version = "1.7.1")

WORKSPACE.bazel

@@ -4,10 +4,10 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
 http_archive(
     name = "bazel_skylib",
-    sha256 = "cd55a062e763b9349921f0f5db8c3933288dc8ba4f76dd9416aac68acee3cb94",
+    sha256 = "bc283cdfcd526a52c3201279cda4bc298652efa898b10b4db0837dc51652756f",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.5.0/bazel-skylib-1.5.0.tar.gz",
-        "https://github.com/bazelbuild/bazel-skylib/releases/download/1.5.0/bazel-skylib-1.5.0.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.7.1/bazel-skylib-1.7.1.tar.gz",
+        "https://github.com/bazelbuild/bazel-skylib/releases/download/1.7.1/bazel-skylib-1.7.1.tar.gz",
     ],
 )
 

conanfile.py

@@ -19,6 +19,7 @@ class CatchConan(ConanFile):
     license = "BSL-1.0"
     version = "latest"
     settings = "os", "compiler", "build_type", "arch"
+    extension_properties = {"compatibility_cppstd": False}
 
     options = {
         "shared": [True, False],
@@ -115,6 +116,7 @@ class CatchConan(ConanFile):
 
         # Catch2
         self.cpp_info.components["catch2base"].set_property("cmake_file_name", "Catch2::Catch2")
+        self.cpp_info.components["catch2base"].set_property("cmake_target_name", "Catch2::Catch2")
         self.cpp_info.components["catch2base"].set_property("pkg_config_name", "catch2")
         self.cpp_info.components["catch2base"].libs = ["Catch2" + lib_suffix]
         self.cpp_info.components["catch2base"].builddirs.append("lib/cmake/Catch2")

docs/assertions.md

@@ -110,7 +110,7 @@ Expects that an exception is thrown that, when converted to a string, matches th
 
 e.g.
 ```cpp
-REQUIRE_THROWS_WITH( openThePodBayDoors(), Contains( "afraid" ) && Contains( "can't do that" ) );
+REQUIRE_THROWS_WITH( openThePodBayDoors(), ContainsSubstring( "afraid" ) && ContainsSubstring( "can't do that" ) );
 REQUIRE_THROWS_WITH( dismantleHal(), "My mind is going" );
 ```
 

docs/cmake-integration.md

@@ -8,6 +8,7 @@
 [`CATCH_CONFIG_*` customization options in CMake](#catch_config_-customization-options-in-cmake)<br>
 [Installing Catch2 from git repository](#installing-catch2-from-git-repository)<br>
 [Installing Catch2 from vcpkg](#installing-catch2-from-vcpkg)<br>
+[Installing Catch2 from Bazel](#installing-catch2-from-bazel)<br>
 
 Because we use CMake to build Catch2, we also provide a couple of
 integration points for our users.

docs/contributing.md

@@ -107,8 +107,7 @@ cmake -B debug-build -S . -DCMAKE_BUILD_TYPE=Debug --preset all-tests
 cmake --build debug-build
 
 # 4. Run the tests using CTest
-cd debug-build
-ctest -j 4 --output-on-failure -C Debug
+ctest -j 4 --output-on-failure -C Debug --test-dir debug-build
 ```
 <sup><a href='/tools/scripts/buildAndTest.sh#L6-L19' title='File snippet `catch2-build-and-test` was extracted from'>snippet source</a> | <a href='#snippet-catch2-build-and-test' title='Navigate to start of snippet `catch2-build-and-test`'>anchor</a></sup>
 <!-- endSnippet -->

docs/deprecations.md

@@ -35,6 +35,19 @@ being aborted (when using `--abort` or `--abortx`). It is however
 **NOT** invoked for test cases that are [explicitly skipped using the `SKIP`
 macro](skipping-passing-failing.md#top).
 
+
+### Non-const function for `TEST_CASE_METHOD`
+
+> Deprecated in Catch2 vX.Y.Z
+
+Currently, the member function generated for `TEST_CASE_METHOD` is
+not `const` qualified. In the future, the generated member function will
+be `const` qualified, just as `TEST_CASE_PERSISTENT_FIXTURE` does.
+
+If you are mutating the fixture instance from within the test case, and
+want to keep doing so in the future, mark the mutated members as `mutable`.
+
+
 ---
 
 [Home](Readme.md#top)

docs/list-of-examples.md

@@ -8,6 +8,7 @@
 - Assertion: [REQUIRE, CHECK](../examples/030-Asn-Require-Check.cpp)
 - Fixture: [Sections](../examples/100-Fix-Section.cpp)
 - Fixture: [Class-based fixtures](../examples/110-Fix-ClassFixture.cpp)
+- Fixture: [Persistent fixtures](../examples/111-Fix-PersistentFixture.cpp)
 - BDD: [SCENARIO, GIVEN, WHEN, THEN](../examples/120-Bdd-ScenarioGivenWhenThen.cpp)
 - Listener: [Listeners](../examples/210-Evt-EventListeners.cpp)
 - Configuration: [Provide your own output streams](../examples/231-Cfg-OutputStreams.cpp)

docs/matchers.md

@@ -210,15 +210,36 @@ The other miscellaneous matcher utility is exception matching.
 
 #### Matching exceptions
 
-Catch2 provides a utility macro for asserting that an expression
-throws exception of specific type, and that the exception has desired
-properties. The macro is `REQUIRE_THROWS_MATCHES(expr, ExceptionType, Matcher)`.
+Because exceptions are a bit special, Catch2 has a separate macro for them.
+
+
+The basic form is
+
+```
+REQUIRE_THROWS_MATCHES(expr, ExceptionType, Matcher)
+```
+
+and it checks that the `expr` throws an exception, that exception is derived
+from the `ExceptionType` type, and then `Matcher::match` is called on
+the caught exception.
 
 > `REQUIRE_THROWS_MATCHES` macro lives in `catch2/matchers/catch_matchers.hpp`
 
+For one-off checks you can use the `Predicate` matcher above, e.g.
 
-Catch2 currently provides two matchers for exceptions.
-These are:
+```cpp
+REQUIRE_THROWS_MATCHES(parse(...),
+                       parse_error,
+                       Predicate<parse_error>([] (parse_error const& err) -> bool { return err.line() == 1; })
+);
+```
+
+but if you intend to thoroughly test your error reporting, I recommend
+defining a specialized matcher.
+
+
+Catch2 also provides 2 built-in matchers for checking the error message
+inside an exception (it must be derived from `std::exception`):
 * `Message(std::string message)`.
 * `MessageMatches(Matcher matcher)`.
 
@@ -236,10 +257,7 @@ REQUIRE_THROWS_MATCHES(throwsDerivedException(),  DerivedException,  Message("De
 REQUIRE_THROWS_MATCHES(throwsDerivedException(),  DerivedException,  MessageMatches(StartsWith("DerivedException")));
 ```
 
-Note that `DerivedException` in the example above has to derive from
-`std::exception` for the example to work.
-
-> the exception message matcher lives in `catch2/matchers/catch_matchers_exception.hpp`
+> the exception message matchers live in `catch2/matchers/catch_matchers_exception.hpp`
 
 
 ### Generic range Matchers

docs/other-macros.md

@@ -93,30 +93,6 @@ TEST_CASE("STATIC_CHECK showcase", "[traits]") {
 
 ## Test case related macros
 
-* `METHOD_AS_TEST_CASE`
-
-`METHOD_AS_TEST_CASE( member-function-pointer, description )` lets you
-register a member function of a class as a Catch2 test case. The class
-will be separately instantiated for each method registered in this way.
-
-```cpp
-class TestClass {
-    std::string s;
-
-public:
-    TestClass()
-        :s( "hello" )
-    {}
-
-    void testCase() {
-        REQUIRE( s == "hello" );
-    }
-};
-
-
-METHOD_AS_TEST_CASE( TestClass::testCase, "Use class's method as a test case", "[class]" )
-```
-
 * `REGISTER_TEST_CASE`
 
 `REGISTER_TEST_CASE( function, description )` let's you register

docs/release-notes.md

@@ -2,6 +2,8 @@
 
 # Release notes
 **Contents**<br>
+[3.7.0](#370)<br>
+[3.6.0](#360)<br>
 [3.5.4](#354)<br>
 [3.5.3](#353)<br>
 [3.5.2](#352)<br>
@@ -62,6 +64,51 @@
 [Even Older versions](#even-older-versions)<br>
 
 
+## 3.7.0
+
+### Improvements
+* Slightly improved compile times of benchmarks
+* Made the resolution estimation in benchmarks slightly more precise
+* Added new test case macro, `TEST_CASE_PERSISTENT_FIXTURE` (#2885, #1602)
+  * Unlike `TEST_CASE_METHOD`, the same underlying instance is used for all partial runs of that test case
+* **MASSIVELY** improved performance of the JUnit reporter when handling successful assertions (#2897)
+  * For 1 test case and 10M assertions, the new reporter runs 3x faster and uses up only 8 MB of memory, while the old one needs 7 GB of memory.
+* Reworked how output redirects works.
+  * Combining a reporter writing to stdout with capturing reporter no longer leads to the capturing reporter seeing all of the other reporter's output.
+  * The file based redirect no longer opens up a new temporary file for each partial test case run, so it will not run out of temporary files when running many tests in single process.
+
+### Miscellaneous
+* Better documentation for matchers on thrown exceptions (`REQUIRE_THROWS_MATCHES`)
+* Improved `catch_discover_tests`'s handling of environment paths (#2878)
+  * It won't reorder paths in `DL_PATHS` or `DYLD_FRAMEWORK_PATHS` args
+  * It won't overwrite the environment paths for test discovery
+
+
+## 3.6.0
+
+### Fixes
+* Fixed Windows ARM64 build by fixing the preprocessor condition guarding use `_umul128` intrinsic.
+* Fixed Windows ARM64EC build by removing intrinsic pragma it does not understand. (#2858)
+  * Why doesn't the x64-emulation build mode understand x64 pragmas? Don't ask me, ask the MSVC guys.
+* Fixed the JUnit reporter sometimes crashing when reporting a fatal error. (#1210, #2855)
+  * The binary will still exit, but through the original error, rather than secondary error inside the reporter.
+  * The underlying fix applies to all reporters, not just the JUnit one, but only JUnit was currently causing troubles.
+
+### Improvements
+* Disable `-Wnon-virtual-dtor` in Decomposer and Matchers (#2854)
+* `precision` in floating point stringmakers defaults to `max_digits10`.
+  * This means that floating point values will be printed with enough precision to disambiguate any two floats.
+* Column wrapping ignores ansi colour codes when calculating string width (#2833, #2849)
+  * This makes the output much more readable when the provided messages contain colour codes.
+
+### Miscellaneous
+* Conan support improvements
+  * `compatibility_cppstr` is set to False. (#2860)
+    * This means that Conan won't let you mix library and project with different C++ standard settings.
+  * The implementation library CMake target name through Conan is properly set to `Catch2::Catch2` (#2861)
+* `SelfTest` target can be built through Bazel (#2857)
+
+
 ## 3.5.4
 
 ### Fixes

docs/test-cases-and-sections.md

@@ -48,7 +48,7 @@ For more detail on command line selection see [the command line docs](command-li
 Tag names are not case sensitive and can contain any ASCII characters.
 This means that tags `[tag with spaces]` and `[I said "good day"]`
 are both allowed tags and can be filtered on. However, escapes are not
-supported however and `[\]]` is not a valid tag.
+supported and `[\]]` is not a valid tag.
 
 The same tag can be specified multiple times for a single test case,
 but only one of the instances of identical tags will be kept. Which one

docs/test-fixtures.md

@@ -1,9 +1,30 @@
 <a id="top"></a>
 # Test fixtures
 
-## Defining test fixtures
+**Contents**<br>
+[Non-Templated test fixtures](#non-templated-test-fixtures)<br>
+[Templated test fixtures](#templated-test-fixtures)<br>
+[Signature-based parameterised test fixtures](#signature-based-parametrised-test-fixtures)<br>
+[Template fixtures with types specified in template type lists](#template-fixtures-with-types-specified-in-template-type-lists)<br>
 
-Although Catch allows you to group tests together as [sections within a test case](test-cases-and-sections.md), it can still be convenient, sometimes, to group them using a more traditional test fixture. Catch fully supports this too. You define the test fixture as a simple structure:
+## Non-Templated test fixtures
+
+Although Catch2 allows you to group tests together as 
+[sections within a test case](test-cases-and-sections.md), it can still 
+be convenient, sometimes, to group them using a more traditional test. 
+Catch2 fully supports this too with 3 different macros for 
+non-templated test fixtures. They are: 
+
+| Macro    | Description |
+|----------|-------------|
+|1. `TEST_CASE_METHOD(className, ...)`| Creates a uniquely named class which inherits from the class specified by `className`. The test function will be a member of this derived class. An instance of the derived class will be created for every partial run of the test case. |
+|2. `METHOD_AS_TEST_CASE(member-function, ...)`| Uses `member-function` as the test function. An instance of the class will be created for each partial run of the test case. |
+|3. `TEST_CASE_PERSISTENT_FIXTURE(className, ...)`| Creates a uniquely named class which inherits from the class specified by `className`. The test function will be a member of this derived class. An instance of the derived class will be created at the start of the test run. That instance will be destroyed once the entire test case has ended. |
+
+### 1. `TEST_CASE_METHOD`
+
+
+You define a `TEST_CASE_METHOD` test fixture as a simple structure:
 
 ```c++
 class UniqueTestsFixture {
@@ -30,8 +51,116 @@ class UniqueTestsFixture {
  }
 ```
 
-The two test cases here will create uniquely-named derived classes of UniqueTestsFixture and thus can access the `getID()` protected method and `conn` member variables. This ensures that both the test cases are able to create a DBConnection using the same method (DRY principle) and that any ID's created are unique such that the order that tests are executed does not matter.
+The two test cases here will create uniquely-named derived classes of 
+UniqueTestsFixture and thus can access the `getID()` protected method 
+and `conn` member variables. This ensures that both the test cases 
+are able to create a DBConnection using the same method 
+(DRY principle) and that any ID's created are unique such that the 
+order that tests are executed does not matter. 
 
+### 2. `METHOD_AS_TEST_CASE`
+
+`METHOD_AS_TEST_CASE` lets you register a member function of a class 
+as a Catch2 test case. The class will be separately instantiated 
+for each method registered in this way.
+
+```cpp
+class TestClass {
+    std::string s;
+
+public:
+    TestClass()
+        :s( "hello" )
+    {}
+
+    void testCase() {
+        REQUIRE( s == "hello" );
+    }
+};
+
+
+METHOD_AS_TEST_CASE( TestClass::testCase, "Use class's method as a test case", "[class]" )
+```
+
+This type of fixture is similar to [TEST_CASE_METHOD](#1-test_case_method) except in this 
+case it will directly use the provided class to create an object rather than a derived 
+class.
+
+### 3. `TEST_CASE_PERSISTENT_FIXTURE`
+
+> [Introduced](https://github.com/catchorg/Catch2/pull/2885) in Catch2 3.7.0
+
+`TEST_CASE_PERSISTENT_FIXTURE` behaves in the same way as
+[TEST_CASE_METHOD](#1-test_case_method) except that there will only be
+one instance created throughout the entire run of a test case. To 
+demonstrate this have a look at the following example:
+
+```cpp
+class ClassWithExpensiveSetup {
+public:
+    ClassWithExpensiveSetup() {
+        // expensive construction
+        std::this_thread::sleep_for( std::chrono::seconds( 2 ) );
+    }
+
+    ~ClassWithExpensiveSetup() noexcept {
+        // expensive destruction
+        std::this_thread::sleep_for( std::chrono::seconds( 1 ) );
+    }
+
+    int getInt() const { return 42; }
+};
+
+struct MyFixture {
+    mutable int myInt = 0;
+    ClassWithExpensiveSetup expensive;
+};
+
+TEST_CASE_PERSISTENT_FIXTURE( MyFixture, "Tests with MyFixture" ) {
+
+    const int val = myInt++;
+
+    SECTION( "First partial run" ) {
+        const auto otherValue = expensive.getInt();
+        REQUIRE( val == 0 );
+        REQUIRE( otherValue == 42 );
+    }
+
+    SECTION( "Second partial run" ) { REQUIRE( val == 1 ); }
+}
+```
+
+This example demonstates two possible use-cases of this fixture type:
+1. Improve test run times by reducing the amount of expensive and 
+redundant setup and tear-down required.
+2. Reusing results from the previous partial run, in the current
+partial run.
+
+This test case will be executed twice as there are two leaf sections.
+On the first run `val` will be `0` and on the second run `val` will be 
+`1`. This demonstrates that we were able to use the results of the
+previous partial run in subsequent partial runs.
+
+Additionally, we are simulating an expensive object using 
+`std::this_thread::sleep_for`, but real world use-cases could be:
+1. Creating a D3D12/Vulkan device
+2. Connecting to a database
+3. Loading a file.
+
+The fixture object (`MyFixture`) will be constructed just before the
+test case begins, and it will be destroyed just after the test case 
+ends. Therefore, this expensive object will only be created and 
+destroyed once during the execution of this test case. If we had used 
+`TEST_CASE_METHOD`, `MyFixture` would have been created and destroyed 
+twice during the execution of this test case.
+
+NOTE: The member function which runs the test case is `const`. Therefore 
+if you want to mutate any member of the fixture it must be marked as
+`mutable` as shown in this example. This is to make it clear that
+the initial state of the fixture is intended to mutate during the
+execution of the test case.
+
+## Templated test fixtures
 
 Catch2 also provides `TEMPLATE_TEST_CASE_METHOD` and
 `TEMPLATE_PRODUCT_TEST_CASE_METHOD` that can be used together
@@ -93,7 +222,7 @@ _While there is an upper limit on the number of types you can specify
 in single `TEMPLATE_TEST_CASE_METHOD` or `TEMPLATE_PRODUCT_TEST_CASE_METHOD`,
 the limit is very high and should not be encountered in practice._
 
-## Signature-based parametrised test fixtures
+## Signature-based parameterised test fixtures
 
 > [Introduced](https://github.com/catchorg/Catch2/issues/1609) in Catch2 2.8.0.
 

examples/111-Fix-PersistentFixture.cpp

@@ -0,0 +1,74 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+// Fixture.cpp
+
+// Catch2 has three ways to express fixtures:
+// - Sections
+// - Traditional class-based fixtures that are created and destroyed on every
+// partial run
+// - Traditional class-based fixtures that are created at the start of a test
+// case and destroyed at the end of a test case (this file)
+
+// main() provided by linkage to Catch2WithMain
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <thread>
+
+class ClassWithExpensiveSetup {
+public:
+    ClassWithExpensiveSetup() {
+        // Imagine some really expensive set up here.
+        // e.g.
+        // setting up a D3D12/Vulkan Device,
+        // connecting to a database,
+        // loading a file
+        // etc etc etc
+        std::this_thread::sleep_for( std::chrono::seconds( 2 ) );
+    }
+
+    ~ClassWithExpensiveSetup() noexcept {
+        // We can do any clean up of the expensive class in the destructor
+        // e.g.
+        // destroy D3D12/Vulkan Device,
+        // disconnecting from a database,
+        // release file handle
+        // etc etc etc
+        std::this_thread::sleep_for( std::chrono::seconds( 1 ) );
+    }
+
+    int getInt() const { return 42; }
+};
+
+struct MyFixture {
+
+    // The test case member function is const.
+    // Therefore we need to mark any member of the fixture
+    // that needs to mutate as mutable.
+    mutable int myInt = 0;
+    ClassWithExpensiveSetup expensive;
+};
+
+// Only one object of type MyFixture will be instantiated for the run
+// of this test case even though there are two leaf sections.
+// This is useful if your test case requires an object that is
+// expensive to create and could be reused for each partial run of the
+// test case.
+TEST_CASE_PERSISTENT_FIXTURE( MyFixture, "Tests with MyFixture" ) {
+
+    const int val = myInt++;
+
+    SECTION( "First partial run" ) {
+        const auto otherValue = expensive.getInt();
+        REQUIRE( val == 0 );
+        REQUIRE( otherValue == 42 );
+    }
+
+    SECTION( "Second partial run" ) { REQUIRE( val == 1 ); }
+}

examples/CMakeLists.txt

@@ -28,6 +28,7 @@ set( SOURCES_IDIOMATIC_EXAMPLES
     030-Asn-Require-Check.cpp
     100-Fix-Section.cpp
     110-Fix-ClassFixture.cpp
+    111-Fix-PersistentFixture.cpp
     120-Bdd-ScenarioGivenWhenThen.cpp
     210-Evt-EventListeners.cpp
     232-Cfg-CustomMain.cpp
@@ -43,8 +44,7 @@ set( TARGETS_IDIOMATIC_EXAMPLES ${BASENAMES_IDIOMATIC_EXAMPLES} )
 
 
 foreach( name ${TARGETS_IDIOMATIC_EXAMPLES} )
-    add_executable( ${name}
-      ${EXAMPLES_DIR}/${name}.cpp )
+    add_executable( ${name} ${name}.cpp )
 endforeach()
 
 set(ALL_EXAMPLE_TARGETS

extras/Catch.cmake

@@ -124,6 +124,13 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
     test executable and when the tests are executed themselves. This requires
     cmake/ctest >= 3.22.
 
+  ``DL_FRAMEWORK_PATHS path...``
+    Specifies paths that need to be set for the dynamic linker to find libraries
+    packaged as frameworks on Apple platforms when running the test executable
+    (DYLD_FRAMEWORK_PATH). These paths will both be set when retrieving the list
+    of test cases from the test executable and when the tests are executed themselves.
+    This requires cmake/ctest >= 3.22.
+
   `DISCOVERY_MODE mode``
     Provides control over when ``catch_discover_tests`` performs test discovery.
     By default, ``POST_BUILD`` sets up a post-build command to perform test discovery
@@ -146,7 +153,7 @@ function(catch_discover_tests TARGET)
     ""
     ""
     "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX;DISCOVERY_MODE"
-    "TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS"
+    "TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS;DL_FRAMEWORK_PATHS"
     ${ARGN}
   )
 
@@ -156,10 +163,11 @@ function(catch_discover_tests TARGET)
   if(NOT _TEST_LIST)
     set(_TEST_LIST ${TARGET}_TESTS)
   endif()
-  if (_DL_PATHS)
-    if(${CMAKE_VERSION} VERSION_LESS "3.22.0")
-        message(FATAL_ERROR "The DL_PATHS option requires at least cmake 3.22")
-    endif()
+  if(_DL_PATHS AND ${CMAKE_VERSION} VERSION_LESS "3.22.0")
+    message(FATAL_ERROR "The DL_PATHS option requires at least cmake 3.22")
+  endif()
+  if(_DL_FRAMEWORK_PATHS AND ${CMAKE_VERSION} VERSION_LESS "3.22.0")
+    message(FATAL_ERROR "The DL_FRAMEWORK_PATHS option requires at least cmake 3.22")
   endif()
   if(NOT _DISCOVERY_MODE)
     if(NOT CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE)
@@ -205,6 +213,7 @@ function(catch_discover_tests TARGET)
               -D "TEST_OUTPUT_PREFIX=${_OUTPUT_PREFIX}"
               -D "TEST_OUTPUT_SUFFIX=${_OUTPUT_SUFFIX}"
               -D "TEST_DL_PATHS=${_DL_PATHS}"
+              -D "TEST_DL_FRAMEWORK_PATHS=${_DL_FRAMEWORK_PATHS}"
               -D "CTEST_FILE=${ctest_tests_file}"
               -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
       VERBATIM
@@ -250,6 +259,7 @@ function(catch_discover_tests TARGET)
       "      TEST_OUTPUT_SUFFIX"     " [==[" "${_OUTPUT_SUFFIX}"          "]==]"   "\n"
       "      CTEST_FILE"             " [==[" "${ctest_tests_file}"        "]==]"   "\n"
       "      TEST_DL_PATHS"          " [==[" "${_DL_PATHS}"               "]==]"   "\n"
+      "      TEST_DL_FRAMEWORK_PATHS" " [==[" "${_DL_FRAMEWORK_PATHS}"     "]==]"   "\n"
       "      CTEST_FILE"             " [==[" "${CTEST_FILE}"              "]==]"   "\n"
       "    )"                                                                      "\n"
       "  endif()"                                                                  "\n"

extras/CatchAddTests.cmake

@@ -22,7 +22,7 @@ function(catch_discover_tests_impl)
     ""
     ""
     "TEST_EXECUTABLE;TEST_WORKING_DIR;TEST_OUTPUT_DIR;TEST_OUTPUT_PREFIX;TEST_OUTPUT_SUFFIX;TEST_PREFIX;TEST_REPORTER;TEST_SPEC;TEST_SUFFIX;TEST_LIST;CTEST_FILE"
-    "TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR;TEST_DL_PATHS"
+    "TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR;TEST_DL_PATHS;TEST_DL_FRAMEWORK_PATHS"
     ${ARGN}
   )
 
@@ -36,6 +36,8 @@ function(catch_discover_tests_impl)
   set(output_prefix ${_TEST_OUTPUT_PREFIX})
   set(output_suffix ${_TEST_OUTPUT_SUFFIX})
   set(dl_paths ${_TEST_DL_PATHS})
+  set(dl_framework_paths ${_TEST_DL_FRAMEWORK_PATHS})
+  set(environment_modifications "")
   set(script)
   set(suite)
   set(tests)
@@ -56,10 +58,19 @@ function(catch_discover_tests_impl)
   endif()
 
   if(dl_paths)
-    cmake_path(CONVERT "${dl_paths}" TO_NATIVE_PATH_LIST paths)
+    cmake_path(CONVERT "$ENV{${dl_paths_variable_name}}" TO_NATIVE_PATH_LIST env_dl_paths)
+    list(PREPEND env_dl_paths "${dl_paths}")
+    cmake_path(CONVERT "${env_dl_paths}" TO_NATIVE_PATH_LIST paths)
     set(ENV{${dl_paths_variable_name}} "${paths}")
   endif()
 
+  if(APPLE AND dl_framework_paths)
+    cmake_path(CONVERT "$ENV{DYLD_FRAMEWORK_PATH}" TO_NATIVE_PATH_LIST env_dl_framework_paths)
+    list(PREPEND env_dl_framework_paths "${dl_framework_paths}")
+    cmake_path(CONVERT "${env_dl_framework_paths}" TO_NATIVE_PATH_LIST paths)
+    set(ENV{DYLD_FRAMEWORK_PATH} "${paths}")
+  endif()
+
   execute_process(
     COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
     OUTPUT_VARIABLE output
@@ -117,7 +128,14 @@ function(catch_discover_tests_impl)
   if(dl_paths)
     foreach(path ${dl_paths})
       cmake_path(NATIVE_PATH path native_path)
-      list(APPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
+      list(PREPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
+    endforeach()
+  endif()
+
+  if(APPLE AND dl_framework_paths)
+    foreach(path ${dl_framework_paths})
+      cmake_path(NATIVE_PATH path native_path)
+      list(PREPEND environment_modifications "DYLD_FRAMEWORK_PATH=path_list_prepend:${native_path}")
     endforeach()
   endif()
 
@@ -187,6 +205,7 @@ if(CMAKE_SCRIPT_MODE_FILE)
     TEST_OUTPUT_PREFIX ${TEST_OUTPUT_PREFIX}
     TEST_OUTPUT_SUFFIX ${TEST_OUTPUT_SUFFIX}
     TEST_DL_PATHS ${TEST_DL_PATHS}
+    TEST_DL_FRAMEWORK_PATHS ${TEST_DL_FRAMEWORK_PATHS}
     CTEST_FILE ${CTEST_FILE}
   )
 endif()

extras/catch_amalgamated.hpp

@@ -6,8 +6,8 @@
 
 // SPDX-License-Identifier: BSL-1.0
 
-//  Catch v3.5.4
-//  Generated: 2024-04-10 12:03:45.785902
+//  Catch v3.7.0
+//  Generated: 2024-08-14 12:04:53.220567
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -1584,22 +1584,17 @@ namespace Catch {
             private:
                 struct callable {
                     virtual void call(Chronometer meter) const = 0;
-                    virtual Catch::Detail::unique_ptr<callable> clone() const = 0;
                     virtual ~callable(); // = default;
 
                     callable() = default;
-                    callable(callable const&) = default;
-                    callable& operator=(callable const&) = default;
+                    callable(callable&&) = default;
+                    callable& operator=(callable&&) = default;
                 };
                 template <typename Fun>
                 struct model : public callable {
                     model(Fun&& fun_) : fun(CATCH_MOVE(fun_)) {}
                     model(Fun const& fun_) : fun(fun_) {}
 
-                    Catch::Detail::unique_ptr<callable> clone() const override {
-                        return Catch::Detail::make_unique<model<Fun>>( *this );
-                    }
-
                     void call(Chronometer meter) const override {
                         call(meter, is_callable<Fun(Chronometer)>());
                     }
@@ -1613,14 +1608,8 @@ namespace Catch {
                     Fun fun;
                 };
 
-                struct do_nothing { void operator()() const {} };
-
-                template <typename T>
-                BenchmarkFunction(model<T>* c) : f(c) {}
-
             public:
-                BenchmarkFunction()
-                    : f(new model<do_nothing>{ {} }) {}
+                BenchmarkFunction();
 
                 template <typename Fun,
                     std::enable_if_t<!is_related<Fun, BenchmarkFunction>::value, int> = 0>
@@ -1630,20 +1619,12 @@ namespace Catch {
                 BenchmarkFunction( BenchmarkFunction&& that ) noexcept:
                     f( CATCH_MOVE( that.f ) ) {}
 
-                BenchmarkFunction(BenchmarkFunction const& that)
-                    : f(that.f->clone()) {}
-
                 BenchmarkFunction&
                 operator=( BenchmarkFunction&& that ) noexcept {
                     f = CATCH_MOVE( that.f );
                     return *this;
                 }
 
-                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
-                    f = that.f->clone();
-                    return *this;
-                }
-
                 void operator()(Chronometer meter) const { f->call(meter); }
 
             private:
@@ -1780,7 +1761,7 @@ namespace Catch {
             template <typename Clock, typename Fun, typename... Args>
             TimingOf<Fun, Args...> measure(Fun&& fun, Args&&... args) {
                 auto start = Clock::now();
-                auto&& r = Detail::complete_invoke(fun, CATCH_FORWARD(args)...);
+                auto&& r = Detail::complete_invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
                 auto end = Clock::now();
                 auto delta = end - start;
                 return { delta, CATCH_FORWARD(r), 1 };
@@ -1946,15 +1927,17 @@ namespace Catch {
         namespace Detail {
             template <typename Clock>
             std::vector<double> resolution(int k) {
-                std::vector<TimePoint<Clock>> times;
-                times.reserve(static_cast<size_t>(k + 1));
-                for ( int i = 0; i < k + 1; ++i ) {
-                    times.push_back( Clock::now() );
+                const size_t points = static_cast<size_t>( k + 1 );
+                // To avoid overhead from the branch inside vector::push_back,
+                // we allocate them all and then overwrite.
+                std::vector<TimePoint<Clock>> times(points);
+                for ( auto& time : times ) {
+                    time = Clock::now();
                 }
 
                 std::vector<double> deltas;
                 deltas.reserve(static_cast<size_t>(k));
-                for ( size_t idx = 1; idx < times.size(); ++idx ) {
+                for ( size_t idx = 1; idx < points; ++idx ) {
                     deltas.push_back( static_cast<double>(
                         ( times[idx] - times[idx - 1] ).count() ) );
                 }
@@ -2103,12 +2086,12 @@ namespace Catch {
                 : fun(CATCH_MOVE(func)), name(CATCH_MOVE(benchmarkName)) {}
 
             template <typename Clock>
-            ExecutionPlan prepare(const IConfig &cfg, Environment env) const {
+            ExecutionPlan prepare(const IConfig &cfg, Environment env) {
                 auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
                 auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
                 auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<IDuration>(run_time), 1, fun);
                 int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), CATCH_MOVE(fun), std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
             }
 
             template <typename Clock = default_clock>
@@ -3347,6 +3330,18 @@ namespace Catch {
 #endif // CATCH_ASSERTION_RESULT_HPP_INCLUDED
 
 
+#ifndef CATCH_CASE_SENSITIVE_HPP_INCLUDED
+#define CATCH_CASE_SENSITIVE_HPP_INCLUDED
+
+namespace Catch {
+
+    enum class CaseSensitive { Yes, No };
+
+} // namespace Catch
+
+#endif // CATCH_CASE_SENSITIVE_HPP_INCLUDED
+
+
 #ifndef CATCH_CONFIG_HPP_INCLUDED
 #define CATCH_CONFIG_HPP_INCLUDED
 
@@ -3366,18 +3361,6 @@ namespace Catch {
 #define CATCH_WILDCARD_PATTERN_HPP_INCLUDED
 
 
-
-#ifndef CATCH_CASE_SENSITIVE_HPP_INCLUDED
-#define CATCH_CASE_SENSITIVE_HPP_INCLUDED
-
-namespace Catch {
-
-    enum class CaseSensitive { Yes, No };
-
-} // namespace Catch
-
-#endif // CATCH_CASE_SENSITIVE_HPP_INCLUDED
-
 #include <string>
 
 namespace Catch
@@ -5242,9 +5225,11 @@ namespace Detail {
 #ifdef __clang__
 #  pragma clang diagnostic push
 #  pragma clang diagnostic ignored "-Wsign-compare"
+#  pragma clang diagnostic ignored "-Wnon-virtual-dtor"
 #elif defined __GNUC__
 #  pragma GCC diagnostic push
 #  pragma GCC diagnostic ignored "-Wsign-compare"
+#  pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
 #endif
 
 #if defined(CATCH_CPP20_OR_GREATER) && __has_include(<compare>)
@@ -5951,6 +5936,8 @@ namespace Catch {
 
     class ITestInvoker {
     public:
+        virtual void prepareTestCase();
+        virtual void tearDownTestCase();
         virtual void invoke() const = 0;
         virtual ~ITestInvoker(); // = default
     };
@@ -6003,6 +5990,33 @@ Detail::unique_ptr<ITestInvoker> makeTestInvoker( void (C::*testAsMethod)() ) {
     return Detail::make_unique<TestInvokerAsMethod<C>>( testAsMethod );
 }
 
+template <typename C>
+class TestInvokerFixture : public ITestInvoker {
+    void ( C::*m_testAsMethod )() const;
+    Detail::unique_ptr<C> m_fixture = nullptr;
+
+public:
+    TestInvokerFixture( void ( C::*testAsMethod )() const) noexcept : m_testAsMethod( testAsMethod ) {}
+
+    void prepareTestCase() override {
+        m_fixture = Detail::make_unique<C>();
+    }
+
+    void tearDownTestCase() override {
+        m_fixture.reset();
+    }
+
+    void invoke() const override {
+        auto* f = m_fixture.get();
+        ( f->*m_testAsMethod )();
+    }
+};
+
+template<typename C>
+Detail::unique_ptr<ITestInvoker> makeTestInvokerFixture( void ( C::*testAsMethod )() const ) {
+    return Detail::make_unique<TestInvokerFixture<C>>( testAsMethod );
+}
+
 struct NameAndTags {
     constexpr NameAndTags( StringRef name_ = StringRef(),
                            StringRef tags_ = StringRef() ) noexcept:
@@ -6099,6 +6113,26 @@ static int catchInternalSectionHint = 0;
     #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
         INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
 
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( TestName, ClassName, ... )      \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                             \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                              \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                      \
+        namespace {                                                           \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS( ClassName ) {     \
+                void test() const;                                            \
+            };                                                                \
+            const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+                Catch::makeTestInvokerFixture( &TestName::test ),                    \
+                CATCH_INTERNAL_LINEINFO,                                      \
+                #ClassName##_catch_sr,                                        \
+                Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */             \
+        }                                                                     \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                              \
+        void TestName::test() const
+    #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( ClassName, ... )    \
+        INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
+
 
     ///////////////////////////////////////////////////////////////////////////////
     #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
@@ -6156,6 +6190,7 @@ static int catchInternalSectionHint = 0;
   #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
   #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
   #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
   #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
   #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
   #define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
@@ -6210,6 +6245,7 @@ static int catchInternalSectionHint = 0;
   #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
   #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
   #define CATCH_METHOD_AS_TEST_CASE( method, ... )
+  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
   #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
   #define CATCH_SECTION( ... )
   #define CATCH_DYNAMIC_SECTION( ... )
@@ -6255,6 +6291,7 @@ static int catchInternalSectionHint = 0;
   #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
   #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
   #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
   #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
   #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
   #define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
@@ -6308,6 +6345,7 @@ static int catchInternalSectionHint = 0;
   #define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
   #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
   #define METHOD_AS_TEST_CASE( method, ... )
+  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
   #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
   #define SECTION( ... )
   #define DYNAMIC_SECTION( ... )
@@ -7101,6 +7139,14 @@ namespace Catch {
         TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
             m_info(info), m_invoker(invoker) {}
 
+        void prepareTestCase() const {
+            m_invoker->prepareTestCase();
+        }
+
+        void tearDownTestCase() const {
+            m_invoker->tearDownTestCase();
+        }
+
         void invoke() const {
             m_invoker->invoke();
         }
@@ -7269,8 +7315,8 @@ namespace Catch {
 #define CATCH_VERSION_MACROS_HPP_INCLUDED
 
 #define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 5
-#define CATCH_VERSION_PATCH 4
+#define CATCH_VERSION_MINOR 7
+#define CATCH_VERSION_PATCH 0
 
 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED
 
@@ -7949,7 +7995,10 @@ namespace Catch {
 //       it, and it provides an escape hatch to the users who need it.
 #if defined( __SIZEOF_INT128__ )
 #    define CATCH_CONFIG_INTERNAL_UINT128
-#elif defined( _MSC_VER ) && ( defined( _WIN64 ) || defined( _M_ARM64 ) )
+// Unlike GCC, MSVC does not polyfill umul as mulh + mul pair on ARM machines.
+// Currently we do not bother doing this ourselves, but we could if it became
+// important for perf.
+#elif defined( _MSC_VER ) && defined( _M_X64 )
 #    define CATCH_CONFIG_INTERNAL_MSVC_UMUL128
 #endif
 
@@ -7964,7 +8013,6 @@ namespace Catch {
     !defined( CATCH_CONFIG_MSVC_UMUL128 )
 #    define CATCH_CONFIG_MSVC_UMUL128
 #    include <intrin.h>
-#    pragma intrinsic( _umul128 )
 #endif
 
 
@@ -10029,106 +10077,67 @@ namespace Catch {
 #define CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
 
 
-#include <cstdio>
-#include <iosfwd>
+#include <cassert>
 #include <string>
 
 namespace Catch {
 
-    class RedirectedStream {
-        std::ostream& m_originalStream;
-        std::ostream& m_redirectionStream;
-        std::streambuf* m_prevBuf;
-
-    public:
-        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
-        ~RedirectedStream();
-    };
-
-    class RedirectedStdOut {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cout;
-    public:
-        RedirectedStdOut();
-        auto str() const -> std::string;
-    };
-
-    // StdErr has two constituent streams in C++, std::cerr and std::clog
-    // This means that we need to redirect 2 streams into 1 to keep proper
-    // order of writes
-    class RedirectedStdErr {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cerr;
-        RedirectedStream m_clog;
-    public:
-        RedirectedStdErr();
-        auto str() const -> std::string;
-    };
-
-    class RedirectedStreams {
-    public:
-        RedirectedStreams(RedirectedStreams const&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
-        RedirectedStreams(RedirectedStreams&&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
-
-        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
-        ~RedirectedStreams();
-    private:
-        std::string& m_redirectedCout;
-        std::string& m_redirectedCerr;
-        RedirectedStdOut m_redirectedStdOut;
-        RedirectedStdErr m_redirectedStdErr;
-    };
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-    // Windows's implementation of std::tmpfile is terrible (it tries
-    // to create a file inside system folder, thus requiring elevated
-    // privileges for the binary), so we have to use tmpnam(_s) and
-    // create the file ourselves there.
-    class TempFile {
-    public:
-        TempFile(TempFile const&) = delete;
-        TempFile& operator=(TempFile const&) = delete;
-        TempFile(TempFile&&) = delete;
-        TempFile& operator=(TempFile&&) = delete;
-
-        TempFile();
-        ~TempFile();
-
-        std::FILE* getFile();
-        std::string getContents();
-
-    private:
-        std::FILE* m_file = nullptr;
-    #if defined(_MSC_VER)
-        char m_buffer[L_tmpnam] = { 0 };
-    #endif
-    };
-
-
     class OutputRedirect {
+        bool m_redirectActive = false;
+        virtual void activateImpl() = 0;
+        virtual void deactivateImpl() = 0;
     public:
-        OutputRedirect(OutputRedirect const&) = delete;
-        OutputRedirect& operator=(OutputRedirect const&) = delete;
-        OutputRedirect(OutputRedirect&&) = delete;
-        OutputRedirect& operator=(OutputRedirect&&) = delete;
+        enum Kind {
+            //! No redirect (noop implementation)
+            None,
+            //! Redirect std::cout/std::cerr/std::clog streams internally
+            Streams,
+            //! Redirect the stdout/stderr file descriptors into files
+            FileDescriptors,
+        };
 
+        virtual ~OutputRedirect(); // = default;
 
-        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
-        ~OutputRedirect();
-
-    private:
-        int m_originalStdout = -1;
-        int m_originalStderr = -1;
-        TempFile m_stdoutFile;
-        TempFile m_stderrFile;
-        std::string& m_stdoutDest;
-        std::string& m_stderrDest;
+        // TODO: Do we want to check that redirect is not active before retrieving the output?
+        virtual std::string getStdout() = 0;
+        virtual std::string getStderr() = 0;
+        virtual void clearBuffers() = 0;
+        bool isActive() const { return m_redirectActive; }
+        void activate() {
+            assert( !m_redirectActive && "redirect is already active" );
+            activateImpl();
+            m_redirectActive = true;
+        }
+        void deactivate() {
+            assert( m_redirectActive && "redirect is not active" );
+            deactivateImpl();
+            m_redirectActive = false;
+        }
     };
 
-#endif
+    bool isRedirectAvailable( OutputRedirect::Kind kind);
+    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual );
+
+    class RedirectGuard {
+        OutputRedirect* m_redirect;
+        bool m_activate;
+        bool m_previouslyActive;
+        bool m_moved = false;
+
+    public:
+        RedirectGuard( bool activate, OutputRedirect& redirectImpl );
+        ~RedirectGuard() noexcept( false );
+
+        RedirectGuard( RedirectGuard const& ) = delete;
+        RedirectGuard& operator=( RedirectGuard const& ) = delete;
+
+        // C++14 needs move-able guards to return them from functions
+        RedirectGuard( RedirectGuard&& rhs ) noexcept;
+        RedirectGuard& operator=( RedirectGuard&& rhs ) noexcept;
+    };
+
+    RedirectGuard scopedActivate( OutputRedirect& redirectImpl );
+    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl );
 
 } // end namespace Catch
 
@@ -10451,6 +10460,7 @@ namespace Catch {
     class IConfig;
     class IEventListener;
     using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+    class OutputRedirect;
 
     ///////////////////////////////////////////////////////////////////////////
 
@@ -10537,7 +10547,7 @@ namespace Catch {
 
     private:
 
-        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
+        void runCurrentTest();
         void invokeActiveTestCase();
 
         void resetAssertionInfo();
@@ -10570,6 +10580,7 @@ namespace Catch {
         std::vector<SectionEndInfo> m_unfinishedSections;
         std::vector<ITracker*> m_activeSections;
         TrackerContext m_trackerContext;
+        Detail::unique_ptr<OutputRedirect> m_outputRedirect;
         FatalConditionHandler m_fatalConditionhandler;
         bool m_lastAssertionPassed = false;
         bool m_shouldReportUnexpected = true;
@@ -10944,6 +10955,107 @@ namespace Catch {
 
         class Columns;
 
+        /**
+         * Abstraction for a string with ansi escape sequences that
+         * automatically skips over escapes when iterating. Only graphical
+         * escape sequences are considered.
+         *
+         * Internal representation:
+         * An escape sequence looks like \033[39;49m
+         * We need bidirectional iteration and the unbound length of escape
+         * sequences poses a problem for operator-- To make this work we'll
+         * replace the last `m` with a 0xff (this is a codepoint that won't have
+         * any utf-8 meaning).
+         */
+        class AnsiSkippingString {
+            std::string m_string;
+            std::size_t m_size = 0;
+
+            // perform 0xff replacement and calculate m_size
+            void preprocessString();
+
+        public:
+            class const_iterator;
+            using iterator = const_iterator;
+            // note: must be u-suffixed or this will cause a "truncation of
+            // constant value" warning on MSVC
+            static constexpr char sentinel = static_cast<char>( 0xffu );
+
+            explicit AnsiSkippingString( std::string const& text );
+            explicit AnsiSkippingString( std::string&& text );
+
+            const_iterator begin() const;
+            const_iterator end() const;
+
+            size_t size() const { return m_size; }
+
+            std::string substring( const_iterator begin,
+                                   const_iterator end ) const;
+        };
+
+        class AnsiSkippingString::const_iterator {
+            friend AnsiSkippingString;
+            struct EndTag {};
+
+            const std::string* m_string;
+            std::string::const_iterator m_it;
+
+            explicit const_iterator( const std::string& string, EndTag ):
+                m_string( &string ), m_it( string.end() ) {}
+
+            void tryParseAnsiEscapes();
+            void advance();
+            void unadvance();
+
+        public:
+            using difference_type = std::ptrdiff_t;
+            using value_type = char;
+            using pointer = value_type*;
+            using reference = value_type&;
+            using iterator_category = std::bidirectional_iterator_tag;
+
+            explicit const_iterator( const std::string& string ):
+                m_string( &string ), m_it( string.begin() ) {
+                tryParseAnsiEscapes();
+            }
+
+            char operator*() const { return *m_it; }
+
+            const_iterator& operator++() {
+                advance();
+                return *this;
+            }
+            const_iterator operator++( int ) {
+                iterator prev( *this );
+                operator++();
+                return prev;
+            }
+            const_iterator& operator--() {
+                unadvance();
+                return *this;
+            }
+            const_iterator operator--( int ) {
+                iterator prev( *this );
+                operator--();
+                return prev;
+            }
+
+            bool operator==( const_iterator const& other ) const {
+                return m_it == other.m_it;
+            }
+            bool operator!=( const_iterator const& other ) const {
+                return !operator==( other );
+            }
+            bool operator<=( const_iterator const& other ) const {
+                return m_it <= other.m_it;
+            }
+
+            const_iterator oneBefore() const {
+                auto it = *this;
+                return --it;
+            }
+        };
+
         /**
          * Represents a column of text with specific width and indentation
          *
@@ -10953,10 +11065,11 @@ namespace Catch {
          */
         class Column {
             // String to be written out
-            std::string m_string;
+            AnsiSkippingString m_string;
             // Width of the column for linebreaking
             size_t m_width = CATCH_CONFIG_CONSOLE_WIDTH - 1;
-            // Indentation of other lines (including first if initial indent is unset)
+            // Indentation of other lines (including first if initial indent is
+            // unset)
             size_t m_indent = 0;
             // Indentation of the first line
             size_t m_initialIndent = std::string::npos;
@@ -10971,16 +11084,19 @@ namespace Catch {
 
                 Column const& m_column;
                 // Where does the current line start?
-                size_t m_lineStart = 0;
+                AnsiSkippingString::const_iterator m_lineStart;
                 // How long should the current line be?
-                size_t m_lineLength = 0;
+                AnsiSkippingString::const_iterator m_lineEnd;
                 // How far have we checked the string to iterate?
-                size_t m_parsedTo = 0;
+                AnsiSkippingString::const_iterator m_parsedTo;
                 // Should a '-' be appended to the line?
                 bool m_addHyphen = false;
 
                 const_iterator( Column const& column, EndTag ):
-                    m_column( column ), m_lineStart( m_column.m_string.size() ) {}
+                    m_column( column ),
+                    m_lineStart( m_column.m_string.end() ),
+                    m_lineEnd( column.m_string.end() ),
+                    m_parsedTo( column.m_string.end() ) {}
 
                 // Calculates the length of the current line
                 void calcLength();
@@ -10990,8 +11106,9 @@ namespace Catch {
 
                 // Creates an indented and (optionally) suffixed string from
                 // current iterator position, indentation and length.
-                std::string addIndentAndSuffix( size_t position,
-                                                size_t length ) const;
+                std::string addIndentAndSuffix(
+                    AnsiSkippingString::const_iterator start,
+                    AnsiSkippingString::const_iterator end ) const;
 
             public:
                 using difference_type = std::ptrdiff_t;
@@ -11008,7 +11125,8 @@ namespace Catch {
                 const_iterator operator++( int );
 
                 bool operator==( const_iterator const& other ) const {
-                    return m_lineStart == other.m_lineStart && &m_column == &other.m_column;
+                    return m_lineStart == other.m_lineStart &&
+                           &m_column == &other.m_column;
                 }
                 bool operator!=( const_iterator const& other ) const {
                     return !operator==( other );
@@ -11018,7 +11136,7 @@ namespace Catch {
 
             explicit Column( std::string const& text ): m_string( text ) {}
             explicit Column( std::string&& text ):
-                m_string( CATCH_MOVE(text)) {}
+                m_string( CATCH_MOVE( text ) ) {}
 
             Column& width( size_t newWidth ) & {
                 assert( newWidth > 0 );
@@ -11049,7 +11167,9 @@ namespace Catch {
 
             size_t width() const { return m_width; }
             const_iterator begin() const { return const_iterator( *this ); }
-            const_iterator end() const { return { *this, const_iterator::EndTag{} }; }
+            const_iterator end() const {
+                return { *this, const_iterator::EndTag{} };
+            }
 
             friend std::ostream& operator<<( std::ostream& os,
                                              Column const& col );
@@ -11320,6 +11440,16 @@ namespace Catch {
 
 namespace Catch {
 
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wsign-compare"
+#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#elif defined __GNUC__
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wsign-compare"
+#    pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
     template<typename ArgT, typename MatcherT>
     class MatchExpr : public ITransientExpression {
         ArgT && m_arg;
@@ -11338,6 +11468,13 @@ namespace Catch {
         }
     };
 
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#elif defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+
+
     namespace Matchers {
         template <typename ArgT>
         class MatcherBase;

meson.build

@@ -8,7 +8,7 @@
 project(
   'catch2',
   'cpp',
-  version: '3.5.4', # CML version placeholder, don't delete
+  version: '3.7.0', # CML version placeholder, don't delete
   license: 'BSL-1.0',
   meson_version: '>=0.54.1',
 )

src/CMakeLists.txt

@@ -48,6 +48,7 @@ set(IMPL_HEADERS
   ${SOURCES_DIR}/catch_approx.hpp
   ${SOURCES_DIR}/catch_assertion_info.hpp
   ${SOURCES_DIR}/catch_assertion_result.hpp
+  ${SOURCES_DIR}/catch_case_sensitive.hpp
   ${SOURCES_DIR}/catch_config.hpp
   ${SOURCES_DIR}/catch_get_random_seed.hpp
   ${SOURCES_DIR}/catch_message.hpp
@@ -67,13 +68,13 @@ set(IMPL_HEADERS
   ${SOURCES_DIR}/catch_version_macros.hpp
   ${SOURCES_DIR}/internal/catch_assertion_handler.hpp
   ${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.hpp
-  ${SOURCES_DIR}/internal/catch_case_sensitive.hpp
   ${SOURCES_DIR}/internal/catch_clara.hpp
   ${SOURCES_DIR}/internal/catch_commandline.hpp
   ${SOURCES_DIR}/internal/catch_compare_traits.hpp
   ${SOURCES_DIR}/internal/catch_compiler_capabilities.hpp
   ${SOURCES_DIR}/internal/catch_config_android_logwrite.hpp
   ${SOURCES_DIR}/internal/catch_config_counter.hpp
+  ${SOURCES_DIR}/internal/catch_config_prefix_messages.hpp
   ${SOURCES_DIR}/internal/catch_config_static_analysis_support.hpp
   ${SOURCES_DIR}/internal/catch_config_uncaught_exceptions.hpp
   ${SOURCES_DIR}/internal/catch_config_wchar.hpp
@@ -194,7 +195,6 @@ set(IMPL_SOURCES
   ${SOURCES_DIR}/internal/catch_random_seed_generation.cpp
   ${SOURCES_DIR}/internal/catch_reporter_registry.cpp
   ${SOURCES_DIR}/internal/catch_reporter_spec_parser.cpp
-  ${SOURCES_DIR}/internal/catch_result_type.cpp
   ${SOURCES_DIR}/internal/catch_reusable_string_stream.cpp
   ${SOURCES_DIR}/internal/catch_run_context.cpp
   ${SOURCES_DIR}/internal/catch_section.cpp

src/catch2/benchmark/catch_benchmark.hpp

@@ -45,12 +45,12 @@ namespace Catch {
                 : fun(CATCH_MOVE(func)), name(CATCH_MOVE(benchmarkName)) {}
 
             template <typename Clock>
-            ExecutionPlan prepare(const IConfig &cfg, Environment env) const {
+            ExecutionPlan prepare(const IConfig &cfg, Environment env) {
                 auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
                 auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
                 auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<IDuration>(run_time), 1, fun);
                 int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), CATCH_MOVE(fun), std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
             }
 
             template <typename Clock = default_clock>

src/catch2/benchmark/catch_outlier_classification.hpp

@@ -19,7 +19,7 @@ namespace Catch {
             int high_mild = 0;      // 1.5 to 3 times IQR above Q3
             int high_severe = 0;    // more than 3 times IQR above Q3
 
-            int total() const {
+            constexpr int total() const {
                 return low_severe + low_mild + high_mild + high_severe;
             }
         };

src/catch2/benchmark/detail/catch_benchmark_function.cpp

@@ -11,7 +11,13 @@
 namespace Catch {
     namespace Benchmark {
         namespace Detail {
+            struct do_nothing {
+                void operator()() const {}
+            };
+
             BenchmarkFunction::callable::~callable() = default;
+            BenchmarkFunction::BenchmarkFunction():
+                f( new model<do_nothing>{ {} } ){}
         } // namespace Detail
     } // namespace Benchmark
 } // namespace Catch

src/catch2/benchmark/detail/catch_benchmark_function.hpp

@@ -35,22 +35,17 @@ namespace Catch {
             private:
                 struct callable {
                     virtual void call(Chronometer meter) const = 0;
-                    virtual Catch::Detail::unique_ptr<callable> clone() const = 0;
                     virtual ~callable(); // = default;
 
                     callable() = default;
-                    callable(callable const&) = default;
-                    callable& operator=(callable const&) = default;
+                    callable(callable&&) = default;
+                    callable& operator=(callable&&) = default;
                 };
                 template <typename Fun>
                 struct model : public callable {
                     model(Fun&& fun_) : fun(CATCH_MOVE(fun_)) {}
                     model(Fun const& fun_) : fun(fun_) {}
 
-                    Catch::Detail::unique_ptr<callable> clone() const override {
-                        return Catch::Detail::make_unique<model<Fun>>( *this );
-                    }
-
                     void call(Chronometer meter) const override {
                         call(meter, is_callable<Fun(Chronometer)>());
                     }
@@ -64,14 +59,8 @@ namespace Catch {
                     Fun fun;
                 };
 
-                struct do_nothing { void operator()() const {} };
-
-                template <typename T>
-                BenchmarkFunction(model<T>* c) : f(c) {}
-
             public:
-                BenchmarkFunction()
-                    : f(new model<do_nothing>{ {} }) {}
+                BenchmarkFunction();
 
                 template <typename Fun,
                     std::enable_if_t<!is_related<Fun, BenchmarkFunction>::value, int> = 0>
@@ -81,20 +70,12 @@ namespace Catch {
                 BenchmarkFunction( BenchmarkFunction&& that ) noexcept:
                     f( CATCH_MOVE( that.f ) ) {}
 
-                BenchmarkFunction(BenchmarkFunction const& that)
-                    : f(that.f->clone()) {}
-
                 BenchmarkFunction&
                 operator=( BenchmarkFunction&& that ) noexcept {
                     f = CATCH_MOVE( that.f );
                     return *this;
                 }
 
-                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
-                    f = that.f->clone();
-                    return *this;
-                }
-
                 void operator()(Chronometer meter) const { f->call(meter); }
 
             private:

src/catch2/benchmark/detail/catch_estimate_clock.hpp

@@ -27,15 +27,17 @@ namespace Catch {
         namespace Detail {
             template <typename Clock>
             std::vector<double> resolution(int k) {
-                std::vector<TimePoint<Clock>> times;
-                times.reserve(static_cast<size_t>(k + 1));
-                for ( int i = 0; i < k + 1; ++i ) {
-                    times.push_back( Clock::now() );
+                const size_t points = static_cast<size_t>( k + 1 );
+                // To avoid overhead from the branch inside vector::push_back,
+                // we allocate them all and then overwrite.
+                std::vector<TimePoint<Clock>> times(points);
+                for ( auto& time : times ) {
+                    time = Clock::now();
                 }
 
                 std::vector<double> deltas;
                 deltas.reserve(static_cast<size_t>(k));
-                for ( size_t idx = 1; idx < times.size(); ++idx ) {
+                for ( size_t idx = 1; idx < points; ++idx ) {
                     deltas.push_back( static_cast<double>(
                         ( times[idx] - times[idx - 1] ).count() ) );
                 }

src/catch2/benchmark/detail/catch_measure.hpp

@@ -20,7 +20,7 @@ namespace Catch {
             template <typename Clock, typename Fun, typename... Args>
             TimingOf<Fun, Args...> measure(Fun&& fun, Args&&... args) {
                 auto start = Clock::now();
-                auto&& r = Detail::complete_invoke(fun, CATCH_FORWARD(args)...);
+                auto&& r = Detail::complete_invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
                 auto end = Clock::now();
                 auto delta = end - start;
                 return { delta, CATCH_FORWARD(r), 1 };

src/catch2/catch_all.hpp

@@ -26,6 +26,7 @@
 #include <catch2/catch_approx.hpp>
 #include <catch2/catch_assertion_info.hpp>
 #include <catch2/catch_assertion_result.hpp>
+#include <catch2/catch_case_sensitive.hpp>
 #include <catch2/catch_config.hpp>
 #include <catch2/catch_get_random_seed.hpp>
 #include <catch2/catch_message.hpp>
@@ -47,7 +48,6 @@
 #include <catch2/interfaces/catch_interfaces_all.hpp>
 #include <catch2/internal/catch_assertion_handler.hpp>
 #include <catch2/internal/catch_case_insensitive_comparisons.hpp>
-#include <catch2/internal/catch_case_sensitive.hpp>
 #include <catch2/internal/catch_clara.hpp>
 #include <catch2/internal/catch_commandline.hpp>
 #include <catch2/internal/catch_compare_traits.hpp>

src/catch2/catch_assertion_result.cpp

@@ -11,7 +11,7 @@
 
 namespace Catch {
 
-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const& _lazyExpression):
         lazyExpression(_lazyExpression),
         resultType(_resultType) {}
 

src/catch2/catch_message.cpp

@@ -91,6 +91,7 @@ namespace Catch {
                     m_messages.back().message += " := ";
                     start = pos;
                 }
+                break;
             default:; // noop
             }
         }

src/catch2/catch_message.hpp

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

src/catch2/catch_test_case_info.cpp

@@ -22,26 +22,26 @@ namespace Catch {
         static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type),
                       "The size of the TestCaseProperties is different from the assumed size");
 
-        TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
+        constexpr TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
             return static_cast<TestCaseProperties>(
                 static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
             );
         }
 
-        TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
+        constexpr TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
             lhs = static_cast<TestCaseProperties>(
                 static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
             );
             return lhs;
         }
 
-        TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
+        constexpr TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
             return static_cast<TestCaseProperties>(
                 static_cast<TCP_underlying_type>(lhs) & static_cast<TCP_underlying_type>(rhs)
             );
         }
 
-        bool applies(TestCaseProperties tcp) {
+        constexpr bool applies(TestCaseProperties tcp) {
             static_assert(static_cast<TCP_underlying_type>(TestCaseProperties::None) == 0,
                           "TestCaseProperties::None must be equal to 0");
             return tcp != TestCaseProperties::None;
@@ -80,7 +80,7 @@ namespace Catch {
             return "Anonymous test case " + std::to_string(++counter);
         }
 
-        StringRef extractFilenamePart(StringRef filename) {
+        constexpr StringRef extractFilenamePart(StringRef filename) {
             size_t lastDot = filename.size();
             while (lastDot > 0 && filename[lastDot - 1] != '.') {
                 --lastDot;
@@ -98,7 +98,7 @@ namespace Catch {
         }
 
         // Returns the upper bound on size of extra tags ([#file]+[.])
-        size_t sizeOfExtraTags(StringRef filepath) {
+        constexpr size_t sizeOfExtraTags(StringRef filepath) {
             // [.] is 3, [#] is another 3
             const size_t extras = 3 + 3;
             return extractFilenamePart(filepath).size() + extras;
@@ -259,8 +259,4 @@ namespace Catch {
         return lhs.tags < rhs.tags;
     }
 
-    TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const {
-        return *m_info;
-    }
-
 } // end namespace Catch

src/catch2/catch_test_case_info.hpp

@@ -109,14 +109,24 @@ namespace Catch {
         TestCaseInfo* m_info;
         ITestInvoker* m_invoker;
     public:
-        TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
+        constexpr TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
             m_info(info), m_invoker(invoker) {}
 
+        void prepareTestCase() const {
+            m_invoker->prepareTestCase();
+        }
+
+        void tearDownTestCase() const {
+            m_invoker->tearDownTestCase();
+        }
+
         void invoke() const {
             m_invoker->invoke();
         }
 
-        TestCaseInfo const& getTestCaseInfo() const;
+        constexpr TestCaseInfo const& getTestCaseInfo() const {
+            return *m_info;
+        }
     };
 
     Detail::unique_ptr<TestCaseInfo>

src/catch2/catch_test_macros.hpp

@@ -43,6 +43,7 @@
   #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
   #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
   #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
   #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
   #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
   #define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
@@ -97,6 +98,7 @@
   #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
   #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
   #define CATCH_METHOD_AS_TEST_CASE( method, ... )
+  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
   #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
   #define CATCH_SECTION( ... )
   #define CATCH_DYNAMIC_SECTION( ... )
@@ -142,6 +144,7 @@
   #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
   #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
   #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
   #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
   #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
   #define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
@@ -195,6 +198,7 @@
   #define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
   #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
   #define METHOD_AS_TEST_CASE( method, ... )
+  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
   #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
   #define SECTION( ... )
   #define DYNAMIC_SECTION( ... )

src/catch2/catch_timer.cpp

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

src/catch2/catch_tostring.cpp

@@ -239,13 +239,13 @@ std::string StringMaker<unsigned char>::convert(unsigned char value) {
     return ::Catch::Detail::stringify(static_cast<char>(value));
 }
 
-int StringMaker<float>::precision = 5;
+int StringMaker<float>::precision = std::numeric_limits<float>::max_digits10;
 
 std::string StringMaker<float>::convert(float value) {
     return Detail::fpToString(value, precision) + 'f';
 }
 
-int StringMaker<double>::precision = 10;
+int StringMaker<double>::precision = std::numeric_limits<double>::max_digits10;
 
 std::string StringMaker<double>::convert(double value) {
     return Detail::fpToString(value, precision);

src/catch2/catch_translate_exception.hpp

@@ -25,7 +25,7 @@ namespace Catch {
         class ExceptionTranslator : public IExceptionTranslator {
         public:
 
-            ExceptionTranslator( std::string(*translateFunction)( T const& ) )
+            constexpr ExceptionTranslator( std::string(*translateFunction)( T const& ) )
             : m_translateFunction( translateFunction )
             {}
 

src/catch2/catch_version.cpp

@@ -36,7 +36,7 @@ namespace Catch {
     }
 
     Version const& libraryVersion() {
-        static Version version( 3, 5, 4, "", 0 );
+        static Version version( 3, 7, 0, "", 0 );
         return version;
     }
 

src/catch2/catch_version_macros.hpp

@@ -9,7 +9,7 @@
 #define CATCH_VERSION_MACROS_HPP_INCLUDED
 
 #define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 5
-#define CATCH_VERSION_PATCH 4
+#define CATCH_VERSION_MINOR 7
+#define CATCH_VERSION_PATCH 0
 
 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED

src/catch2/interfaces/catch_interfaces_capture.hpp

@@ -9,7 +9,6 @@
 #define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
 
 #include <string>
-#include <chrono>
 
 #include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_result_type.hpp>
@@ -77,7 +76,7 @@ namespace Catch {
         virtual void handleMessage
                 (   AssertionInfo const& info,
                     ResultWas::OfType resultType,
-                    StringRef message,
+                    std::string&& message,
                     AssertionReaction& reaction ) = 0;
         virtual void handleUnexpectedExceptionNotThrown
                 (   AssertionInfo const& info,

src/catch2/interfaces/catch_interfaces_test_invoker.hpp

@@ -12,6 +12,8 @@ namespace Catch {
 
     class ITestInvoker {
     public:
+        virtual void prepareTestCase();
+        virtual void tearDownTestCase();
         virtual void invoke() const = 0;
         virtual ~ITestInvoker(); // = default
     };

src/catch2/internal/catch_assertion_handler.cpp

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

src/catch2/internal/catch_assertion_handler.hpp

@@ -42,12 +42,12 @@ namespace Catch {
 
 
         template<typename T>
-        void handleExpr( ExprLhs<T> const& expr ) {
+        constexpr void handleExpr( ExprLhs<T> const& expr ) {
             handleExpr( expr.makeUnaryExpr() );
         }
         void handleExpr( ITransientExpression const& expr );
 
-        void handleMessage(ResultWas::OfType resultType, StringRef message);
+        void handleMessage(ResultWas::OfType resultType, std::string&& message);
 
         void handleExceptionThrownAsExpected();
         void handleUnexpectedExceptionNotThrown();

src/catch2/internal/catch_clara.cpp

@@ -76,7 +76,7 @@ namespace Catch {
                                 { TokenType::Argument,
                                   next.substr( delimiterPos + 1, next.size() ) } );
                         } else {
-                            if ( next[1] != '-' && next.size() > 2 ) {
+                            if ( next.size() > 1 && next[1] != '-' && next.size() > 2 ) {
                                 // Combined short args, e.g. "-ab" for "-a -b"
                                 for ( size_t i = 1; i < next.size(); ++i ) {
                                     m_tokenBuffer.push_back(

src/catch2/internal/catch_context.cpp

@@ -27,12 +27,6 @@ namespace Catch {
         return *Context::currentContext;
     }
 
-    void Context::setResultCapture( IResultCapture* resultCapture ) {
-        m_resultCapture = resultCapture;
-    }
-
-    void Context::setConfig( IConfig const* config ) { m_config = config; }
-
     SimplePcg32& sharedRng() {
         static SimplePcg32 s_rng;
         return s_rng;

src/catch2/internal/catch_context.hpp

@@ -26,10 +26,15 @@ namespace Catch {
         friend void cleanUpContext();
 
     public:
-        IResultCapture* getResultCapture() const { return m_resultCapture; }
-        IConfig const* getConfig() const { return m_config; }
-        void setResultCapture( IResultCapture* resultCapture );
-        void setConfig( IConfig const* config );
+        constexpr IResultCapture* getResultCapture() const {
+            return m_resultCapture;
+        }
+        constexpr IConfig const* getConfig() const { return m_config; }
+        constexpr void setResultCapture( IResultCapture* resultCapture ) {
+            m_resultCapture = resultCapture;
+        }
+        constexpr void setConfig( IConfig const* config ) { m_config = config; }
+
     };
 
     Context& getCurrentMutableContext();

src/catch2/internal/catch_decomposer.hpp

@@ -110,9 +110,11 @@
 #ifdef __clang__
 #  pragma clang diagnostic push
 #  pragma clang diagnostic ignored "-Wsign-compare"
+#  pragma clang diagnostic ignored "-Wnon-virtual-dtor"
 #elif defined __GNUC__
 #  pragma GCC diagnostic push
 #  pragma GCC diagnostic ignored "-Wsign-compare"
+#  pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
 #endif
 
 #if defined(CATCH_CPP20_OR_GREATER) && __has_include(<compare>)
@@ -155,6 +157,9 @@ namespace Catch {
         bool m_isBinaryExpression;
         bool m_result;
 
+    protected:
+        ~ITransientExpression() = default;
+
     public:
         constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
         constexpr auto getResult() const -> bool { return m_result; }
@@ -166,17 +171,13 @@ namespace Catch {
             m_result( result )
         {}
 
-        ITransientExpression() = default;
-        ITransientExpression(ITransientExpression const&) = default;
-        ITransientExpression& operator=(ITransientExpression const&) = default;
+        constexpr ITransientExpression( ITransientExpression const& ) = default;
+        constexpr ITransientExpression& operator=( ITransientExpression const& ) = default;
 
         friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) {
             expr.streamReconstructedExpression(out);
             return out;
         }
-
-    protected:
-        ~ITransientExpression() = default;
     };
 
     void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );

src/catch2/internal/catch_is_permutation.hpp

@@ -18,6 +18,7 @@ namespace Catch {
                   typename Sentinel,
                   typename T,
                   typename Comparator>
+        constexpr
         ForwardIter find_sentinel( ForwardIter start,
                                    Sentinel sentinel,
                                    T const& value,
@@ -33,6 +34,7 @@ namespace Catch {
                   typename Sentinel,
                   typename T,
                   typename Comparator>
+        constexpr
         std::ptrdiff_t count_sentinel( ForwardIter start,
                                        Sentinel sentinel,
                                        T const& value,
@@ -46,6 +48,7 @@ namespace Catch {
         }
 
         template <typename ForwardIter, typename Sentinel>
+        constexpr
         std::enable_if_t<!std::is_same<ForwardIter, Sentinel>::value,
                          std::ptrdiff_t>
         sentinel_distance( ForwardIter iter, const Sentinel sentinel ) {
@@ -58,8 +61,8 @@ namespace Catch {
         }
 
         template <typename ForwardIter>
-        std::ptrdiff_t sentinel_distance( ForwardIter first,
-                                          ForwardIter last ) {
+        constexpr std::ptrdiff_t sentinel_distance( ForwardIter first,
+                                                    ForwardIter last ) {
             return std::distance( first, last );
         }
 
@@ -68,11 +71,11 @@ namespace Catch {
                   typename ForwardIter2,
                   typename Sentinel2,
                   typename Comparator>
-        bool check_element_counts( ForwardIter1 first_1,
-                                   const Sentinel1 end_1,
-                                   ForwardIter2 first_2,
-                                   const Sentinel2 end_2,
-                                   Comparator cmp ) {
+        constexpr bool check_element_counts( ForwardIter1 first_1,
+                                             const Sentinel1 end_1,
+                                             ForwardIter2 first_2,
+                                             const Sentinel2 end_2,
+                                             Comparator cmp ) {
             auto cursor = first_1;
             while ( cursor != end_1 ) {
                 if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
@@ -102,11 +105,11 @@ namespace Catch {
                   typename ForwardIter2,
                   typename Sentinel2,
                   typename Comparator>
-        bool is_permutation( ForwardIter1 first_1,
-                             const Sentinel1 end_1,
-                             ForwardIter2 first_2,
-                             const Sentinel2 end_2,
-                             Comparator cmp ) {
+        constexpr bool is_permutation( ForwardIter1 first_1,
+                                       const Sentinel1 end_1,
+                                       ForwardIter2 first_2,
+                                       const Sentinel2 end_2,
+                                       Comparator cmp ) {
             // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
             // TODO: Comparator has to be "both sides", e.g. a == b => b == a
             // This skips shared prefix of the two ranges

src/catch2/internal/catch_lazy_expr.hpp

@@ -22,13 +22,13 @@ namespace Catch {
         ITransientExpression const* m_transientExpression = nullptr;
         bool m_isNegated;
     public:
-        LazyExpression( bool isNegated ):
+        constexpr LazyExpression( bool isNegated ):
             m_isNegated(isNegated)
         {}
-        LazyExpression(LazyExpression const& other) = default;
+        constexpr LazyExpression(LazyExpression const& other) = default;
         LazyExpression& operator = ( LazyExpression const& ) = delete;
 
-        explicit operator bool() const {
+        constexpr explicit operator bool() const {
             return m_transientExpression != nullptr;
         }
 

src/catch2/internal/catch_output_redirect.cpp

@@ -5,142 +5,523 @@
 //        https://www.boost.org/LICENSE_1_0.txt)
 
 // SPDX-License-Identifier: BSL-1.0
-#include <catch2/internal/catch_output_redirect.hpp>
+#include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_enforce.hpp>
+#include <catch2/internal/catch_output_redirect.hpp>
+#include <catch2/internal/catch_platform.hpp>
+#include <catch2/internal/catch_reusable_string_stream.hpp>
 #include <catch2/internal/catch_stdstreams.hpp>
 
 #include <cstdio>
 #include <cstring>
+#include <iosfwd>
 #include <sstream>
 
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #include <io.h>      //_dup and _dup2
-    #define dup _dup
-    #define dup2 _dup2
-    #define fileno _fileno
-    #else
-    #include <unistd.h>  // dup and dup2
-    #endif
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <thread>
+#include <mutex>
 #endif
 
+#if defined( CATCH_CONFIG_NEW_CAPTURE ) || defined(CATCH_CONFIG_USE_ASYNC)
+#    if defined( _MSC_VER )
+#        include <io.h> //_dup and _dup2
+#        include <fcntl.h> // _O_BINARY
+#        define dup _dup
+#        define dup2 _dup2
+#        define fileno _fileno
+#        define close _close
+#    else
+#        include <unistd.h> // dup and dup2
+#    endif
+#endif
 
 namespace Catch {
 
-    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
-    :   m_originalStream( originalStream ),
-        m_redirectionStream( redirectionStream ),
-        m_prevBuf( m_originalStream.rdbuf() )
-    {
-        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
-    }
+    namespace {
+        //! A no-op implementation, used if no reporter wants output
+        //! redirection.
+        class NoopRedirect : public OutputRedirect {
+            void activateImpl() override {}
+            void deactivateImpl() override {}
+            std::string getStdout() override { return {}; }
+            std::string getStderr() override { return {}; }
+            void clearBuffers() override {}
+        };
 
-    RedirectedStream::~RedirectedStream() {
-        m_originalStream.rdbuf( m_prevBuf );
-    }
+        /**
+         * Redirects specific stream's rdbuf with another's.
+         *
+         * Redirection can be stopped and started on-demand, assumes
+         * that the underlying stream's rdbuf aren't changed by other
+         * users.
+         */
+        class RedirectedStream {
+            std::ostream& m_originalStream;
+            std::ostream& m_redirectionStream;
+            std::streambuf* m_prevBuf;
 
-    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
-    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
+        public:
+            RedirectedStream( std::ostream& originalStream,
+                                 std::ostream& redirectionStream ):
+                m_originalStream( originalStream ),
+                m_redirectionStream( redirectionStream ),
+                m_prevBuf( m_originalStream.rdbuf() ) {}
 
-    RedirectedStdErr::RedirectedStdErr()
-    :   m_cerr( Catch::cerr(), m_rss.get() ),
-        m_clog( Catch::clog(), m_rss.get() )
-    {}
-    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
-    :   m_redirectedCout(redirectedCout),
-        m_redirectedCerr(redirectedCerr)
-    {}
-
-    RedirectedStreams::~RedirectedStreams() {
-        m_redirectedCout += m_redirectedStdOut.str();
-        m_redirectedCerr += m_redirectedStdErr.str();
-    }
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-#if defined(_MSC_VER)
-    TempFile::TempFile() {
-        if (tmpnam_s(m_buffer)) {
-            CATCH_RUNTIME_ERROR("Could not get a temp filename");
-        }
-        if (fopen_s(&m_file, m_buffer, "w+")) {
-            char buffer[100];
-            if (strerror_s(buffer, errno)) {
-                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
+            void startRedirect() {
+                m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
             }
-            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
-        }
-    }
-#else
-    TempFile::TempFile() {
-        m_file = std::tmpfile();
-        if (!m_file) {
-            CATCH_RUNTIME_ERROR("Could not create a temp file.");
-        }
-    }
+            void stopRedirect() { m_originalStream.rdbuf( m_prevBuf ); }
+        };
 
-#endif
+        /**
+         * Redirects the `std::cout`, `std::cerr`, `std::clog` streams,
+         * but does not touch the actual `stdout`/`stderr` file descriptors.
+         */
+        class StreamRedirect : public OutputRedirect {
+            ReusableStringStream m_redirectedOut, m_redirectedErr;
+            RedirectedStream m_cout, m_cerr, m_clog;
 
-    TempFile::~TempFile() {
-         // TBD: What to do about errors here?
-         std::fclose(m_file);
-         // We manually create the file on Windows only, on Linux
-         // it will be autodeleted
-#if defined(_MSC_VER)
-         std::remove(m_buffer);
-#endif
-    }
+        public:
+            StreamRedirect():
+                m_cout( Catch::cout(), m_redirectedOut.get() ),
+                m_cerr( Catch::cerr(), m_redirectedErr.get() ),
+                m_clog( Catch::clog(), m_redirectedErr.get() ) {}
 
+            void activateImpl() override {
+                m_cout.startRedirect();
+                m_cerr.startRedirect();
+                m_clog.startRedirect();
+            }
+            void deactivateImpl() override {
+                m_cout.stopRedirect();
+                m_cerr.stopRedirect();
+                m_clog.stopRedirect();
+            }
+            std::string getStdout() override { return m_redirectedOut.str(); }
+            std::string getStderr() override { return m_redirectedErr.str(); }
+            void clearBuffers() override {
+                m_redirectedOut.str( "" );
+                m_redirectedErr.str( "" );
+            }
+        };
 
-    FILE* TempFile::getFile() {
-        return m_file;
-    }
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
 
-    std::string TempFile::getContents() {
-        std::stringstream sstr;
-        char buffer[100] = {};
-        std::rewind(m_file);
-        while (std::fgets(buffer, sizeof(buffer), m_file)) {
-            sstr << buffer;
-        }
-        return sstr.str();
-    }
+        // Windows's implementation of std::tmpfile is terrible (it tries
+        // to create a file inside system folder, thus requiring elevated
+        // privileges for the binary), so we have to use tmpnam(_s) and
+        // create the file ourselves there.
+        class TempFile {
+        public:
+            TempFile( TempFile const& ) = delete;
+            TempFile& operator=( TempFile const& ) = delete;
+            TempFile( TempFile&& ) = delete;
+            TempFile& operator=( TempFile&& ) = delete;
 
-    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
-        m_originalStdout(dup(1)),
-        m_originalStderr(dup(2)),
-        m_stdoutDest(stdout_dest),
-        m_stderrDest(stderr_dest) {
-        dup2(fileno(m_stdoutFile.getFile()), 1);
-        dup2(fileno(m_stderrFile.getFile()), 2);
-    }
+#    if defined( _MSC_VER )
+            TempFile() {
+                if ( tmpnam_s( m_buffer ) ) {
+                    CATCH_RUNTIME_ERROR( "Could not get a temp filename" );
+                }
+                if ( fopen_s( &m_file, m_buffer, "wb+" ) ) {
+                    char buffer[100];
+                    if ( strerror_s( buffer, errno ) ) {
+                        CATCH_RUNTIME_ERROR(
+                            "Could not translate errno to a string" );
+                    }
+                    CATCH_RUNTIME_ERROR( "Could not open the temp file: '"
+                                         << m_buffer
+                                         << "' because: " << buffer );
+                }
+            }
+#    else
+            TempFile() {
+                m_file = std::tmpfile();
+                if ( !m_file ) {
+                    CATCH_RUNTIME_ERROR( "Could not create a temp file." );
+                }
+            }
+#    endif
 
-    OutputRedirect::~OutputRedirect() {
-        Catch::cout() << std::flush;
-        fflush(stdout);
-        // Since we support overriding these streams, we flush cerr
-        // even though std::cerr is unbuffered
-        Catch::cerr() << std::flush;
-        Catch::clog() << std::flush;
-        fflush(stderr);
+            ~TempFile() {
+                // TBD: What to do about errors here?
+                std::fclose( m_file );
+                // We manually create the file on Windows only, on Linux
+                // it will be autodeleted
+#    if defined( _MSC_VER )
+                std::remove( m_buffer );
+#    endif
+            }
 
-        dup2(m_originalStdout, 1);
-        dup2(m_originalStderr, 2);
+            std::FILE* getFile() { return m_file; }
+            std::string getContents() {
+                ReusableStringStream sstr;
+                constexpr long buffer_size = 100;
+                char buffer[buffer_size + 1] = {};
+                long current_pos = ftell( m_file );
+                CATCH_ENFORCE( current_pos >= 0,
+                               "ftell failed, errno: " << errno );
+                std::rewind( m_file );
+                while ( current_pos > 0 ) {
+                    auto read_characters =
+                        std::fread( buffer,
+                                    1,
+                                    std::min( buffer_size, current_pos ),
+                                    m_file );
+                    buffer[read_characters] = '\0';
+                    sstr << buffer;
+                    current_pos -= static_cast<long>( read_characters );
+                }
+                return sstr.str();
+            }
 
-        m_stdoutDest += m_stdoutFile.getContents();
-        m_stderrDest += m_stderrFile.getContents();
-    }
+            void clear() { std::rewind( m_file ); }
+
+        private:
+            std::FILE* m_file = nullptr;
+            char m_buffer[L_tmpnam] = { 0 };
+        };
+
+        /**
+         * Redirects the actual `stdout`/`stderr` file descriptors.
+         *
+         * Works by replacing the file descriptors numbered 1 and 2
+         * with an open temporary file.
+         */
+        class FileRedirect : public OutputRedirect {
+            TempFile m_outFile, m_errFile;
+            int m_originalOut = -1;
+            int m_originalErr = -1;
+
+            // Flushes cout/cerr/clog streams and stdout/stderr FDs
+            void flushEverything() {
+                Catch::cout() << std::flush;
+                fflush( stdout );
+                // Since we support overriding these streams, we flush cerr
+                // even though std::cerr is unbuffered
+                Catch::cerr() << std::flush;
+                Catch::clog() << std::flush;
+                fflush( stderr );
+            }
+
+        public:
+            FileRedirect():
+                m_originalOut( dup( fileno( stdout ) ) ),
+                m_originalErr( dup( fileno( stderr ) ) ) {
+                CATCH_ENFORCE( m_originalOut >= 0, "Could not dup stdout" );
+                CATCH_ENFORCE( m_originalErr >= 0, "Could not dup stderr" );
+            }
+
+            std::string getStdout() override { return m_outFile.getContents(); }
+            std::string getStderr() override { return m_errFile.getContents(); }
+            void clearBuffers() override {
+                m_outFile.clear();
+                m_errFile.clear();
+            }
+
+            void activateImpl() override {
+                // We flush before starting redirect, to ensure that we do
+                // not capture the end of message sent before activation.
+                flushEverything();
+
+                int ret;
+                ret = dup2( fileno( m_outFile.getFile() ), fileno( stdout ) );
+                CATCH_ENFORCE( ret >= 0,
+                               "dup2 to stdout has failed, errno: " << errno );
+                ret = dup2( fileno( m_errFile.getFile() ), fileno( stderr ) );
+                CATCH_ENFORCE( ret >= 0,
+                               "dup2 to stderr has failed, errno: " << errno );
+            }
+            void deactivateImpl() override {
+                // We flush before ending redirect, to ensure that we
+                // capture all messages sent while the redirect was active.
+                flushEverything();
+
+                int ret;
+                ret = dup2( m_originalOut, fileno( stdout ) );
+                CATCH_ENFORCE(
+                    ret >= 0,
+                    "dup2 of original stdout has failed, errno: " << errno );
+                ret = dup2( m_originalErr, fileno( stderr ) );
+                CATCH_ENFORCE(
+                    ret >= 0,
+                    "dup2 of original stderr has failed, errno: " << errno );
+            }
+        };
 
 #endif // CATCH_CONFIG_NEW_CAPTURE
 
+
+#if defined( CATCH_CONFIG_USE_ASYNC )
+
+        static inline void pipe_or_throw( int descriptors[2] ) {
+#    if defined( _MSC_VER )
+            constexpr int defaultPipeSize{ 0 };
+
+            int result{ _pipe( descriptors, defaultPipeSize, _O_BINARY ) };
+#    else
+            int result{ pipe( descriptors ) };
+#    endif
+
+            if ( result ) {
+                CATCH_INTERNAL_ERROR( "pipe-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+        }
+
+        static inline size_t
+        read_or_throw( int descriptor, void* buffer, size_t size ) {
+#    if defined( _MSC_VER )
+            int result{
+                _read( descriptor, buffer, static_cast<unsigned>( size ) ) };
+#    else
+            ssize_t result{ read( descriptor, buffer, size ) };
+#    endif
+
+            if ( result == -1 ) {
+                CATCH_INTERNAL_ERROR( "read-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+
+            return static_cast<size_t>( result );
+        }
+
+        static inline void close_or_throw( int descriptor ) {
+            if ( close( descriptor ) ) {
+                CATCH_INTERNAL_ERROR( "close-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+        }
+
+        static inline int dup_or_throw( int descriptor ) {
+            int result{ dup( descriptor ) };
+
+            if ( result == -1 ) {
+                CATCH_INTERNAL_ERROR( "dup-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+
+            return result;
+        }
+
+        static inline int dup2_or_throw( int sourceDescriptor,
+                                         int destinationDescriptor ) {
+            int result{ dup2( sourceDescriptor, destinationDescriptor ) };
+
+            if ( result == -1 ) {
+                CATCH_INTERNAL_ERROR( "dup2-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+
+            return result;
+        }
+
+        static inline int fileno_or_throw( std::FILE* file ) {
+            int result{ fileno( file ) };
+
+            if ( result == -1 ) {
+                CATCH_INTERNAL_ERROR( "fileno-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+
+            return result;
+        }
+
+        static inline void fflush_or_throw( std::FILE* file ) {
+            if ( std::fflush( file ) ) {
+                CATCH_INTERNAL_ERROR( "fflush-or-throw" );
+                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+            }
+        }
+
+        class StreamPipeHandler {
+            int m_originalFd = -1;
+            int m_pipeReadEnd = -1;
+            int m_pipeWriteEnd = -1;
+            FILE* m_targetStream;
+            std::mutex m_mutex;
+            std::string m_captured;
+            std::thread m_readThread;
+
+        public:
+            StreamPipeHandler( FILE* original ):
+                m_originalFd( dup_or_throw( fileno( original ) ) ),
+                m_targetStream(original)
+            {
+                CATCH_ENFORCE( m_originalFd >= 0, "Could not dup stream" );
+                int pipe_fds[2];
+                pipe_or_throw( pipe_fds );
+                m_pipeReadEnd = pipe_fds[0];
+                m_pipeWriteEnd = pipe_fds[1];
+
+                m_readThread = std::thread([this]() {
+                    constexpr size_t bufferSize = 4096;
+                    char buffer[bufferSize];
+                    size_t sizeRead;
+                    while ( ( sizeRead = read_or_throw(
+                                  m_pipeReadEnd, buffer, bufferSize ) ) != 0 ) {
+                        std::unique_lock<std::mutex> _( m_mutex );
+                        m_captured.append( buffer, sizeRead );
+                    }
+                });
+            }
+
+            ~StreamPipeHandler() {
+                close_or_throw( m_pipeWriteEnd );
+                m_readThread.join();
+            }
+
+            std::string getCapturedOutput() {
+                std::unique_lock<std::mutex> _( m_mutex );
+                return m_captured;
+            }
+
+            void clearCapturedOutput() {
+                std::unique_lock<std::mutex> _( m_mutex );
+                m_captured.clear();
+            }
+
+            void startCapture() {
+                fflush_or_throw( m_targetStream );
+                int ret = dup2_or_throw( m_pipeWriteEnd, fileno( m_targetStream ) );
+                CATCH_ENFORCE( ret >= 0,
+                               "dup2 pipe-write -> original stream failed " << errno );
+            }
+            void stopCapture() {
+                fflush_or_throw( m_targetStream );
+                int ret = dup2_or_throw( m_originalFd, fileno( m_targetStream ) );
+                CATCH_ENFORCE( ret >= 0,
+                               "dup2 of original fd -> original stream failed " << errno );
+            }
+        };
+
+        class PipeRedirect : public OutputRedirect {
+        private:
+            StreamPipeHandler m_stdout;
+            StreamPipeHandler m_stderr;
+        public:
+            PipeRedirect():
+                m_stdout(stdout),
+                m_stderr(stderr){}
+
+            void activateImpl() override {
+                m_stdout.startCapture();
+                m_stderr.startCapture();
+            }
+            void deactivateImpl() override {
+                m_stdout.stopCapture();
+                m_stderr.stopCapture();
+            }
+            std::string getStdout() override {
+                return m_stdout.getCapturedOutput();
+            }
+            std::string getStderr() override {
+                return m_stderr.getCapturedOutput();
+            }
+            void clearBuffers() override {
+                m_stdout.clearCapturedOutput();
+                m_stderr.clearCapturedOutput();
+            }
+        };
+
+#endif // CATCH_CONFIG_USE_ASYNC
+
+
+    } // end namespace
+
+    bool isRedirectAvailable( OutputRedirect::Kind kind ) {
+        switch ( kind ) {
+        // These two are always available
+        case OutputRedirect::None:
+        case OutputRedirect::Streams:
+            return true;
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+        case OutputRedirect::FileDescriptors:
+            return true;
+#endif
+#if defined(CATCH_CONFIG_USE_ASYNC)
+        case OutputRedirect::Pipes:
+            return true;
+#endif
+        default:
+            return false;
+        }
+    }
+
+    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual ) {
+        if ( actual ) {
+            // TODO: Clean this up later
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+            return Detail::make_unique<FileRedirect>();
+#else
+            //return Detail::make_unique<StreamRedirect>();
+            return Detail::make_unique<PipeRedirect>();
+#endif
+        } else {
+            return Detail::make_unique<NoopRedirect>();
+        }
+    }
+
+    RedirectGuard scopedActivate( OutputRedirect& redirectImpl ) {
+        return RedirectGuard( true, redirectImpl );
+    }
+
+    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl ) {
+        return RedirectGuard( false, redirectImpl );
+    }
+
+    OutputRedirect::~OutputRedirect() = default;
+
+    RedirectGuard::RedirectGuard( bool activate, OutputRedirect& redirectImpl ):
+        m_redirect( &redirectImpl ),
+        m_activate( activate ),
+        m_previouslyActive( redirectImpl.isActive() ) {
+
+        // Skip cases where there is no actual state change.
+        if ( m_activate == m_previouslyActive ) { return; }
+
+        if ( m_activate ) {
+            m_redirect->activate();
+        } else {
+            m_redirect->deactivate();
+        }
+    }
+
+    RedirectGuard::~RedirectGuard() noexcept( false ) {
+        if ( m_moved ) { return; }
+        // Skip cases where there is no actual state change.
+        if ( m_activate == m_previouslyActive ) { return; }
+
+        if ( m_activate ) {
+            m_redirect->deactivate();
+        } else {
+            m_redirect->activate();
+        }
+    }
+
+    RedirectGuard::RedirectGuard( RedirectGuard&& rhs ) noexcept:
+        m_redirect( rhs.m_redirect ),
+        m_activate( rhs.m_activate ),
+        m_previouslyActive( rhs.m_previouslyActive ),
+        m_moved( false ) {
+        rhs.m_moved = true;
+    }
+
+    RedirectGuard& RedirectGuard::operator=( RedirectGuard&& rhs ) noexcept {
+        m_redirect = rhs.m_redirect;
+        m_activate = rhs.m_activate;
+        m_previouslyActive = rhs.m_previouslyActive;
+        m_moved = false;
+        rhs.m_moved = true;
+        return *this;
+    }
+
 } // namespace Catch
 
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #undef dup
-    #undef dup2
-    #undef fileno
-    #endif
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+#    if defined( _MSC_VER )
+#        undef dup
+#        undef dup2
+#        undef fileno
+#    endif
 #endif

src/catch2/internal/catch_output_redirect.hpp

@@ -8,110 +8,71 @@
 #ifndef CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
 #define CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
 
-#include <catch2/internal/catch_platform.hpp>
-#include <catch2/internal/catch_reusable_string_stream.hpp>
-#include <catch2/internal/catch_compiler_capabilities.hpp>
+#include <catch2/internal/catch_unique_ptr.hpp>
 
-#include <cstdio>
-#include <iosfwd>
+#include <cassert>
 #include <string>
 
 namespace Catch {
 
-    class RedirectedStream {
-        std::ostream& m_originalStream;
-        std::ostream& m_redirectionStream;
-        std::streambuf* m_prevBuf;
-
-    public:
-        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
-        ~RedirectedStream();
-    };
-
-    class RedirectedStdOut {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cout;
-    public:
-        RedirectedStdOut();
-        auto str() const -> std::string;
-    };
-
-    // StdErr has two constituent streams in C++, std::cerr and std::clog
-    // This means that we need to redirect 2 streams into 1 to keep proper
-    // order of writes
-    class RedirectedStdErr {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cerr;
-        RedirectedStream m_clog;
-    public:
-        RedirectedStdErr();
-        auto str() const -> std::string;
-    };
-
-    class RedirectedStreams {
-    public:
-        RedirectedStreams(RedirectedStreams const&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
-        RedirectedStreams(RedirectedStreams&&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
-
-        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
-        ~RedirectedStreams();
-    private:
-        std::string& m_redirectedCout;
-        std::string& m_redirectedCerr;
-        RedirectedStdOut m_redirectedStdOut;
-        RedirectedStdErr m_redirectedStdErr;
-    };
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-    // Windows's implementation of std::tmpfile is terrible (it tries
-    // to create a file inside system folder, thus requiring elevated
-    // privileges for the binary), so we have to use tmpnam(_s) and
-    // create the file ourselves there.
-    class TempFile {
-    public:
-        TempFile(TempFile const&) = delete;
-        TempFile& operator=(TempFile const&) = delete;
-        TempFile(TempFile&&) = delete;
-        TempFile& operator=(TempFile&&) = delete;
-
-        TempFile();
-        ~TempFile();
-
-        std::FILE* getFile();
-        std::string getContents();
-
-    private:
-        std::FILE* m_file = nullptr;
-    #if defined(_MSC_VER)
-        char m_buffer[L_tmpnam] = { 0 };
-    #endif
-    };
-
-
     class OutputRedirect {
+        bool m_redirectActive = false;
+        virtual void activateImpl() = 0;
+        virtual void deactivateImpl() = 0;
     public:
-        OutputRedirect(OutputRedirect const&) = delete;
-        OutputRedirect& operator=(OutputRedirect const&) = delete;
-        OutputRedirect(OutputRedirect&&) = delete;
-        OutputRedirect& operator=(OutputRedirect&&) = delete;
+        enum Kind {
+            //! No redirect (noop implementation)
+            None,
+            //! Redirect std::cout/std::cerr/std::clog streams internally
+            Streams,
+            //! Redirect the stdout/stderr file descriptors into temp files
+            FileDescriptors,
+            //! Redirect the stdout/stderr file descriptors into anonymous pipes
+            Pipes,
+        };
 
+        virtual ~OutputRedirect(); // = default;
 
-        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
-        ~OutputRedirect();
-
-    private:
-        int m_originalStdout = -1;
-        int m_originalStderr = -1;
-        TempFile m_stdoutFile;
-        TempFile m_stderrFile;
-        std::string& m_stdoutDest;
-        std::string& m_stderrDest;
+        // TODO: Do we want to check that redirect is not active before retrieving the output?
+        virtual std::string getStdout() = 0;
+        virtual std::string getStderr() = 0;
+        virtual void clearBuffers() = 0;
+        bool isActive() const { return m_redirectActive; }
+        void activate() {
+            assert( !m_redirectActive && "redirect is already active" );
+            activateImpl();
+            m_redirectActive = true;
+        }
+        void deactivate() {
+            assert( m_redirectActive && "redirect is not active" );
+            deactivateImpl();
+            m_redirectActive = false;
+        }
     };
 
-#endif
+    bool isRedirectAvailable( OutputRedirect::Kind kind);
+    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual );
+
+    class RedirectGuard {
+        OutputRedirect* m_redirect;
+        bool m_activate;
+        bool m_previouslyActive;
+        bool m_moved = false;
+
+    public:
+        RedirectGuard( bool activate, OutputRedirect& redirectImpl );
+        ~RedirectGuard() noexcept( false );
+
+        RedirectGuard( RedirectGuard const& ) = delete;
+        RedirectGuard& operator=( RedirectGuard const& ) = delete;
+
+        // C++14 needs move-able guards to return them from functions
+        RedirectGuard( RedirectGuard&& rhs ) noexcept;
+        RedirectGuard& operator=( RedirectGuard&& rhs ) noexcept;
+    };
+
+    RedirectGuard scopedActivate( OutputRedirect& redirectImpl );
+    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl );
 
 } // end namespace Catch
 

src/catch2/internal/catch_random_integer_helpers.hpp

@@ -21,7 +21,10 @@
 //       it, and it provides an escape hatch to the users who need it.
 #if defined( __SIZEOF_INT128__ )
 #    define CATCH_CONFIG_INTERNAL_UINT128
-#elif defined( _MSC_VER ) && ( defined( _WIN64 ) || defined( _M_ARM64 ) )
+// Unlike GCC, MSVC does not polyfill umul as mulh + mul pair on ARM machines.
+// Currently we do not bother doing this ourselves, but we could if it became
+// important for perf.
+#elif defined( _MSC_VER ) && defined( _M_X64 )
 #    define CATCH_CONFIG_INTERNAL_MSVC_UMUL128
 #endif
 
@@ -36,7 +39,6 @@
     !defined( CATCH_CONFIG_MSVC_UMUL128 )
 #    define CATCH_CONFIG_MSVC_UMUL128
 #    include <intrin.h>
-#    pragma intrinsic( _umul128 )
 #endif
 
 
@@ -67,7 +69,7 @@ namespace Catch {
         struct ExtendedMultResult {
             T upper;
             T lower;
-            bool operator==( ExtendedMultResult const& rhs ) const {
+            constexpr bool operator==( ExtendedMultResult const& rhs ) const {
                 return upper == rhs.upper && lower == rhs.lower;
             }
         };
@@ -185,6 +187,7 @@ namespace Catch {
          * get by simple casting ([0, ..., INT_MAX, INT_MIN, ..., -1])
          */
         template <typename OriginalType, typename UnsignedType>
+        constexpr
         std::enable_if_t<std::is_signed<OriginalType>::value, UnsignedType>
         transposeToNaturalOrder( UnsignedType in ) {
             static_assert(
@@ -205,6 +208,7 @@ namespace Catch {
 
         template <typename OriginalType,
                   typename UnsignedType>
+        constexpr
         std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
             transposeToNaturalOrder(UnsignedType in) {
             static_assert(

src/catch2/internal/catch_result_type.cpp

@@ -1,26 +0,0 @@
-
-//              Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE.txt or copy at
-//        https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-#include <catch2/internal/catch_result_type.hpp>
-
-namespace Catch {
-
-    bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
-
-    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
-
-} // end namespace Catch

src/catch2/internal/catch_result_type.hpp

@@ -33,8 +33,10 @@ namespace Catch {
 
     }; };
 
-    bool isOk( ResultWas::OfType resultType );
-    bool isJustInfo( int flags );
+    constexpr bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    constexpr bool isJustInfo( int flags ) { return flags == ResultWas::Info; }
 
 
     // ResultDisposition::Flags enum
@@ -46,11 +48,18 @@ namespace Catch {
         SuppressFail = 0x08         // Failures are reported but do not fail the test
     }; };
 
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
+    constexpr ResultDisposition::Flags operator|( ResultDisposition::Flags lhs,
+                                        ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) |
+                                                      static_cast<int>( rhs ) );
+    }
 
-    bool shouldContinueOnFailure( int flags );
-    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    bool shouldSuppressFailure( int flags );
+    constexpr bool isFalseTest( int flags ) {
+        return ( flags & ResultDisposition::FalseTest ) != 0;
+    }
+    constexpr bool shouldSuppressFailure( int flags ) {
+        return ( flags & ResultDisposition::SuppressFail ) != 0;
+    }
 
 } // end namespace Catch
 

src/catch2/internal/catch_run_context.cpp

@@ -170,6 +170,7 @@ namespace Catch {
         m_config(_config),
         m_reporter(CATCH_MOVE(reporter)),
         m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
+        m_outputRedirect( makeOutputRedirect( m_reporter->getPreferences().shouldRedirectStdOut ) ),
         m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
     {
         getCurrentMutableContext().setResultCapture( this );
@@ -185,6 +186,7 @@ namespace Catch {
 
         auto const& testInfo = testCase.getTestCaseInfo();
         m_reporter->testCaseStarting(testInfo);
+        testCase.prepareTestCase();
         m_activeTestCase = &testCase;
 
 
@@ -235,15 +237,17 @@ namespace Catch {
             m_reporter->testCasePartialStarting(testInfo, testRuns);
 
             const auto beforeRunTotals = m_totals;
-            std::string oneRunCout, oneRunCerr;
-            runCurrentTest(oneRunCout, oneRunCerr);
+            runCurrentTest();
+            std::string oneRunCout = m_outputRedirect->getStdout();
+            std::string oneRunCerr = m_outputRedirect->getStderr();
+            m_outputRedirect->clearBuffers();
             redirectedCout += oneRunCout;
             redirectedCerr += oneRunCerr;
 
             const auto singleRunTotals = m_totals.delta(beforeRunTotals);
             auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
-
             m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
+
             ++testRuns;
         } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
 
@@ -254,6 +258,7 @@ namespace Catch {
             deltaTotals.testCases.failed++;
         }
         m_totals.testCases += deltaTotals.testCases;
+        testCase.tearDownTestCase();
         m_reporter->testCaseEnded(TestCaseStats(testInfo,
                                   deltaTotals,
                                   CATCH_MOVE(redirectedCout),
@@ -287,7 +292,10 @@ namespace Catch {
             m_lastAssertionPassed = true;
         }
 
-        m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals));
+        {
+            auto _ = scopedDeactivate( *m_outputRedirect );
+            m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) );
+        }
 
         if ( result.getResultType() != ResultWas::Warning ) {
             m_messageScopes.clear();
@@ -304,6 +312,7 @@ namespace Catch {
     }
 
     void RunContext::notifyAssertionStarted( AssertionInfo const& info ) {
+        auto _ = scopedDeactivate( *m_outputRedirect );
         m_reporter->assertionStarting( info );
     }
 
@@ -322,7 +331,10 @@ namespace Catch {
         SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) );
         m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
 
-        m_reporter->sectionStarting(sectionInfo);
+        {
+            auto _ = scopedDeactivate( *m_outputRedirect );
+            m_reporter->sectionStarting( sectionInfo );
+        }
 
         assertions = m_totals.assertions;
 
@@ -382,7 +394,15 @@ namespace Catch {
             m_activeSections.pop_back();
         }
 
-        m_reporter->sectionEnded(SectionStats(CATCH_MOVE(endInfo.sectionInfo), assertions, endInfo.durationInSeconds, missingAssertions));
+        {
+            auto _ = scopedDeactivate( *m_outputRedirect );
+            m_reporter->sectionEnded(
+                SectionStats( CATCH_MOVE( endInfo.sectionInfo ),
+                              assertions,
+                              endInfo.durationInSeconds,
+                              missingAssertions ) );
+        }
+
         m_messages.clear();
         m_messageScopes.clear();
     }
@@ -399,15 +419,19 @@ namespace Catch {
     }
 
     void RunContext::benchmarkPreparing( StringRef name ) {
-        m_reporter->benchmarkPreparing(name);
+        auto _ = scopedDeactivate( *m_outputRedirect );
+        m_reporter->benchmarkPreparing( name );
     }
     void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
+        auto _ = scopedDeactivate( *m_outputRedirect );
         m_reporter->benchmarkStarting( info );
     }
     void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
+        auto _ = scopedDeactivate( *m_outputRedirect );
         m_reporter->benchmarkEnded( stats );
     }
     void RunContext::benchmarkFailed( StringRef error ) {
+        auto _ = scopedDeactivate( *m_outputRedirect );
         m_reporter->benchmarkFailed( error );
     }
 
@@ -438,8 +462,13 @@ namespace Catch {
     }
 
     void RunContext::handleFatalErrorCondition( StringRef message ) {
+        // TODO: scoped deactivate here? Just give up and do best effort?
+        //       the deactivation can break things further, OTOH so can the
+        //       capture
+        auto _ = scopedDeactivate( *m_outputRedirect );
+
         // First notify reporter that bad things happened
-        m_reporter->fatalErrorEncountered(message);
+        m_reporter->fatalErrorEncountered( message );
 
         // Don't rebuild the result -- the stringification itself can cause more fatal errors
         // Instead, fake a result data.
@@ -450,6 +479,13 @@ namespace Catch {
         assertionEnded(CATCH_MOVE(result) );
         resetAssertionInfo();
 
+        // Best effort cleanup for sections that have not been destructed yet
+        // Since this is a fatal error, we have not had and won't have the opportunity to destruct them properly
+        while (!m_activeSections.empty()) {
+            auto nl = m_activeSections.back()->nameAndLocation();
+            SectionEndInfo endInfo{ SectionInfo(CATCH_MOVE(nl.location), CATCH_MOVE(nl.name)), {}, 0.0 };
+            sectionEndedEarly(CATCH_MOVE(endInfo));
+        }
         handleUnfinishedSections();
 
         // Recreate section for test case (as we will lose the one that was in scope)
@@ -459,7 +495,7 @@ namespace Catch {
         Counts assertions;
         assertions.failed = 1;
         SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false);
-        m_reporter->sectionEnded(testCaseSectionStats);
+        m_reporter->sectionEnded( testCaseSectionStats );
 
         auto const& testInfo = m_activeTestCase->getTestCaseInfo();
 
@@ -490,7 +526,7 @@ namespace Catch {
         return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
     }
 
-    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
+    void RunContext::runCurrentTest() {
         auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
         SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
         m_reporter->sectionStarting(testCaseSection);
@@ -501,18 +537,8 @@ namespace Catch {
 
         Timer timer;
         CATCH_TRY {
-            if (m_reporter->getPreferences().shouldRedirectStdOut) {
-#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
-
-                timer.start();
-                invokeActiveTestCase();
-#else
-                OutputRedirect r(redirectedCout, redirectedCerr);
-                timer.start();
-                invokeActiveTestCase();
-#endif
-            } else {
+            {
+                auto _ = scopedActivate( *m_outputRedirect );
                 timer.start();
                 invokeActiveTestCase();
             }
@@ -557,11 +583,12 @@ namespace Catch {
     void RunContext::handleUnfinishedSections() {
         // If sections ended prematurely due to an exception we stored their
         // infos here so we can tear them down outside the unwind process.
-        for (auto it = m_unfinishedSections.rbegin(),
-             itEnd = m_unfinishedSections.rend();
-             it != itEnd;
-             ++it)
-            sectionEnded(CATCH_MOVE(*it));
+        for ( auto it = m_unfinishedSections.rbegin(),
+                   itEnd = m_unfinishedSections.rend();
+              it != itEnd;
+              ++it ) {
+            sectionEnded( CATCH_MOVE( *it ) );
+        }
         m_unfinishedSections.clear();
     }
 
@@ -605,13 +632,13 @@ namespace Catch {
     void RunContext::handleMessage(
             AssertionInfo const& info,
             ResultWas::OfType resultType,
-            StringRef message,
+            std::string&& message,
             AssertionReaction& reaction
     ) {
         m_lastAssertionInfo = info;
 
         AssertionResultData data( resultType, LazyExpression( false ) );
-        data.message = static_cast<std::string>(message);
+        data.message = CATCH_MOVE( message );
         AssertionResult assertionResult{ m_lastAssertionInfo,
                                          CATCH_MOVE( data ) };
 

src/catch2/internal/catch_run_context.hpp

@@ -29,6 +29,7 @@ namespace Catch {
     class IConfig;
     class IEventListener;
     using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+    class OutputRedirect;
 
     ///////////////////////////////////////////////////////////////////////////
 
@@ -54,7 +55,7 @@ namespace Catch {
         void handleMessage
                 (   AssertionInfo const& info,
                     ResultWas::OfType resultType,
-                    StringRef message,
+                    std::string&& message,
                     AssertionReaction& reaction ) override;
         void handleUnexpectedExceptionNotThrown
                 (   AssertionInfo const& info,
@@ -115,7 +116,7 @@ namespace Catch {
 
     private:
 
-        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
+        void runCurrentTest();
         void invokeActiveTestCase();
 
         void resetAssertionInfo();
@@ -148,6 +149,7 @@ namespace Catch {
         std::vector<SectionEndInfo> m_unfinishedSections;
         std::vector<ITracker*> m_activeSections;
         TrackerContext m_trackerContext;
+        Detail::unique_ptr<OutputRedirect> m_outputRedirect;
         FatalConditionHandler m_fatalConditionhandler;
         bool m_lastAssertionPassed = false;
         bool m_shouldReportUnexpected = true;

src/catch2/internal/catch_test_macro_impl.hpp

@@ -38,8 +38,6 @@
 
 #endif
 
-#define INTERNAL_CATCH_REACT( handler ) handler.complete();
-
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
     do { /* NOLINT(bugprone-infinite-loop) */ \
@@ -52,7 +50,7 @@
             catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); /* NOLINT(bugprone-chained-comparison) */ \
             CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
         } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+        catchAssertionHandler.complete(); \
     } while( (void)0, (false) && static_cast<const bool&>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
     // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
 
@@ -80,7 +78,7 @@
         catch( ... ) { \
             catchAssertionHandler.handleUnexpectedInflightException(); \
         } \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+        catchAssertionHandler.complete(); \
     } while( false )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -101,7 +99,7 @@
             } \
         else \
             catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+        catchAssertionHandler.complete(); \
     } while( false )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -125,7 +123,7 @@
             } \
         else \
             catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+        catchAssertionHandler.complete(); \
     } while( false )
 
 
@@ -149,7 +147,7 @@
             } \
         else \
             catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+        catchAssertionHandler.complete(); \
     } while( false )
 
 #endif // CATCH_CONFIG_DISABLE

src/catch2/internal/catch_test_registry.cpp

@@ -16,6 +16,8 @@
 #include <iterator>
 
 namespace Catch {
+    void ITestInvoker::prepareTestCase() {}
+    void ITestInvoker::tearDownTestCase() {}
     ITestInvoker::~ITestInvoker() = default;
 
     namespace {
@@ -52,7 +54,7 @@ namespace Catch {
             TestType m_testAsFunction;
 
         public:
-            TestInvokerAsFunction( TestType testAsFunction ) noexcept:
+            constexpr TestInvokerAsFunction( TestType testAsFunction ) noexcept:
                 m_testAsFunction( testAsFunction ) {}
 
             void invoke() const override { m_testAsFunction(); }

src/catch2/internal/catch_test_registry.hpp

@@ -32,7 +32,8 @@ template<typename C>
 class TestInvokerAsMethod : public ITestInvoker {
     void (C::*m_testAsMethod)();
 public:
-    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
+    constexpr TestInvokerAsMethod( void ( C::*testAsMethod )() ) noexcept:
+        m_testAsMethod( testAsMethod ) {}
 
     void invoke() const override {
         C obj;
@@ -47,6 +48,34 @@ Detail::unique_ptr<ITestInvoker> makeTestInvoker( void (C::*testAsMethod)() ) {
     return Detail::make_unique<TestInvokerAsMethod<C>>( testAsMethod );
 }
 
+template <typename C>
+class TestInvokerFixture : public ITestInvoker {
+    void ( C::*m_testAsMethod )() const;
+    Detail::unique_ptr<C> m_fixture = nullptr;
+
+public:
+    constexpr TestInvokerFixture( void ( C::*testAsMethod )() const ) noexcept:
+        m_testAsMethod( testAsMethod ) {}
+
+    void prepareTestCase() override {
+        m_fixture = Detail::make_unique<C>();
+    }
+
+    void tearDownTestCase() override {
+        m_fixture.reset();
+    }
+
+    void invoke() const override {
+        auto* f = m_fixture.get();
+        ( f->*m_testAsMethod )();
+    }
+};
+
+template<typename C>
+Detail::unique_ptr<ITestInvoker> makeTestInvokerFixture( void ( C::*testAsMethod )() const ) {
+    return Detail::make_unique<TestInvokerFixture<C>>( testAsMethod );
+}
+
 struct NameAndTags {
     constexpr NameAndTags( StringRef name_ = StringRef(),
                            StringRef tags_ = StringRef() ) noexcept:
@@ -143,6 +172,26 @@ static int catchInternalSectionHint = 0;
     #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
         INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
 
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( TestName, ClassName, ... )      \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                             \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                              \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                      \
+        namespace {                                                           \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS( ClassName ) {     \
+                void test() const;                                            \
+            };                                                                \
+            const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+                Catch::makeTestInvokerFixture( &TestName::test ),                    \
+                CATCH_INTERNAL_LINEINFO,                                      \
+                #ClassName##_catch_sr,                                        \
+                Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */             \
+        }                                                                     \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                              \
+        void TestName::test() const
+    #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( ClassName, ... )    \
+        INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
+
 
     ///////////////////////////////////////////////////////////////////////////////
     #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \

src/catch2/internal/catch_textflow.cpp

@@ -26,117 +26,228 @@ namespace {
         return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
     }
 
-    bool isBoundary( std::string const& line, size_t at ) {
-        assert( at > 0 );
-        assert( at <= line.size() );
-
-        return at == line.size() ||
-               ( isWhitespace( line[at] ) && !isWhitespace( line[at - 1] ) ) ||
-               isBreakableBefore( line[at] ) ||
-               isBreakableAfter( line[at - 1] );
-    }
-
 } // namespace
 
 namespace Catch {
     namespace TextFlow {
+        void AnsiSkippingString::preprocessString() {
+            for ( auto it = m_string.begin(); it != m_string.end(); ) {
+                // try to read through an ansi sequence
+                while ( it != m_string.end() && *it == '\033' &&
+                        it + 1 != m_string.end() && *( it + 1 ) == '[' ) {
+                    auto cursor = it + 2;
+                    while ( cursor != m_string.end() &&
+                            ( isdigit( *cursor ) || *cursor == ';' ) ) {
+                        ++cursor;
+                    }
+                    if ( cursor == m_string.end() || *cursor != 'm' ) {
+                        break;
+                    }
+                    // 'm' -> 0xff
+                    *cursor = AnsiSkippingString::sentinel;
+                    // if we've read an ansi sequence, set the iterator and
+                    // return to the top of the loop
+                    it = cursor + 1;
+                }
+                if ( it != m_string.end() ) {
+                    ++m_size;
+                    ++it;
+                }
+            }
+        }
+
+        AnsiSkippingString::AnsiSkippingString( std::string const& text ):
+            m_string( text ) {
+            preprocessString();
+        }
+
+        AnsiSkippingString::AnsiSkippingString( std::string&& text ):
+            m_string( CATCH_MOVE( text ) ) {
+            preprocessString();
+        }
+
+        AnsiSkippingString::const_iterator AnsiSkippingString::begin() const {
+            return const_iterator( m_string );
+        }
+
+        AnsiSkippingString::const_iterator AnsiSkippingString::end() const {
+            return const_iterator( m_string, const_iterator::EndTag{} );
+        }
+
+        std::string AnsiSkippingString::substring( const_iterator begin,
+                                                   const_iterator end ) const {
+            // There's one caveat here to an otherwise simple substring: when
+            // making a begin iterator we might have skipped ansi sequences at
+            // the start. If `begin` here is a begin iterator, skipped over
+            // initial ansi sequences, we'll use the true beginning of the
+            // string. Lastly: We need to transform any chars we replaced with
+            // 0xff back to 'm'
+            auto str = std::string( begin == this->begin() ? m_string.begin()
+                                                           : begin.m_it,
+                                    end.m_it );
+            std::transform( str.begin(), str.end(), str.begin(), []( char c ) {
+                return c == AnsiSkippingString::sentinel ? 'm' : c;
+            } );
+            return str;
+        }
+
+        void AnsiSkippingString::const_iterator::tryParseAnsiEscapes() {
+            // check if we've landed on an ansi sequence, and if so read through
+            // it
+            while ( m_it != m_string->end() && *m_it == '\033' &&
+                    m_it + 1 != m_string->end() &&  *( m_it + 1 ) == '[' ) {
+                auto cursor = m_it + 2;
+                while ( cursor != m_string->end() &&
+                        ( isdigit( *cursor ) || *cursor == ';' ) ) {
+                    ++cursor;
+                }
+                if ( cursor == m_string->end() ||
+                     *cursor != AnsiSkippingString::sentinel ) {
+                    break;
+                }
+                // if we've read an ansi sequence, set the iterator and
+                // return to the top of the loop
+                m_it = cursor + 1;
+            }
+        }
+
+        void AnsiSkippingString::const_iterator::advance() {
+            assert( m_it != m_string->end() );
+            m_it++;
+            tryParseAnsiEscapes();
+        }
+
+        void AnsiSkippingString::const_iterator::unadvance() {
+            assert( m_it != m_string->begin() );
+            m_it--;
+            // if *m_it is 0xff, scan back to the \033 and then m_it-- once more
+            // (and repeat check)
+            while ( *m_it == AnsiSkippingString::sentinel ) {
+                while ( *m_it != '\033' ) {
+                    assert( m_it != m_string->begin() );
+                    m_it--;
+                }
+                // if this happens, we must have been a begin iterator that had
+                // skipped over ansi sequences at the start of a string
+                assert( m_it != m_string->begin() );
+                assert( *m_it == '\033' );
+                m_it--;
+            }
+        }
+
+        static bool isBoundary( AnsiSkippingString const& line,
+                                AnsiSkippingString::const_iterator it ) {
+            return it == line.end() ||
+                   ( isWhitespace( *it ) &&
+                     !isWhitespace( *it.oneBefore() ) ) ||
+                   isBreakableBefore( *it ) ||
+                   isBreakableAfter( *it.oneBefore() );
+        }
 
         void Column::const_iterator::calcLength() {
             m_addHyphen = false;
             m_parsedTo = m_lineStart;
+            AnsiSkippingString const& current_line = m_column.m_string;
 
-            std::string const& current_line = m_column.m_string;
-            if ( current_line[m_lineStart] == '\n' ) {
-                ++m_parsedTo;
+            if ( m_parsedTo == current_line.end() ) {
+                m_lineEnd = m_parsedTo;
+                return;
             }
 
+            assert( m_lineStart != current_line.end() );
+            if ( *m_lineStart == '\n' ) { ++m_parsedTo; }
+
             const auto maxLineLength = m_column.m_width - indentSize();
-            const auto maxParseTo = std::min(current_line.size(), m_lineStart + maxLineLength);
-            while ( m_parsedTo < maxParseTo &&
-                    current_line[m_parsedTo] != '\n' ) {
+            std::size_t lineLength = 0;
+            while ( m_parsedTo != current_line.end() &&
+                    lineLength < maxLineLength && *m_parsedTo != '\n' ) {
                 ++m_parsedTo;
+                ++lineLength;
             }
 
             // If we encountered a newline before the column is filled,
             // then we linebreak at the newline and consider this line
             // finished.
-            if ( m_parsedTo < m_lineStart + maxLineLength ) {
-                m_lineLength = m_parsedTo - m_lineStart;
+            if ( lineLength < maxLineLength ) {
+                m_lineEnd = m_parsedTo;
             } else {
                 // Look for a natural linebreak boundary in the column
                 // (We look from the end, so that the first found boundary is
                 // the right one)
-                size_t newLineLength = maxLineLength;
-                while ( newLineLength > 0 && !isBoundary( current_line, m_lineStart + newLineLength ) ) {
-                    --newLineLength;
+                m_lineEnd = m_parsedTo;
+                while ( lineLength > 0 &&
+                        !isBoundary( current_line, m_lineEnd ) ) {
+                    --lineLength;
+                    --m_lineEnd;
                 }
-                while ( newLineLength > 0 &&
-                        isWhitespace( current_line[m_lineStart + newLineLength - 1] ) ) {
-                    --newLineLength;
+                while ( lineLength > 0 &&
+                        isWhitespace( *m_lineEnd.oneBefore() ) ) {
+                    --lineLength;
+                    --m_lineEnd;
                 }
 
-                // If we found one, then that is where we linebreak
-                if ( newLineLength > 0 ) {
-                    m_lineLength = newLineLength;
-                } else {
-                    // Otherwise we have to split text with a hyphen
+                // If we found one, then that is where we linebreak, otherwise
+                // we have to split text with a hyphen
+                if ( lineLength == 0 ) {
                     m_addHyphen = true;
-                    m_lineLength = maxLineLength - 1;
+                    m_lineEnd = m_parsedTo.oneBefore();
                 }
             }
         }
 
         size_t Column::const_iterator::indentSize() const {
-            auto initial =
-                m_lineStart == 0 ? m_column.m_initialIndent : std::string::npos;
+            auto initial = m_lineStart == m_column.m_string.begin()
+                               ? m_column.m_initialIndent
+                               : std::string::npos;
             return initial == std::string::npos ? m_column.m_indent : initial;
         }
 
-        std::string
-        Column::const_iterator::addIndentAndSuffix( size_t position,
-                                              size_t length ) const {
+        std::string Column::const_iterator::addIndentAndSuffix(
+            AnsiSkippingString::const_iterator start,
+            AnsiSkippingString::const_iterator end ) const {
             std::string ret;
             const auto desired_indent = indentSize();
-            ret.reserve( desired_indent + length + m_addHyphen );
+            // ret.reserve( desired_indent + (end - start) + m_addHyphen );
             ret.append( desired_indent, ' ' );
-            ret.append( m_column.m_string, position, length );
-            if ( m_addHyphen ) {
-                ret.push_back( '-' );
-            }
+            // ret.append( start, end );
+            ret += m_column.m_string.substring( start, end );
+            if ( m_addHyphen ) { ret.push_back( '-' ); }
 
             return ret;
         }
 
-        Column::const_iterator::const_iterator( Column const& column ): m_column( column ) {
+        Column::const_iterator::const_iterator( Column const& column ):
+            m_column( column ),
+            m_lineStart( column.m_string.begin() ),
+            m_lineEnd( column.m_string.begin() ),
+            m_parsedTo( column.m_string.begin() ) {
             assert( m_column.m_width > m_column.m_indent );
             assert( m_column.m_initialIndent == std::string::npos ||
                     m_column.m_width > m_column.m_initialIndent );
             calcLength();
-            if ( m_lineLength == 0 ) {
-                m_lineStart = m_column.m_string.size();
+            if ( m_lineStart == m_lineEnd ) {
+                m_lineStart = m_column.m_string.end();
             }
         }
 
         std::string Column::const_iterator::operator*() const {
             assert( m_lineStart <= m_parsedTo );
-            return addIndentAndSuffix( m_lineStart, m_lineLength );
+            return addIndentAndSuffix( m_lineStart, m_lineEnd );
         }
 
         Column::const_iterator& Column::const_iterator::operator++() {
-            m_lineStart += m_lineLength;
-            std::string const& current_line = m_column.m_string;
-            if ( m_lineStart < current_line.size() && current_line[m_lineStart] == '\n' ) {
-                m_lineStart += 1;
+            m_lineStart = m_lineEnd;
+            AnsiSkippingString const& current_line = m_column.m_string;
+            if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) {
+                m_lineStart++;
             } else {
-                while ( m_lineStart < current_line.size() &&
-                        isWhitespace( current_line[m_lineStart] ) ) {
+                while ( m_lineStart != current_line.end() &&
+                        isWhitespace( *m_lineStart ) ) {
                     ++m_lineStart;
                 }
             }
 
-            if ( m_lineStart != current_line.size() ) {
-                calcLength();
-            }
+            if ( m_lineStart != current_line.end() ) { calcLength(); }
             return *this;
         }
 
@@ -233,25 +344,25 @@ namespace Catch {
             return os;
         }
 
-        Columns operator+(Column const& lhs, Column const& rhs) {
+        Columns operator+( Column const& lhs, Column const& rhs ) {
             Columns cols;
             cols += lhs;
             cols += rhs;
             return cols;
         }
-        Columns operator+(Column&& lhs, Column&& rhs) {
+        Columns operator+( Column&& lhs, Column&& rhs ) {
             Columns cols;
             cols += CATCH_MOVE( lhs );
             cols += CATCH_MOVE( rhs );
             return cols;
         }
 
-        Columns& operator+=(Columns& lhs, Column const& rhs) {
+        Columns& operator+=( Columns& lhs, Column const& rhs ) {
             lhs.m_columns.push_back( rhs );
             return lhs;
         }
-        Columns& operator+=(Columns& lhs, Column&& rhs) {
-            lhs.m_columns.push_back( CATCH_MOVE(rhs) );
+        Columns& operator+=( Columns& lhs, Column&& rhs ) {
+            lhs.m_columns.push_back( CATCH_MOVE( rhs ) );
             return lhs;
         }
         Columns operator+( Columns const& lhs, Column const& rhs ) {

src/catch2/internal/catch_textflow.hpp

@@ -20,6 +20,107 @@ namespace Catch {
 
         class Columns;
 
+        /**
+         * Abstraction for a string with ansi escape sequences that
+         * automatically skips over escapes when iterating. Only graphical
+         * escape sequences are considered.
+         *
+         * Internal representation:
+         * An escape sequence looks like \033[39;49m
+         * We need bidirectional iteration and the unbound length of escape
+         * sequences poses a problem for operator-- To make this work we'll
+         * replace the last `m` with a 0xff (this is a codepoint that won't have
+         * any utf-8 meaning).
+         */
+        class AnsiSkippingString {
+            std::string m_string;
+            std::size_t m_size = 0;
+
+            // perform 0xff replacement and calculate m_size
+            void preprocessString();
+
+        public:
+            class const_iterator;
+            using iterator = const_iterator;
+            // note: must be u-suffixed or this will cause a "truncation of
+            // constant value" warning on MSVC
+            static constexpr char sentinel = static_cast<char>( 0xffu );
+
+            explicit AnsiSkippingString( std::string const& text );
+            explicit AnsiSkippingString( std::string&& text );
+
+            const_iterator begin() const;
+            const_iterator end() const;
+
+            size_t size() const { return m_size; }
+
+            std::string substring( const_iterator begin,
+                                   const_iterator end ) const;
+        };
+
+        class AnsiSkippingString::const_iterator {
+            friend AnsiSkippingString;
+            struct EndTag {};
+
+            const std::string* m_string;
+            std::string::const_iterator m_it;
+
+            explicit const_iterator( const std::string& string, EndTag ):
+                m_string( &string ), m_it( string.end() ) {}
+
+            void tryParseAnsiEscapes();
+            void advance();
+            void unadvance();
+
+        public:
+            using difference_type = std::ptrdiff_t;
+            using value_type = char;
+            using pointer = value_type*;
+            using reference = value_type&;
+            using iterator_category = std::bidirectional_iterator_tag;
+
+            explicit const_iterator( const std::string& string ):
+                m_string( &string ), m_it( string.begin() ) {
+                tryParseAnsiEscapes();
+            }
+
+            char operator*() const { return *m_it; }
+
+            const_iterator& operator++() {
+                advance();
+                return *this;
+            }
+            const_iterator operator++( int ) {
+                iterator prev( *this );
+                operator++();
+                return prev;
+            }
+            const_iterator& operator--() {
+                unadvance();
+                return *this;
+            }
+            const_iterator operator--( int ) {
+                iterator prev( *this );
+                operator--();
+                return prev;
+            }
+
+            bool operator==( const_iterator const& other ) const {
+                return m_it == other.m_it;
+            }
+            bool operator!=( const_iterator const& other ) const {
+                return !operator==( other );
+            }
+            bool operator<=( const_iterator const& other ) const {
+                return m_it <= other.m_it;
+            }
+
+            const_iterator oneBefore() const {
+                auto it = *this;
+                return --it;
+            }
+        };
+
         /**
          * Represents a column of text with specific width and indentation
          *
@@ -29,10 +130,11 @@ namespace Catch {
          */
         class Column {
             // String to be written out
-            std::string m_string;
+            AnsiSkippingString m_string;
             // Width of the column for linebreaking
             size_t m_width = CATCH_CONFIG_CONSOLE_WIDTH - 1;
-            // Indentation of other lines (including first if initial indent is unset)
+            // Indentation of other lines (including first if initial indent is
+            // unset)
             size_t m_indent = 0;
             // Indentation of the first line
             size_t m_initialIndent = std::string::npos;
@@ -47,16 +149,19 @@ namespace Catch {
 
                 Column const& m_column;
                 // Where does the current line start?
-                size_t m_lineStart = 0;
+                AnsiSkippingString::const_iterator m_lineStart;
                 // How long should the current line be?
-                size_t m_lineLength = 0;
+                AnsiSkippingString::const_iterator m_lineEnd;
                 // How far have we checked the string to iterate?
-                size_t m_parsedTo = 0;
+                AnsiSkippingString::const_iterator m_parsedTo;
                 // Should a '-' be appended to the line?
                 bool m_addHyphen = false;
 
                 const_iterator( Column const& column, EndTag ):
-                    m_column( column ), m_lineStart( m_column.m_string.size() ) {}
+                    m_column( column ),
+                    m_lineStart( m_column.m_string.end() ),
+                    m_lineEnd( column.m_string.end() ),
+                    m_parsedTo( column.m_string.end() ) {}
 
                 // Calculates the length of the current line
                 void calcLength();
@@ -66,8 +171,9 @@ namespace Catch {
 
                 // Creates an indented and (optionally) suffixed string from
                 // current iterator position, indentation and length.
-                std::string addIndentAndSuffix( size_t position,
-                                                size_t length ) const;
+                std::string addIndentAndSuffix(
+                    AnsiSkippingString::const_iterator start,
+                    AnsiSkippingString::const_iterator end ) const;
 
             public:
                 using difference_type = std::ptrdiff_t;
@@ -84,7 +190,8 @@ namespace Catch {
                 const_iterator operator++( int );
 
                 bool operator==( const_iterator const& other ) const {
-                    return m_lineStart == other.m_lineStart && &m_column == &other.m_column;
+                    return m_lineStart == other.m_lineStart &&
+                           &m_column == &other.m_column;
                 }
                 bool operator!=( const_iterator const& other ) const {
                     return !operator==( other );
@@ -94,7 +201,7 @@ namespace Catch {
 
             explicit Column( std::string const& text ): m_string( text ) {}
             explicit Column( std::string&& text ):
-                m_string( CATCH_MOVE(text)) {}
+                m_string( CATCH_MOVE( text ) ) {}
 
             Column& width( size_t newWidth ) & {
                 assert( newWidth > 0 );
@@ -125,7 +232,9 @@ namespace Catch {
 
             size_t width() const { return m_width; }
             const_iterator begin() const { return const_iterator( *this ); }
-            const_iterator end() const { return { *this, const_iterator::EndTag{} }; }
+            const_iterator end() const {
+                return { *this, const_iterator::EndTag{} };
+            }
 
             friend std::ostream& operator<<( std::ostream& os,
                                              Column const& col );

src/catch2/internal/catch_uniform_integer_distribution.hpp

@@ -48,24 +48,24 @@ class uniform_integer_distribution {
     // distribution will be reused many times and this is an optimization.
     UnsignedIntegerType m_rejection_threshold = 0;
 
-    UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) const {
+    static constexpr UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) {
         // This overflows and returns 0 if a == 0 and b == TYPE_MAX.
         // We handle that later when generating the number.
         return transposeTo(b) - transposeTo(a) + 1;
     }
 
-    static UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
+    static constexpr UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
         // distance == 0 means that we will return all possible values from
         // the type's range, and that we shouldn't reject anything.
         if ( ab_distance == 0 ) { return 0; }
         return ( ~ab_distance + 1 ) % ab_distance;
     }
 
-    static UnsignedIntegerType transposeTo(IntegerType in) {
+    static constexpr UnsignedIntegerType transposeTo(IntegerType in) {
         return Detail::transposeToNaturalOrder<IntegerType>(
             static_cast<UnsignedIntegerType>( in ) );
     }
-    static IntegerType transposeBack(UnsignedIntegerType in) {
+    static constexpr IntegerType transposeBack(UnsignedIntegerType in) {
         return static_cast<IntegerType>(
             Detail::transposeToNaturalOrder<IntegerType>(in) );
     }
@@ -73,7 +73,7 @@ class uniform_integer_distribution {
 public:
     using result_type = IntegerType;
 
-    uniform_integer_distribution( IntegerType a, IntegerType b ):
+    constexpr uniform_integer_distribution( IntegerType a, IntegerType b ):
         m_a( transposeTo(a) ),
         m_ab_distance( computeDistance(a, b) ),
         m_rejection_threshold( computeRejectionThreshold(m_ab_distance) ) {
@@ -81,7 +81,7 @@ public:
     }
 
     template <typename Generator>
-    result_type operator()( Generator& g ) {
+    constexpr result_type operator()( Generator& g ) {
         // All possible values of result_type are valid.
         if ( m_ab_distance == 0 ) {
             return transposeBack( Detail::fillBitsFrom<UnsignedIntegerType>( g ) );
@@ -99,8 +99,8 @@ public:
         return transposeBack(m_a + emul.upper);
     }
 
-    result_type a() const { return transposeBack(m_a); }
-    result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
+    constexpr result_type a() const { return transposeBack(m_a); }
+    constexpr result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
 };
 
 } // end namespace Catch

src/catch2/internal/catch_wildcard_pattern.hpp

@@ -8,7 +8,7 @@
 #ifndef CATCH_WILDCARD_PATTERN_HPP_INCLUDED
 #define CATCH_WILDCARD_PATTERN_HPP_INCLUDED
 
-#include <catch2/internal/catch_case_sensitive.hpp>
+#include <catch2/catch_case_sensitive.hpp>
 
 #include <string>
 

src/catch2/internal/catch_xmlwriter.cpp

@@ -53,36 +53,16 @@ namespace {
         os.flags(f);
     }
 
-    bool shouldNewline(XmlFormatting fmt) {
+    constexpr bool shouldNewline(XmlFormatting fmt) {
         return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline));
     }
 
-    bool shouldIndent(XmlFormatting fmt) {
+    constexpr bool shouldIndent(XmlFormatting fmt) {
         return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent));
     }
 
 } // anonymous namespace
 
-    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
-        return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) |
-            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
-        );
-    }
-
-    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
-        return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) &
-            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
-        );
-    }
-
-
-    XmlEncode::XmlEncode( StringRef str, ForWhat forWhat )
-    :   m_str( str ),
-        m_forWhat( forWhat )
-    {}
-
     void XmlEncode::encodeTo( std::ostream& os ) const {
         // Apostrophe escaping not necessary if we always use " to write attributes
         // (see: http://www.w3.org/TR/xml/#syntax)

src/catch2/internal/catch_xmlwriter.hpp

@@ -15,14 +15,22 @@
 #include <vector>
 
 namespace Catch {
-    enum class XmlFormatting {
+    enum class XmlFormatting : uint8_t {
         None = 0x00,
         Indent = 0x01,
         Newline = 0x02,
     };
 
-    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
-    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
+    constexpr XmlFormatting operator|( XmlFormatting lhs, XmlFormatting rhs ) {
+        return static_cast<XmlFormatting>( static_cast<uint8_t>( lhs ) |
+                                           static_cast<uint8_t>( rhs ) );
+    }
+
+    constexpr XmlFormatting operator&( XmlFormatting lhs, XmlFormatting rhs ) {
+        return static_cast<XmlFormatting>( static_cast<uint8_t>( lhs ) &
+                                           static_cast<uint8_t>( rhs ) );
+    }
+
 
     /**
      * Helper for XML-encoding text (escaping angle brackets, quotes, etc)
@@ -34,7 +42,9 @@ namespace Catch {
     public:
         enum ForWhat { ForTextNodes, ForAttributes };
 
-        XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes );
+        constexpr XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes ):
+            m_str( str ), m_forWhat( forWhat ) {}
+
 
         void encodeTo( std::ostream& os ) const;
 

src/catch2/matchers/catch_matchers_floating_point.cpp

@@ -176,7 +176,7 @@ namespace Detail {
 
     std::string WithinRelMatcher::describe() const {
         Catch::ReusableStringStream sstr;
-        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
+        sstr << "and " << ::Catch::Detail::stringify(m_target) << " are within " << m_epsilon * 100. << "% of each other";
         return sstr.str();
     }
 

src/catch2/matchers/catch_matchers_range_equals.hpp

@@ -28,12 +28,14 @@ namespace Catch {
 
         public:
             template <typename TargetRangeLike2, typename Equality2>
+            constexpr
             RangeEqualsMatcher( TargetRangeLike2&& range,
                                 Equality2&& predicate ):
                 m_desired( CATCH_FORWARD( range ) ),
                 m_predicate( CATCH_FORWARD( predicate ) ) {}
 
             template <typename RangeLike>
+            constexpr
             bool match( RangeLike&& rng ) const {
                 auto rng_start = begin( rng );
                 const auto rng_end = end( rng );
@@ -66,12 +68,14 @@ namespace Catch {
 
         public:
             template <typename TargetRangeLike2, typename Equality2>
+            constexpr
             UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
                                          Equality2&& predicate ):
                 m_desired( CATCH_FORWARD( range ) ),
                 m_predicate( CATCH_FORWARD( predicate ) ) {}
 
             template <typename RangeLike>
+            constexpr
             bool match( RangeLike&& rng ) const {
                 using std::begin;
                 using std::end;
@@ -95,6 +99,7 @@ namespace Catch {
          * Uses `std::equal_to` to do the comparison
          */
         template <typename RangeLike>
+        constexpr
         std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
                          RangeEqualsMatcher<RangeLike, std::equal_to<>>>
         RangeEquals( RangeLike&& range ) {
@@ -108,6 +113,7 @@ namespace Catch {
          * Uses to provided predicate `predicate` to do the comparisons
          */
         template <typename RangeLike, typename Equality>
+        constexpr
         RangeEqualsMatcher<RangeLike, Equality>
         RangeEquals( RangeLike&& range, Equality&& predicate ) {
             return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
@@ -120,6 +126,7 @@ namespace Catch {
          * Uses `std::equal_to` to do the comparison
          */
         template <typename RangeLike>
+        constexpr
         std::enable_if_t<
             !Detail::is_matcher<RangeLike>::value,
             UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
@@ -134,6 +141,7 @@ namespace Catch {
          * Uses to provided predicate `predicate` to do the comparisons
          */
         template <typename RangeLike, typename Equality>
+        constexpr
         UnorderedRangeEqualsMatcher<RangeLike, Equality>
         UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
             return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };

src/catch2/matchers/catch_matchers_string.hpp

@@ -8,9 +8,9 @@
 #ifndef CATCH_MATCHERS_STRING_HPP_INCLUDED
 #define CATCH_MATCHERS_STRING_HPP_INCLUDED
 
-#include <catch2/matchers/catch_matchers.hpp>
-#include <catch2/internal/catch_case_sensitive.hpp>
 #include <catch2/internal/catch_stringref.hpp>
+#include <catch2/matchers/catch_matchers.hpp>
+#include <catch2/catch_case_sensitive.hpp>
 
 #include <string>
 

src/catch2/matchers/internal/catch_matchers_impl.hpp

@@ -18,12 +18,22 @@
 
 namespace Catch {
 
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wsign-compare"
+#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#elif defined __GNUC__
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wsign-compare"
+#    pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
     template<typename ArgT, typename MatcherT>
     class MatchExpr : public ITransientExpression {
         ArgT && m_arg;
         MatcherT const& m_matcher;
     public:
-        MatchExpr( ArgT && arg, MatcherT const& matcher )
+        constexpr MatchExpr( ArgT && arg, MatcherT const& matcher )
         :   ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
             m_arg( CATCH_FORWARD(arg) ),
             m_matcher( matcher )
@@ -36,6 +46,13 @@ namespace Catch {
         }
     };
 
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#elif defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+
+
     namespace Matchers {
         template <typename ArgT>
         class MatcherBase;
@@ -46,7 +63,8 @@ namespace Catch {
     void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );
 
     template<typename ArgT, typename MatcherT>
-    auto makeMatchExpr( ArgT && arg, MatcherT const& matcher ) -> MatchExpr<ArgT, MatcherT> {
+    constexpr MatchExpr<ArgT, MatcherT>
+    makeMatchExpr( ArgT&& arg, MatcherT const& matcher ) {
         return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher );
     }
 
@@ -60,7 +78,7 @@ namespace Catch {
         INTERNAL_CATCH_TRY { \
             catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher ) ); \
         } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+        catchAssertionHandler.complete(); \
     } while( false )
 
 
@@ -70,7 +88,10 @@ namespace Catch {
         Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
         if( catchAssertionHandler.allowThrows() ) \
             try { \
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
                 static_cast<void>(__VA_ARGS__ ); \
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
                 catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
             } \
             catch( exceptionType const& ex ) { \
@@ -81,7 +102,7 @@ namespace Catch {
             } \
         else \
             catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+        catchAssertionHandler.complete(); \
     } while( false )
 
 

src/catch2/meson.build

@@ -74,13 +74,13 @@ internal_headers = [
   'interfaces/catch_interfaces_testcase.hpp',
   'internal/catch_assertion_handler.hpp',
   'internal/catch_case_insensitive_comparisons.hpp',
-  'internal/catch_case_sensitive.hpp',
   'internal/catch_clara.hpp',
   'internal/catch_commandline.hpp',
   'internal/catch_compare_traits.hpp',
   'internal/catch_compiler_capabilities.hpp',
   'internal/catch_config_android_logwrite.hpp',
   'internal/catch_config_counter.hpp',
+  'internal/catch_config_prefix_messages.hpp',
   'internal/catch_config_static_analysis_support.hpp',
   'internal/catch_config_uncaught_exceptions.hpp',
   'internal/catch_config_wchar.hpp',
@@ -173,6 +173,7 @@ internal_headers = [
   'catch_approx.hpp',
   'catch_assertion_info.hpp',
   'catch_assertion_result.hpp',
+  'catch_case_sensitive.hpp',
   'catch_config.hpp',
   'catch_get_random_seed.hpp',
   'catch_message.hpp',
@@ -233,7 +234,6 @@ internal_sources = files(
   'internal/catch_random_seed_generation.cpp',
   'internal/catch_reporter_registry.cpp',
   'internal/catch_reporter_spec_parser.cpp',
-  'internal/catch_result_type.cpp',
   'internal/catch_reusable_string_stream.cpp',
   'internal/catch_run_context.cpp',
   'internal/catch_section.cpp',

src/catch2/reporters/catch_reporter_junit.cpp

@@ -88,7 +88,7 @@ namespace Catch {
             xml( m_stream )
         {
             m_preferences.shouldRedirectStdOut = true;
-            m_preferences.shouldReportAllAssertions = true;
+            m_preferences.shouldReportAllAssertions = false;
             m_shouldStoreSuccesfulAssertions = false;
         }
 
@@ -198,7 +198,7 @@ namespace Catch {
         if( !rootName.empty() )
             name = rootName + '/' + name;
 
-        if( sectionNode.hasAnyAssertions()
+        if ( sectionNode.stats.assertions.total() > 0
            || !sectionNode.stdOut.empty()
            || !sectionNode.stdErr.empty() ) {
             XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );

src/catch2/reporters/catch_reporter_sonarqube.cpp

@@ -73,9 +73,9 @@ namespace Catch {
         if (!rootName.empty())
             name = rootName + '/' + name;
 
-        if ( sectionNode.hasAnyAssertions()
+        if ( sectionNode.stats.assertions.total() > 0
             || !sectionNode.stdOut.empty()
-            ||  !sectionNode.stdErr.empty() ) {
+            || !sectionNode.stdErr.empty() ) {
             XmlWriter::ScopedElement e = xml.scopedElement("testCase");
             xml.writeAttribute("name"_sr, name);
             xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));

src/catch2/reporters/catch_reporter_sonarqube.hpp

@@ -21,7 +21,7 @@ namespace Catch {
         : CumulativeReporterBase(CATCH_MOVE(config))
         , xml(m_stream) {
             m_preferences.shouldRedirectStdOut = true;
-            m_preferences.shouldReportAllAssertions = true;
+            m_preferences.shouldReportAllAssertions = false;
             m_shouldStoreSuccesfulAssertions = false;
         }
 

tests/BUILD.bazel

@@ -0,0 +1,83 @@
+load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test")
+
+package(default_visibility = ["//visibility:public"])
+
+cc_library(
+    name = "catch2_self_test_helper",
+    srcs = ["SelfTest/helpers/parse_test_spec.cpp"],
+    hdrs = [
+        "SelfTest/helpers/parse_test_spec.hpp",
+        "SelfTest/helpers/range_test_helpers.hpp",
+        "SelfTest/helpers/type_with_lit_0_comparisons.hpp",
+    ],
+    includes = ["SelfTest"],
+    deps = [
+        "//:catch2",
+    ],
+)
+
+cc_test(
+    name = "catch2_self_test",
+    size = "small",
+    srcs = [
+        "SelfTest/IntrospectiveTests/Algorithms.tests.cpp",
+        "SelfTest/IntrospectiveTests/Clara.tests.cpp",
+        "SelfTest/IntrospectiveTests/CmdLine.tests.cpp",
+        "SelfTest/IntrospectiveTests/CmdLineHelpers.tests.cpp",
+        "SelfTest/IntrospectiveTests/ColourImpl.tests.cpp",
+        "SelfTest/IntrospectiveTests/Details.tests.cpp",
+        "SelfTest/IntrospectiveTests/FloatingPoint.tests.cpp",
+        "SelfTest/IntrospectiveTests/GeneratorsImpl.tests.cpp",
+        "SelfTest/IntrospectiveTests/Integer.tests.cpp",
+        "SelfTest/IntrospectiveTests/InternalBenchmark.tests.cpp",
+        "SelfTest/IntrospectiveTests/Parse.tests.cpp",
+        "SelfTest/IntrospectiveTests/PartTracker.tests.cpp",
+        "SelfTest/IntrospectiveTests/RandomNumberGeneration.tests.cpp",
+        "SelfTest/IntrospectiveTests/Reporters.tests.cpp",
+        "SelfTest/IntrospectiveTests/Sharding.tests.cpp",
+        "SelfTest/IntrospectiveTests/Stream.tests.cpp",
+        "SelfTest/IntrospectiveTests/String.tests.cpp",
+        "SelfTest/IntrospectiveTests/StringManip.tests.cpp",
+        "SelfTest/IntrospectiveTests/Tag.tests.cpp",
+        "SelfTest/IntrospectiveTests/TestCaseInfoHasher.tests.cpp",
+        "SelfTest/IntrospectiveTests/TestSpec.tests.cpp",
+        "SelfTest/IntrospectiveTests/TestSpecParser.tests.cpp",
+        "SelfTest/IntrospectiveTests/TextFlow.tests.cpp",
+        "SelfTest/IntrospectiveTests/ToString.tests.cpp",
+        "SelfTest/IntrospectiveTests/Traits.tests.cpp",
+        "SelfTest/IntrospectiveTests/UniquePtr.tests.cpp",
+        "SelfTest/IntrospectiveTests/Xml.tests.cpp",
+        "SelfTest/TestRegistrations.cpp",
+        "SelfTest/TimingTests/Sleep.tests.cpp",
+        "SelfTest/UsageTests/Approx.tests.cpp",
+        "SelfTest/UsageTests/BDD.tests.cpp",
+        "SelfTest/UsageTests/Benchmark.tests.cpp",
+        "SelfTest/UsageTests/Class.tests.cpp",
+        "SelfTest/UsageTests/Compilation.tests.cpp",
+        "SelfTest/UsageTests/Condition.tests.cpp",
+        "SelfTest/UsageTests/Decomposition.tests.cpp",
+        "SelfTest/UsageTests/EnumToString.tests.cpp",
+        "SelfTest/UsageTests/Exception.tests.cpp",
+        "SelfTest/UsageTests/Generators.tests.cpp",
+        "SelfTest/UsageTests/Matchers.tests.cpp",
+        "SelfTest/UsageTests/MatchersRanges.tests.cpp",
+        "SelfTest/UsageTests/Message.tests.cpp",
+        "SelfTest/UsageTests/Misc.tests.cpp",
+        "SelfTest/UsageTests/ToStringByte.tests.cpp",
+        "SelfTest/UsageTests/ToStringChrono.tests.cpp",
+        "SelfTest/UsageTests/ToStringGeneral.tests.cpp",
+        "SelfTest/UsageTests/ToStringOptional.tests.cpp",
+        "SelfTest/UsageTests/ToStringPair.tests.cpp",
+        "SelfTest/UsageTests/ToStringTuple.tests.cpp",
+        "SelfTest/UsageTests/ToStringVariant.tests.cpp",
+        "SelfTest/UsageTests/ToStringVector.tests.cpp",
+        "SelfTest/UsageTests/ToStringWhich.tests.cpp",
+        "SelfTest/UsageTests/Tricky.tests.cpp",
+        "SelfTest/UsageTests/VariadicMacros.tests.cpp",
+    ],
+    deps = [
+        ":catch2_self_test_helper",
+        "//:catch2",
+        "//:catch2_main",
+    ],
+)

tests/ExtraTests/CMakeLists.txt

@@ -467,6 +467,18 @@ set_tests_properties(
     PASS_REGULAR_EXPRESSION "Errors occurred during startup!"
 )
 
+add_executable(ReportingCrashWithJunitReporter ${TESTS_DIR}/X36-ReportingCrashWithJunitReporter.cpp)
+target_link_libraries(ReportingCrashWithJunitReporter PRIVATE Catch2::Catch2WithMain)
+add_test(
+  NAME Reporters::CrashInJunitReporter
+  COMMAND ${CMAKE_COMMAND} -E env $<TARGET_FILE:ReportingCrashWithJunitReporter> --reporter JUnit
+)
+set_tests_properties(
+    Reporters::CrashInJunitReporter
+  PROPERTIES
+    PASS_REGULAR_EXPRESSION "</testsuites>"
+    LABELS "uses-signals"
+)
 
 add_executable(AssertionStartingEventGoesBeforeAssertionIsEvaluated
   X20-AssertionStartingEventGoesBeforeAssertionIsEvaluated.cpp

tests/ExtraTests/X02-DisabledMacros.cpp

@@ -11,34 +11,28 @@
  * and expressions in assertion macros are not run.
  */
 
-
-#include <catch2/catch_test_macros.hpp>
 #include <catch2/benchmark/catch_benchmark.hpp>
+#include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers.hpp>
 #include <catch2/matchers/catch_matchers_predicate.hpp>
 
 #include <iostream>
 
 struct foo {
-    foo(){
-        REQUIRE_NOTHROW( print() );
-    }
-    void print() const {
-        std::cout << "This should not happen\n";
-    }
+    foo() { REQUIRE_NOTHROW( print() ); }
+    void print() const { std::cout << "This should not happen\n"; }
 };
 
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wglobal-constructors"
+#if defined( __clang__ )
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wglobal-constructors"
 #endif
 // Construct foo, but `foo::print` should not be run
 static foo f;
 
-
-#if defined(__clang__)
+#if defined( __clang__ )
 // The test is unused since the registration is disabled
-#pragma clang diagnostic ignored "-Wunused-function"
+#    pragma clang diagnostic ignored "-Wunused-function"
 #endif
 
 // This test should not be run, because it won't be registered
@@ -60,6 +54,26 @@ TEST_CASE( "Disabled Macros" ) {
     BENCHMARK( "Disabled benchmark" ) { REQUIRE( 1 == 2 ); };
 }
 
-#if defined(__clang__)
-#pragma clang diagnostic pop
+struct DisabledFixture {};
+
+TEST_CASE_PERSISTENT_FIXTURE( DisabledFixture, "Disabled Persistent Fixture" ) {
+    CHECK( 1 == 2 );
+    REQUIRE( 1 == 2 );
+    std::cout << "This should not happen\n";
+    FAIL();
+
+    // Test that static assertions don't fire when macros are disabled
+    STATIC_CHECK( 0 == 1 );
+    STATIC_REQUIRE( !true );
+
+    CAPTURE( 1 );
+    CAPTURE( 1, "captured" );
+
+    REQUIRE_THAT( 1,
+                  Catch::Matchers::Predicate( []( int ) { return false; } ) );
+    BENCHMARK( "Disabled benchmark" ) { REQUIRE( 1 == 2 ); };
+}
+
+#if defined( __clang__ )
+#    pragma clang diagnostic pop
 #endif

tests/ExtraTests/X36-ReportingCrashWithJunitReporter.cpp

@@ -0,0 +1,32 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+/**\file
+ * Checks that signals/SEH within open section does not hard crash JUnit
+ * (or similar reporter) while we are trying to report fatal error.
+ */
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <csignal>
+
+// On Windows we need to send SEH and not signal to test the
+// RunContext::handleFatalErrorCondition code path
+#if defined( _MSC_VER )
+#    include <windows.h>
+#endif
+
+TEST_CASE( "raises signal" ) {
+    SECTION( "section" ) {
+#if defined( _MSC_VER )
+        RaiseException( 0xC0000005, 0, 0, NULL );
+#else
+        std::raise( SIGILL );
+#endif
+    }
+}

tests/SelfTest/Baselines/automake.sw.approved.txt

@@ -68,6 +68,8 @@ Nor would this
 :test-result: PASS A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6
 :test-result: FAIL A TEST_CASE_METHOD based test run that fails
 :test-result: PASS A TEST_CASE_METHOD based test run that succeeds
+:test-result: FAIL A TEST_CASE_PERSISTENT_FIXTURE based test run that fails
+:test-result: PASS A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds
 :test-result: PASS A Template product test case - Foo<float>
 :test-result: PASS A Template product test case - Foo<int>
 :test-result: PASS A Template product test case - std::vector<float>
@@ -103,6 +105,7 @@ Nor would this
 :test-result: PASS CaseInsensitiveEqualsTo is case insensitive
 :test-result: PASS CaseInsensitiveLess is case insensitive
 :test-result: PASS Character pretty printing
+:test-result: PASS Clara::Arg does not crash on incomplete input
 :test-result: PASS Clara::Arg supports single-arg parse the way Opt does
 :test-result: PASS Clara::Opt supports accept-many lambdas
 :test-result: PASS ColourGuard behaviour
@@ -354,7 +357,6 @@ b1!
 :test-result: FAIL nested sections can be skipped dynamically at runtime
 :test-result: PASS non streamable - with conv. op
 :test-result: PASS non-copyable objects
-:test-result: PASS normal_cdf
 :test-result: PASS normal_quantile
 :test-result: PASS not allowed
 :test-result: FAIL not prints unscoped info from previous failures

tests/SelfTest/Baselines/automake.sw.multi.approved.txt

@@ -66,6 +66,8 @@
 :test-result: PASS A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6
 :test-result: FAIL A TEST_CASE_METHOD based test run that fails
 :test-result: PASS A TEST_CASE_METHOD based test run that succeeds
+:test-result: FAIL A TEST_CASE_PERSISTENT_FIXTURE based test run that fails
+:test-result: PASS A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds
 :test-result: PASS A Template product test case - Foo<float>
 :test-result: PASS A Template product test case - Foo<int>
 :test-result: PASS A Template product test case - std::vector<float>
@@ -101,6 +103,7 @@
 :test-result: PASS CaseInsensitiveEqualsTo is case insensitive
 :test-result: PASS CaseInsensitiveLess is case insensitive
 :test-result: PASS Character pretty printing
+:test-result: PASS Clara::Arg does not crash on incomplete input
 :test-result: PASS Clara::Arg supports single-arg parse the way Opt does
 :test-result: PASS Clara::Opt supports accept-many lambdas
 :test-result: PASS ColourGuard behaviour
@@ -343,7 +346,6 @@
 :test-result: FAIL nested sections can be skipped dynamically at runtime
 :test-result: PASS non streamable - with conv. op
 :test-result: PASS non-copyable objects
-:test-result: PASS normal_cdf
 :test-result: PASS normal_quantile
 :test-result: PASS not allowed
 :test-result: FAIL not prints unscoped info from previous failures

tests/SelfTest/Baselines/compact.sw.approved.txt

@@ -241,6 +241,10 @@ Class.tests.cpp:<line number>: passed: Nttp_Fixture<V>::value > 0 for: 3 > 0
 Class.tests.cpp:<line number>: passed: Nttp_Fixture<V>::value > 0 for: 6 > 0
 Class.tests.cpp:<line number>: failed: m_a == 2 for: 1 == 2
 Class.tests.cpp:<line number>: passed: m_a == 1 for: 1 == 1
+Class.tests.cpp:<line number>: passed: m_a++ == 0 for: 0 == 0
+Class.tests.cpp:<line number>: failed: m_a == 0 for: 1 == 0
+Class.tests.cpp:<line number>: passed: m_a++ == 0 for: 0 == 0
+Class.tests.cpp:<line number>: passed: m_a == 1 for: 1 == 1
 Misc.tests.cpp:<line number>: passed: x.size() == 0 for: 0 == 0
 Misc.tests.cpp:<line number>: passed: x.size() == 0 for: 0 == 0
 Misc.tests.cpp:<line number>: passed: x.size() == 0 for: 0 == 0
@@ -249,12 +253,22 @@ Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 42 > 0
 Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 9 > 0
 Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 42 > 0
 Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 9 > 0
-Approx.tests.cpp:<line number>: passed: d == 1.23_a for: 1.23 == Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: d != 1.22_a for: 1.23 != Approx( 1.22 )
-Approx.tests.cpp:<line number>: passed: -d == -1.23_a for: -1.23 == Approx( -1.23 )
-Approx.tests.cpp:<line number>: passed: d == 1.2_a .epsilon(.1) for: 1.23 == Approx( 1.2 )
-Approx.tests.cpp:<line number>: passed: d != 1.2_a .epsilon(.001) for: 1.23 != Approx( 1.2 )
-Approx.tests.cpp:<line number>: passed: d == 1_a .epsilon(.3) for: 1.23 == Approx( 1.0 )
+Approx.tests.cpp:<line number>: passed: d == 1.23_a for: 1.22999999999999998
+==
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: d != 1.22_a for: 1.22999999999999998
+!=
+Approx( 1.21999999999999997 )
+Approx.tests.cpp:<line number>: passed: -d == -1.23_a for: -1.22999999999999998
+==
+Approx( -1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: d == 1.2_a .epsilon(.1) for: 1.22999999999999998
+==
+Approx( 1.19999999999999996 )
+Approx.tests.cpp:<line number>: passed: d != 1.2_a .epsilon(.001) for: 1.22999999999999998
+!=
+Approx( 1.19999999999999996 )
+Approx.tests.cpp:<line number>: passed: d == 1_a .epsilon(.3) for: 1.22999999999999998 == Approx( 1.0 )
 Misc.tests.cpp:<line number>: passed: with 1 message: 'that's not flying - that's failing in style'
 Misc.tests.cpp:<line number>: failed: explicitly with 1 message: 'to infinity and beyond'
 Tricky.tests.cpp:<line number>: failed: &o1 == &o2 for: 0x<hex digits> == 0x<hex digits>
@@ -263,8 +277,8 @@ Approx.tests.cpp:<line number>: passed: 104.0 != Approx(100.0) for: 104.0 != App
 Approx.tests.cpp:<line number>: passed: 104.0 == Approx(100.0).margin(5) for: 104.0 == Approx( 100.0 )
 Approx.tests.cpp:<line number>: passed: 104.0 == Approx(100.0).margin(4) for: 104.0 == Approx( 100.0 )
 Approx.tests.cpp:<line number>: passed: 104.0 != Approx(100.0).margin(3) for: 104.0 != Approx( 100.0 )
-Approx.tests.cpp:<line number>: passed: 100.3 != Approx(100.0) for: 100.3 != Approx( 100.0 )
-Approx.tests.cpp:<line number>: passed: 100.3 == Approx(100.0).margin(0.5) for: 100.3 == Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 100.3 != Approx(100.0) for: 100.29999999999999716 != Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 100.3 == Approx(100.0).margin(0.5) for: 100.29999999999999716 == Approx( 100.0 )
 Tricky.tests.cpp:<line number>: passed: i++ == 7 for: 7 == 7
 Tricky.tests.cpp:<line number>: passed: i++ == 8 for: 8 == 8
 Exception.tests.cpp:<line number>: passed: 1 == 1
@@ -282,19 +296,33 @@ Approx.tests.cpp:<line number>: passed: 0.0f == Approx(0.25f).margin(0.25f) for:
 Approx.tests.cpp:<line number>: passed: 0.5f == Approx(0.25f).margin(0.25f) for: 0.5f == Approx( 0.25 )
 Approx.tests.cpp:<line number>: passed: 245.0f == Approx(245.25f).margin(0.25f) for: 245.0f == Approx( 245.25 )
 Approx.tests.cpp:<line number>: passed: 245.5f == Approx(245.25f).margin(0.25f) for: 245.5f == Approx( 245.25 )
-Approx.tests.cpp:<line number>: passed: divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) for: 3.1428571429 == Approx( 3.141 )
-Approx.tests.cpp:<line number>: passed: divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) for: 3.1428571429 != Approx( 3.141 )
-Approx.tests.cpp:<line number>: passed: d != Approx( 1.231 ) for: 1.23 != Approx( 1.231 )
-Approx.tests.cpp:<line number>: passed: d == Approx( 1.231 ).epsilon( 0.1 ) for: 1.23 == Approx( 1.231 )
-Approx.tests.cpp:<line number>: passed: 1.23f == Approx( 1.23f ) for: 1.23f == Approx( 1.2300000191 )
+Approx.tests.cpp:<line number>: passed: divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) for: 3.14285714285714279
+==
+Approx( 3.14100000000000001 )
+Approx.tests.cpp:<line number>: passed: divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) for: 3.14285714285714279
+!=
+Approx( 3.14100000000000001 )
+Approx.tests.cpp:<line number>: passed: d != Approx( 1.231 ) for: 1.22999999999999998
+!=
+Approx( 1.23100000000000009 )
+Approx.tests.cpp:<line number>: passed: d == Approx( 1.231 ).epsilon( 0.1 ) for: 1.22999999999999998
+==
+Approx( 1.23100000000000009 )
+Approx.tests.cpp:<line number>: passed: 1.23f == Approx( 1.23f ) for: 1.230000019f
+==
+Approx( 1.23000001907348633 )
 Approx.tests.cpp:<line number>: passed: 0.0f == Approx( 0.0f ) for: 0.0f == Approx( 0.0 )
 Approx.tests.cpp:<line number>: passed: 1 == Approx( 1 ) for: 1 == Approx( 1.0 )
 Approx.tests.cpp:<line number>: passed: 0 == Approx( 0 ) for: 0 == Approx( 0.0 )
 Approx.tests.cpp:<line number>: passed: 1.0f == Approx( 1 ) for: 1.0f == Approx( 1.0 )
 Approx.tests.cpp:<line number>: passed: 0 == Approx( dZero) for: 0 == Approx( 0.0 )
 Approx.tests.cpp:<line number>: passed: 0 == Approx( dSmall ).margin( 0.001 ) for: 0 == Approx( 0.00001 )
-Approx.tests.cpp:<line number>: passed: 1.234f == Approx( dMedium ) for: 1.234f == Approx( 1.234 )
-Approx.tests.cpp:<line number>: passed: dMedium == Approx( 1.234f ) for: 1.234 == Approx( 1.2339999676 )
+Approx.tests.cpp:<line number>: passed: 1.234f == Approx( dMedium ) for: 1.233999968f
+==
+Approx( 1.23399999999999999 )
+Approx.tests.cpp:<line number>: passed: dMedium == Approx( 1.234f ) for: 1.23399999999999999
+==
+Approx( 1.23399996757507324 )
 Matchers.tests.cpp:<line number>: passed: 1, Predicate<int>( alwaysTrue, "always true" ) for: 1 matches predicate: "always true"
 Matchers.tests.cpp:<line number>: passed: 1, !Predicate<int>( alwaysFalse, "always false" ) for: 1 not matches predicate: "always false"
 Matchers.tests.cpp:<line number>: passed: "Hello olleH", Predicate<std::string>( []( std::string const& str ) -> bool { return str.front() == str.back(); }, "First and last character should be equal" ) for: "Hello olleH" matches predicate: "First and last character should be equal"
@@ -361,6 +389,12 @@ ToStringGeneral.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( '\0
 ToStringGeneral.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( static_cast<char>(2) ) == "2" for: "2" == "2"
 ToStringGeneral.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( static_cast<char>(5) ) == "5" for: "5" == "5"
 Clara.tests.cpp:<line number>: passed: name.empty() for: true
+Clara.tests.cpp:<line number>: passed: result for: {?}
+Clara.tests.cpp:<line number>: passed: result.type() == Catch::Clara::Detail::ResultType::Ok for: 0 == 0
+Clara.tests.cpp:<line number>: passed: parsed.type() == Catch::Clara::ParseResultType::NoMatch for: 1 == 1
+Clara.tests.cpp:<line number>: passed: parsed.remainingTokens().count() == 2 for: 2 == 2
+Clara.tests.cpp:<line number>: passed: name.empty() for: true
+Clara.tests.cpp:<line number>: passed: name.empty() for: true
 Clara.tests.cpp:<line number>: passed: name == "foo" for: "foo" == "foo"
 Clara.tests.cpp:<line number>: passed: !(parse_result) for: !{?}
 Clara.tests.cpp:<line number>: passed: parse_result for: {?}
@@ -509,7 +543,7 @@ Stream.tests.cpp:<line number>: passed: Catch::makeStream( "-" )->isConsole() fo
 Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'custom exception - not std'; expression was: throwCustom()
 Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'custom exception - not std'; expression was: throwCustom(), std::exception
 Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'custom std exception'
-Approx.tests.cpp:<line number>: passed: 101.000001 != Approx(100).epsilon(0.01) for: 101.000001 != Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 101.000001 != Approx(100).epsilon(0.01) for: 101.00000099999999748 != Approx( 100.0 )
 Approx.tests.cpp:<line number>: passed: std::pow(10, -5) != Approx(std::pow(10, -7)) for: 0.00001 != Approx( 0.0000001 )
 ToString.tests.cpp:<line number>: passed: enumInfo->lookup(0) == "Value1" for: Value1 == "Value1"
 ToString.tests.cpp:<line number>: passed: enumInfo->lookup(1) == "Value2" for: Value2 == "Value2"
@@ -529,27 +563,39 @@ EnumToString.tests.cpp:<line number>: passed: stringify( EnumClass3::Value4 ) ==
 EnumToString.tests.cpp:<line number>: passed: stringify( ec3 ) == "Value2" for: "Value2" == "Value2"
 EnumToString.tests.cpp:<line number>: passed: stringify( Bikeshed::Colours::Red ) == "Red" for: "Red" == "Red"
 EnumToString.tests.cpp:<line number>: passed: stringify( Bikeshed::Colours::Blue ) == "Blue" for: "Blue" == "Blue"
-Approx.tests.cpp:<line number>: passed: 101.01 != Approx(100).epsilon(0.01) for: 101.01 != Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 101.01 != Approx(100).epsilon(0.01) for: 101.01000000000000512 != Approx( 100.0 )
 Condition.tests.cpp:<line number>: failed: data.int_seven == 6 for: 7 == 6
 Condition.tests.cpp:<line number>: failed: data.int_seven == 8 for: 7 == 8
 Condition.tests.cpp:<line number>: failed: data.int_seven == 0 for: 7 == 0
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 9.11f ) for: 9.1f == Approx( 9.1099996567 )
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 9.0f ) for: 9.1f == Approx( 9.0 )
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 1 ) for: 9.1f == Approx( 1.0 )
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 0 ) for: 9.1f == Approx( 0.0 )
-Condition.tests.cpp:<line number>: failed: data.double_pi == Approx( 3.1415 ) for: 3.1415926535 == Approx( 3.1415 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 9.11f ) for: 9.100000381f
+==
+Approx( 9.10999965667724609 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 9.0f ) for: 9.100000381f == Approx( 9.0 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 1 ) for: 9.100000381f == Approx( 1.0 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 0 ) for: 9.100000381f == Approx( 0.0 )
+Condition.tests.cpp:<line number>: failed: data.double_pi == Approx( 3.1415 ) for: 3.14159265350000005
+==
+Approx( 3.14150000000000018 )
 Condition.tests.cpp:<line number>: failed: data.str_hello == "goodbye" for: "hello" == "goodbye"
 Condition.tests.cpp:<line number>: failed: data.str_hello == "hell" for: "hello" == "hell"
 Condition.tests.cpp:<line number>: failed: data.str_hello == "hello1" for: "hello" == "hello1"
 Condition.tests.cpp:<line number>: failed: data.str_hello.size() == 6 for: 5 == 6
-Condition.tests.cpp:<line number>: failed: x == Approx( 1.301 ) for: 1.3 == Approx( 1.301 )
+Condition.tests.cpp:<line number>: failed: x == Approx( 1.301 ) for: 1.30000000000000027
+==
+Approx( 1.30099999999999993 )
 Condition.tests.cpp:<line number>: passed: data.int_seven == 7 for: 7 == 7
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one == Approx( 9.1f ) for: 9.1f == Approx( 9.1000003815 )
-Condition.tests.cpp:<line number>: passed: data.double_pi == Approx( 3.1415926535 ) for: 3.1415926535 == Approx( 3.1415926535 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one == Approx( 9.1f ) for: 9.100000381f
+==
+Approx( 9.10000038146972656 )
+Condition.tests.cpp:<line number>: passed: data.double_pi == Approx( 3.1415926535 ) for: 3.14159265350000005
+==
+Approx( 3.14159265350000005 )
 Condition.tests.cpp:<line number>: passed: data.str_hello == "hello" for: "hello" == "hello"
 Condition.tests.cpp:<line number>: passed: "hello" == data.str_hello for: "hello" == "hello"
 Condition.tests.cpp:<line number>: passed: data.str_hello.size() == 5 for: 5 == 5
-Condition.tests.cpp:<line number>: passed: x == Approx( 1.3 ) for: 1.3 == Approx( 1.3 )
+Condition.tests.cpp:<line number>: passed: x == Approx( 1.3 ) for: 1.30000000000000027
+==
+Approx( 1.30000000000000004 )
 Matchers.tests.cpp:<line number>: passed: testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) for: "this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring"
 Matchers.tests.cpp:<line number>: passed: testStringForMatching(), Equals( "this string contains 'ABC' as a substring", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring" (case insensitive)
 Matchers.tests.cpp:<line number>: failed: testStringForMatching(), Equals( "this string contains 'ABC' as a substring" ) for: "this string contains 'abc' as a substring" equals: "this string contains 'ABC' as a substring"
@@ -596,21 +642,21 @@ Misc.tests.cpp:<line number>: passed: Factorial(2) == 2 for: 2 == 2
 Misc.tests.cpp:<line number>: passed: Factorial(3) == 6 for: 6 == 6
 Misc.tests.cpp:<line number>: passed: Factorial(10) == 3628800 for: 3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
 GeneratorsImpl.tests.cpp:<line number>: passed: filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
-Matchers.tests.cpp:<line number>: passed: 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.1 are within 10% of each other
-Matchers.tests.cpp:<line number>: passed: 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.2 are within 10% of each other
-Matchers.tests.cpp:<line number>: passed: 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0 are within 99% of each other
-Matchers.tests.cpp:<line number>: passed: -0., WithinRel( 0. ) for: -0.0 and 0 are within 2.22045e-12% of each other
-Matchers.tests.cpp:<line number>: passed: v1, WithinRel( v2 ) for: 0.0 and 2.22507e-308 are within 2.22045e-12% of each other
+Matchers.tests.cpp:<line number>: passed: 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.09999999999999964 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.19999999999999929 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0.0 are within 99% of each other
+Matchers.tests.cpp:<line number>: passed: -0., WithinRel( 0. ) for: -0.0 and 0.0 are within 2.22045e-12% of each other
+Matchers.tests.cpp:<line number>: passed: v1, WithinRel( v2 ) for: 0.0 and 0.0 are within 2.22045e-12% of each other
 Matchers.tests.cpp:<line number>: passed: 1., WithinAbs( 1., 0 ) for: 1.0 is within 0.0 of 1.0
 Matchers.tests.cpp:<line number>: passed: 0., WithinAbs( 1., 1 ) for: 0.0 is within 1.0 of 1.0
-Matchers.tests.cpp:<line number>: passed: 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0
-Matchers.tests.cpp:<line number>: passed: 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.98999999999999999 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.98999999999999999 of 1.0
 Matchers.tests.cpp:<line number>: passed: 11., !WithinAbs( 10., 0.5 ) for: 11.0 not is within 0.5 of 10.0
 Matchers.tests.cpp:<line number>: passed: 10., !WithinAbs( 11., 0.5 ) for: 10.0 not is within 0.5 of 11.0
 Matchers.tests.cpp:<line number>: passed: -10., WithinAbs( -10., 0.5 ) for: -10.0 is within 0.5 of -10.0
-Matchers.tests.cpp:<line number>: passed: -10., WithinAbs( -9.6, 0.5 ) for: -10.0 is within 0.5 of -9.6
+Matchers.tests.cpp:<line number>: passed: -10., WithinAbs( -9.6, 0.5 ) for: -10.0 is within 0.5 of -9.59999999999999964
 Matchers.tests.cpp:<line number>: passed: 1., WithinULP( 1., 0 ) for: 1.0 is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00])
-Matchers.tests.cpp:<line number>: passed: nextafter( 1., 2. ), WithinULP( 1., 1 ) for: 1.0 is within 1 ULPs of 1.0000000000000000e+00 ([9.9999999999999989e-01, 1.0000000000000002e+00])
+Matchers.tests.cpp:<line number>: passed: nextafter( 1., 2. ), WithinULP( 1., 1 ) for: 1.00000000000000022 is within 1 ULPs of 1.0000000000000000e+00 ([9.9999999999999989e-01, 1.0000000000000002e+00])
 Matchers.tests.cpp:<line number>: passed: 0., WithinULP( nextafter( 0., 1. ), 1 ) for: 0.0 is within 1 ULPs of 4.9406564584124654e-324 ([0.0000000000000000e+00, 9.8813129168249309e-324])
 Matchers.tests.cpp:<line number>: passed: 1., WithinULP( nextafter( 1., 0. ), 1 ) for: 1.0 is within 1 ULPs of 9.9999999999999989e-01 ([9.9999999999999978e-01, 1.0000000000000000e+00])
 Matchers.tests.cpp:<line number>: passed: 1., !WithinULP( nextafter( 1., 2. ), 0 ) for: 1.0 not is within 0 ULPs of 1.0000000000000002e+00 ([1.0000000000000002e+00, 1.0000000000000002e+00])
@@ -618,7 +664,7 @@ Matchers.tests.cpp:<line number>: passed: 1., WithinULP( 1., 0 ) for: 1.0 is wit
 Matchers.tests.cpp:<line number>: passed: -0., WithinULP( 0., 0 ) for: -0.0 is within 0 ULPs of 0.0000000000000000e+00 ([0.0000000000000000e+00, 0.0000000000000000e+00])
 Matchers.tests.cpp:<line number>: passed: 1., WithinAbs( 1., 0.5 ) || WithinULP( 2., 1 ) for: 1.0 ( is within 0.5 of 1.0 or is within 1 ULPs of 2.0000000000000000e+00 ([1.9999999999999998e+00, 2.0000000000000004e+00]) )
 Matchers.tests.cpp:<line number>: passed: 1., WithinAbs( 2., 0.5 ) || WithinULP( 1., 0 ) for: 1.0 ( is within 0.5 of 2.0 or is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00]) )
-Matchers.tests.cpp:<line number>: passed: 0.0001, WithinAbs( 0., 0.001 ) || WithinRel( 0., 0.1 ) for: 0.0001 ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+Matchers.tests.cpp:<line number>: passed: 0.0001, WithinAbs( 0., 0.001 ) || WithinRel( 0., 0.1 ) for: 0.0001 ( is within 0.001 of 0.0 or and 0.0 are within 10% of each other )
 Matchers.tests.cpp:<line number>: passed: WithinAbs( 1., 0. )
 Matchers.tests.cpp:<line number>: passed: WithinAbs( 1., -1. ), std::domain_error
 Matchers.tests.cpp:<line number>: passed: WithinULP( 1., 0 )
@@ -626,23 +672,23 @@ Matchers.tests.cpp:<line number>: passed: WithinRel( 1., 0. )
 Matchers.tests.cpp:<line number>: passed: WithinRel( 1., -0.2 ), std::domain_error
 Matchers.tests.cpp:<line number>: passed: WithinRel( 1., 1. ), std::domain_error
 Matchers.tests.cpp:<line number>: passed: 1., !IsNaN() for: 1.0 not is NaN
-Matchers.tests.cpp:<line number>: passed: 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.1 are within 10% of each other
-Matchers.tests.cpp:<line number>: passed: 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.2 are within 10% of each other
-Matchers.tests.cpp:<line number>: passed: 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0 are within 99% of each other
-Matchers.tests.cpp:<line number>: passed: -0.f, WithinRel( 0.f ) for: -0.0f and 0 are within 0.00119209% of each other
-Matchers.tests.cpp:<line number>: passed: v1, WithinRel( v2 ) for: 0.0f and 1.17549e-38 are within 0.00119209% of each other
+Matchers.tests.cpp:<line number>: passed: 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.10000038146972656 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.19999980926513672 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0.0 are within 99% of each other
+Matchers.tests.cpp:<line number>: passed: -0.f, WithinRel( 0.f ) for: -0.0f and 0.0 are within 0.00119209% of each other
+Matchers.tests.cpp:<line number>: passed: v1, WithinRel( v2 ) for: 0.0f and 0.0 are within 0.00119209% of each other
 Matchers.tests.cpp:<line number>: passed: 1.f, WithinAbs( 1.f, 0 ) for: 1.0f is within 0.0 of 1.0
 Matchers.tests.cpp:<line number>: passed: 0.f, WithinAbs( 1.f, 1 ) for: 0.0f is within 1.0 of 1.0
-Matchers.tests.cpp:<line number>: passed: 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0
-Matchers.tests.cpp:<line number>: passed: 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.99000000953674316 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.99000000953674316 of 1.0
 Matchers.tests.cpp:<line number>: passed: 0.f, WithinAbs( -0.f, 0 ) for: 0.0f is within 0.0 of -0.0
 Matchers.tests.cpp:<line number>: passed: 11.f, !WithinAbs( 10.f, 0.5f ) for: 11.0f not is within 0.5 of 10.0
 Matchers.tests.cpp:<line number>: passed: 10.f, !WithinAbs( 11.f, 0.5f ) for: 10.0f not is within 0.5 of 11.0
 Matchers.tests.cpp:<line number>: passed: -10.f, WithinAbs( -10.f, 0.5f ) for: -10.0f is within 0.5 of -10.0
-Matchers.tests.cpp:<line number>: passed: -10.f, WithinAbs( -9.6f, 0.5f ) for: -10.0f is within 0.5 of -9.6000003815
+Matchers.tests.cpp:<line number>: passed: -10.f, WithinAbs( -9.6f, 0.5f ) for: -10.0f is within 0.5 of -9.60000038146972656
 Matchers.tests.cpp:<line number>: passed: 1.f, WithinULP( 1.f, 0 ) for: 1.0f is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00])
 Matchers.tests.cpp:<line number>: passed: -1.f, WithinULP( -1.f, 0 ) for: -1.0f is within 0 ULPs of -1.00000000e+00f ([-1.00000000e+00, -1.00000000e+00])
-Matchers.tests.cpp:<line number>: passed: nextafter( 1.f, 2.f ), WithinULP( 1.f, 1 ) for: 1.0f is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00])
+Matchers.tests.cpp:<line number>: passed: nextafter( 1.f, 2.f ), WithinULP( 1.f, 1 ) for: 1.000000119f is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00])
 Matchers.tests.cpp:<line number>: passed: 0.f, WithinULP( nextafter( 0.f, 1.f ), 1 ) for: 0.0f is within 1 ULPs of 1.40129846e-45f ([0.00000000e+00, 2.80259693e-45])
 Matchers.tests.cpp:<line number>: passed: 1.f, WithinULP( nextafter( 1.f, 0.f ), 1 ) for: 1.0f is within 1 ULPs of 9.99999940e-01f ([9.99999881e-01, 1.00000000e+00])
 Matchers.tests.cpp:<line number>: passed: 1.f, !WithinULP( nextafter( 1.f, 2.f ), 0 ) for: 1.0f not is within 0 ULPs of 1.00000012e+00f ([1.00000012e+00, 1.00000012e+00])
@@ -650,7 +696,7 @@ Matchers.tests.cpp:<line number>: passed: 1.f, WithinULP( 1.f, 0 ) for: 1.0f is
 Matchers.tests.cpp:<line number>: passed: -0.f, WithinULP( 0.f, 0 ) for: -0.0f is within 0 ULPs of 0.00000000e+00f ([0.00000000e+00, 0.00000000e+00])
 Matchers.tests.cpp:<line number>: passed: 1.f, WithinAbs( 1.f, 0.5 ) || WithinULP( 1.f, 1 ) for: 1.0f ( is within 0.5 of 1.0 or is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00]) )
 Matchers.tests.cpp:<line number>: passed: 1.f, WithinAbs( 2.f, 0.5 ) || WithinULP( 1.f, 0 ) for: 1.0f ( is within 0.5 of 2.0 or is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00]) )
-Matchers.tests.cpp:<line number>: passed: 0.0001f, WithinAbs( 0.f, 0.001f ) || WithinRel( 0.f, 0.1f ) for: 0.0001f ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+Matchers.tests.cpp:<line number>: passed: 0.0001f, WithinAbs( 0.f, 0.001f ) || WithinRel( 0.f, 0.1f ) for: 0.0001f ( is within 0.00100000004749745 of 0.0 or and 0.0 are within 10% of each other )
 Matchers.tests.cpp:<line number>: passed: WithinAbs( 1.f, 0.f )
 Matchers.tests.cpp:<line number>: passed: WithinAbs( 1.f, -1.f ), std::domain_error
 Matchers.tests.cpp:<line number>: passed: WithinULP( 1.f, 0 )
@@ -830,68 +876,122 @@ GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 5 for: 5 == 5
 GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.9 == Approx( -0.9 ) with 1 message: 'Current expected value is -0.9'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.90000000000000002
+==
+Approx( -0.90000000000000002 ) with 1 message: 'Current expected value is -0.9'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.9'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.8 == Approx( -0.8 ) with 1 message: 'Current expected value is -0.8'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.80000000000000004
+==
+Approx( -0.80000000000000004 ) with 1 message: 'Current expected value is -0.8'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.8'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.70000000000000007
+==
+Approx( -0.70000000000000007 ) with 1 message: 'Current expected value is -0.7'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.7'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.6 == Approx( -0.6 ) with 1 message: 'Current expected value is -0.6'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.60000000000000009
+==
+Approx( -0.60000000000000009 ) with 1 message: 'Current expected value is -0.6'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.6'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.5 == Approx( -0.5 ) with 1 message: 'Current expected value is -0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.50000000000000011
+==
+Approx( -0.50000000000000011 ) with 1 message: 'Current expected value is -0.5'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.5'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.40000000000000013
+==
+Approx( -0.40000000000000013 ) with 1 message: 'Current expected value is -0.4'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.4'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.3 == Approx( -0.3 ) with 1 message: 'Current expected value is -0.3'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.30000000000000016
+==
+Approx( -0.30000000000000016 ) with 1 message: 'Current expected value is -0.3'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.3'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.2 == Approx( -0.2 ) with 1 message: 'Current expected value is -0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.20000000000000015
+==
+Approx( -0.20000000000000015 ) with 1 message: 'Current expected value is -0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.2'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.10000000000000014
+==
+Approx( -0.10000000000000014 ) with 1 message: 'Current expected value is -0.1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.0 == Approx( -0.0 ) with 1 message: 'Current expected value is -1.38778e-16'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.00000000000000014
+==
+Approx( -0.00000000000000014 ) with 1 message: 'Current expected value is -1.38778e-16'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1.38778e-16'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.1 == Approx( 0.1 ) with 1 message: 'Current expected value is 0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.09999999999999987
+==
+Approx( 0.09999999999999987 ) with 1 message: 'Current expected value is 0.1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.19999999999999987
+==
+Approx( 0.19999999999999987 ) with 1 message: 'Current expected value is 0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.2'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.3 == Approx( 0.3 ) with 1 message: 'Current expected value is 0.3'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.29999999999999988
+==
+Approx( 0.29999999999999988 ) with 1 message: 'Current expected value is 0.3'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.3'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.4 == Approx( 0.4 ) with 1 message: 'Current expected value is 0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.39999999999999991
+==
+Approx( 0.39999999999999991 ) with 1 message: 'Current expected value is 0.4'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.4'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.49999999999999989
+==
+Approx( 0.49999999999999989 ) with 1 message: 'Current expected value is 0.5'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.5'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.6 == Approx( 0.6 ) with 1 message: 'Current expected value is 0.6'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.59999999999999987
+==
+Approx( 0.59999999999999987 ) with 1 message: 'Current expected value is 0.6'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.6'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.7 == Approx( 0.7 ) with 1 message: 'Current expected value is 0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.69999999999999984
+==
+Approx( 0.69999999999999984 ) with 1 message: 'Current expected value is 0.7'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.7'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.8 == Approx( 0.8 ) with 1 message: 'Current expected value is 0.8'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.79999999999999982
+==
+Approx( 0.79999999999999982 ) with 1 message: 'Current expected value is 0.8'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.8'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.9 == Approx( 0.9 ) with 1 message: 'Current expected value is 0.9'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.8999999999999998
+==
+Approx( 0.8999999999999998 ) with 1 message: 'Current expected value is 0.9'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.9'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx( rangeEnd ) for: 1.0 == Approx( 1.0 )
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx( rangeEnd ) for: 0.99999999999999978 == Approx( 1.0 )
 GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.69999999999999996
+==
+Approx( -0.69999999999999996 ) with 1 message: 'Current expected value is -0.7'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.7'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.39999999999999997
+==
+Approx( -0.39999999999999997 ) with 1 message: 'Current expected value is -0.4'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.4'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.09999999999999998
+==
+Approx( -0.09999999999999998 ) with 1 message: 'Current expected value is -0.1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.20000000000000001
+==
+Approx( 0.20000000000000001 ) with 1 message: 'Current expected value is 0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.5'
 GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.69999999999999996
+==
+Approx( -0.69999999999999996 ) with 1 message: 'Current expected value is -0.7'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.7'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.39999999999999997
+==
+Approx( -0.39999999999999997 ) with 1 message: 'Current expected value is -0.4'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.4'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.09999999999999998
+==
+Approx( -0.09999999999999998 ) with 1 message: 'Current expected value is -0.1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.20000000000000001
+==
+Approx( 0.20000000000000001 ) with 1 message: 'Current expected value is 0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.5'
@@ -922,10 +1022,18 @@ GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -4 for: -4 == -4
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -7 for: -7 == -7
 GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
-Approx.tests.cpp:<line number>: passed: d >= Approx( 1.22 ) for: 1.23 >= Approx( 1.22 )
-Approx.tests.cpp:<line number>: passed: d >= Approx( 1.23 ) for: 1.23 >= Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: !(d >= Approx( 1.24 )) for: !(1.23 >= Approx( 1.24 ))
-Approx.tests.cpp:<line number>: passed: d >= Approx( 1.24 ).epsilon(0.1) for: 1.23 >= Approx( 1.24 )
+Approx.tests.cpp:<line number>: passed: d >= Approx( 1.22 ) for: 1.22999999999999998
+>=
+Approx( 1.21999999999999997 )
+Approx.tests.cpp:<line number>: passed: d >= Approx( 1.23 ) for: 1.22999999999999998
+>=
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: !(d >= Approx( 1.24 )) for: !(1.22999999999999998
+>=
+Approx( 1.23999999999999999 ))
+Approx.tests.cpp:<line number>: passed: d >= Approx( 1.24 ).epsilon(0.1) for: 1.22999999999999998
+>=
+Approx( 1.23999999999999999 )
 TestCaseInfoHasher.tests.cpp:<line number>: passed: h1( dummy ) != h2( dummy ) for: 3422778688 (0x<hex digits>)
 !=
 130711275 (0x<hex digits>)
@@ -964,17 +1072,25 @@ Message.tests.cpp:<line number>: passed: i < 10 for: 9 < 10 with 2 messages: 'cu
 Message.tests.cpp:<line number>: failed: i < 10 for: 10 < 10 with 2 messages: 'current counter 10' and 'i := 10'
 AssertionHandler.tests.cpp:<line number>: failed: unexpected exception with message: 'Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE'; expression was: Dummy
 Condition.tests.cpp:<line number>: failed: data.int_seven != 7 for: 7 != 7
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one != Approx( 9.1f ) for: 9.1f != Approx( 9.1000003815 )
-Condition.tests.cpp:<line number>: failed: data.double_pi != Approx( 3.1415926535 ) for: 3.1415926535 != Approx( 3.1415926535 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one != Approx( 9.1f ) for: 9.100000381f
+!=
+Approx( 9.10000038146972656 )
+Condition.tests.cpp:<line number>: failed: data.double_pi != Approx( 3.1415926535 ) for: 3.14159265350000005
+!=
+Approx( 3.14159265350000005 )
 Condition.tests.cpp:<line number>: failed: data.str_hello != "hello" for: "hello" != "hello"
 Condition.tests.cpp:<line number>: failed: data.str_hello.size() != 5 for: 5 != 5
 Condition.tests.cpp:<line number>: passed: data.int_seven != 6 for: 7 != 6
 Condition.tests.cpp:<line number>: passed: data.int_seven != 8 for: 7 != 8
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 9.11f ) for: 9.1f != Approx( 9.1099996567 )
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 9.0f ) for: 9.1f != Approx( 9.0 )
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 1 ) for: 9.1f != Approx( 1.0 )
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 0 ) for: 9.1f != Approx( 0.0 )
-Condition.tests.cpp:<line number>: passed: data.double_pi != Approx( 3.1415 ) for: 3.1415926535 != Approx( 3.1415 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 9.11f ) for: 9.100000381f
+!=
+Approx( 9.10999965667724609 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 9.0f ) for: 9.100000381f != Approx( 9.0 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 1 ) for: 9.100000381f != Approx( 1.0 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 0 ) for: 9.100000381f != Approx( 0.0 )
+Condition.tests.cpp:<line number>: passed: data.double_pi != Approx( 3.1415 ) for: 3.14159265350000005
+!=
+Approx( 3.14150000000000018 )
 Condition.tests.cpp:<line number>: passed: data.str_hello != "goodbye" for: "hello" != "goodbye"
 Condition.tests.cpp:<line number>: passed: data.str_hello != "hell" for: "hello" != "hell"
 Condition.tests.cpp:<line number>: passed: data.str_hello != "hello1" for: "hello" != "hello1"
@@ -1065,10 +1181,18 @@ Json.tests.cpp:<line number>: passed: sstream.str() == "\"\\r\"" for: ""\r"" ==
 Json.tests.cpp:<line number>: passed: sstream.str() == "\"\\t\"" for: ""\t"" == ""\t""
 Json.tests.cpp:<line number>: passed: sstream.str() == "\"\\\\/\\t\\r\\n\"" for: ""\\/\t\r\n"" == ""\\/\t\r\n""
 Compilation.tests.cpp:<line number>: passed: []() { return true; }() for: true
-Approx.tests.cpp:<line number>: passed: d <= Approx( 1.24 ) for: 1.23 <= Approx( 1.24 )
-Approx.tests.cpp:<line number>: passed: d <= Approx( 1.23 ) for: 1.23 <= Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: !(d <= Approx( 1.22 )) for: !(1.23 <= Approx( 1.22 ))
-Approx.tests.cpp:<line number>: passed: d <= Approx( 1.22 ).epsilon(0.1) for: 1.23 <= Approx( 1.22 )
+Approx.tests.cpp:<line number>: passed: d <= Approx( 1.24 ) for: 1.22999999999999998
+<=
+Approx( 1.23999999999999999 )
+Approx.tests.cpp:<line number>: passed: d <= Approx( 1.23 ) for: 1.22999999999999998
+<=
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: !(d <= Approx( 1.22 )) for: !(1.22999999999999998
+<=
+Approx( 1.21999999999999997 ))
+Approx.tests.cpp:<line number>: passed: d <= Approx( 1.22 ).epsilon(0.1) for: 1.22999999999999998
+<=
+Approx( 1.21999999999999997 )
 Misc.tests.cpp:<line number>: passed: with 1 message: 'was called'
 Matchers.tests.cpp:<line number>: passed: testStringForMatching(), ContainsSubstring( "string" ) && ContainsSubstring( "abc" ) && ContainsSubstring( "substring" ) && ContainsSubstring( "contains" ) for: "this string contains 'abc' as a substring" ( contains: "string" and contains: "abc" and contains: "substring" and contains: "contains" )
 Matchers.tests.cpp:<line number>: passed: testStringForMatching(), ContainsSubstring( "string" ) || ContainsSubstring( "different" ) || ContainsSubstring( "random" ) for: "this string contains 'abc' as a substring" ( contains: "string" or contains: "different" or contains: "random" )
@@ -1135,9 +1259,9 @@ Condition.tests.cpp:<line number>: failed: data.int_seven < 0 for: 7 < 0
 Condition.tests.cpp:<line number>: failed: data.int_seven < -1 for: 7 < -1
 Condition.tests.cpp:<line number>: failed: data.int_seven >= 8 for: 7 >= 8
 Condition.tests.cpp:<line number>: failed: data.int_seven <= 6 for: 7 <= 6
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one < 9 for: 9.1f < 9
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one > 10 for: 9.1f > 10
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one > 9.2 for: 9.1f > 9.2
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one < 9 for: 9.100000381f < 9
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one > 10 for: 9.100000381f > 10
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one > 9.2 for: 9.100000381f > 9.19999999999999929
 Condition.tests.cpp:<line number>: failed: data.str_hello > "hello" for: "hello" > "hello"
 Condition.tests.cpp:<line number>: failed: data.str_hello < "hello" for: "hello" < "hello"
 Condition.tests.cpp:<line number>: failed: data.str_hello > "hellp" for: "hello" > "hellp"
@@ -1154,9 +1278,9 @@ Condition.tests.cpp:<line number>: passed: data.int_seven >= 7 for: 7 >= 7
 Condition.tests.cpp:<line number>: passed: data.int_seven >= 6 for: 7 >= 6
 Condition.tests.cpp:<line number>: passed: data.int_seven <= 7 for: 7 <= 7
 Condition.tests.cpp:<line number>: passed: data.int_seven <= 8 for: 7 <= 8
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one > 9 for: 9.1f > 9
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one < 10 for: 9.1f < 10
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one < 9.2 for: 9.1f < 9.2
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one > 9 for: 9.100000381f > 9
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one < 10 for: 9.100000381f < 10
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one < 9.2 for: 9.100000381f < 9.19999999999999929
 Condition.tests.cpp:<line number>: passed: data.str_hello <= "hello" for: "hello" <= "hello"
 Condition.tests.cpp:<line number>: passed: data.str_hello >= "hello" for: "hello" >= "hello"
 Condition.tests.cpp:<line number>: passed: data.str_hello < "hellp" for: "hello" < "hellp"
@@ -1354,7 +1478,9 @@ CmdLine.tests.cpp:<line number>: passed: config.benchmarkSamples == 200 for: 200
 CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-resamples=20000" }) for: {?}
 CmdLine.tests.cpp:<line number>: passed: config.benchmarkResamples == 20000 for: 20000 (0x<hex digits>) == 20000 (0x<hex digits>)
 CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-confidence-interval=0.99" }) for: {?}
-CmdLine.tests.cpp:<line number>: passed: config.benchmarkConfidenceInterval == Catch::Approx(0.99) for: 0.99 == Approx( 0.99 )
+CmdLine.tests.cpp:<line number>: passed: config.benchmarkConfidenceInterval == Catch::Approx(0.99) for: 0.98999999999999999
+==
+Approx( 0.98999999999999999 )
 CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-no-analysis" }) for: {?}
 CmdLine.tests.cpp:<line number>: passed: config.benchmarkNoAnalysis for: true
 CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-warmup-time=10" }) for: {?}
@@ -1609,14 +1735,30 @@ BDD.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
 A string sent directly to stdout
 A string sent directly to stderr
 A string sent to stderr via clog
-Approx.tests.cpp:<line number>: passed: d == Approx( 1.23 ) for: 1.23 == Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: d != Approx( 1.22 ) for: 1.23 != Approx( 1.22 )
-Approx.tests.cpp:<line number>: passed: d != Approx( 1.24 ) for: 1.23 != Approx( 1.24 )
-Approx.tests.cpp:<line number>: passed: d == 1.23_a for: 1.23 == Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: d != 1.22_a for: 1.23 != Approx( 1.22 )
-Approx.tests.cpp:<line number>: passed: Approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23
-Approx.tests.cpp:<line number>: passed: Approx( d ) != 1.22 for: Approx( 1.23 ) != 1.22
-Approx.tests.cpp:<line number>: passed: Approx( d ) != 1.24 for: Approx( 1.23 ) != 1.24
+Approx.tests.cpp:<line number>: passed: d == Approx( 1.23 ) for: 1.22999999999999998
+==
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: d != Approx( 1.22 ) for: 1.22999999999999998
+!=
+Approx( 1.21999999999999997 )
+Approx.tests.cpp:<line number>: passed: d != Approx( 1.24 ) for: 1.22999999999999998
+!=
+Approx( 1.23999999999999999 )
+Approx.tests.cpp:<line number>: passed: d == 1.23_a for: 1.22999999999999998
+==
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: d != 1.22_a for: 1.22999999999999998
+!=
+Approx( 1.21999999999999997 )
+Approx.tests.cpp:<line number>: passed: Approx( d ) == 1.23 for: Approx( 1.22999999999999998 )
+==
+1.22999999999999998
+Approx.tests.cpp:<line number>: passed: Approx( d ) != 1.22 for: Approx( 1.22999999999999998 )
+!=
+1.21999999999999997
+Approx.tests.cpp:<line number>: passed: Approx( d ) != 1.24 for: Approx( 1.22999999999999998 )
+!=
+1.23999999999999999
 Message from section one
 Message from section two
 Matchers.tests.cpp:<line number>: failed: testStringForMatching(), StartsWith( "This String" ) for: "this string contains 'abc' as a substring" starts with: "This String"
@@ -2025,7 +2167,7 @@ MatchersRanges.tests.cpp:<line number>: passed: a, !RangeEquals( b ) for: { 1, 2
 MatchersRanges.tests.cpp:<line number>: passed: a, UnorderedRangeEquals( b ) for: { 1, 2, 3 } unordered elements are { 3, 2, 1 }
 MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
 MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
-Exception.tests.cpp:<line number>: failed: unexpected exception with message: '3.14'
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: '3.14000000000000012'
 UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
 UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
 MatchersRanges.tests.cpp:<line number>: passed: data, AllMatch(SizeIs(5)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } all match has size == 5
@@ -2171,14 +2313,26 @@ MatchersRanges.tests.cpp:<line number>: passed: arr, !SizeIs(!Lt(3)) for: { 0, 0
 MatchersRanges.tests.cpp:<line number>: passed: map, SizeIs(3) for: { {?}, {?}, {?} } has size == 3
 MatchersRanges.tests.cpp:<line number>: passed: unrelated::ADL_size{}, SizeIs(12) for: {?} has size == 12
 MatchersRanges.tests.cpp:<line number>: passed: has_size{}, SizeIs(13) for: {?} has size == 13
-Approx.tests.cpp:<line number>: passed: d == approx( 1.23 ) for: 1.23 == Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: d == approx( 1.22 ) for: 1.23 == Approx( 1.22 )
-Approx.tests.cpp:<line number>: passed: d == approx( 1.24 ) for: 1.23 == Approx( 1.24 )
-Approx.tests.cpp:<line number>: passed: d != approx( 1.25 ) for: 1.23 != Approx( 1.25 )
-Approx.tests.cpp:<line number>: passed: approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23
-Approx.tests.cpp:<line number>: passed: approx( d ) == 1.22 for: Approx( 1.23 ) == 1.22
-Approx.tests.cpp:<line number>: passed: approx( d ) == 1.24 for: Approx( 1.23 ) == 1.24
-Approx.tests.cpp:<line number>: passed: approx( d ) != 1.25 for: Approx( 1.23 ) != 1.25
+Approx.tests.cpp:<line number>: passed: d == approx( 1.23 ) for: 1.22999999999999998
+==
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: d == approx( 1.22 ) for: 1.22999999999999998
+==
+Approx( 1.21999999999999997 )
+Approx.tests.cpp:<line number>: passed: d == approx( 1.24 ) for: 1.22999999999999998
+==
+Approx( 1.23999999999999999 )
+Approx.tests.cpp:<line number>: passed: d != approx( 1.25 ) for: 1.22999999999999998 != Approx( 1.25 )
+Approx.tests.cpp:<line number>: passed: approx( d ) == 1.23 for: Approx( 1.22999999999999998 )
+==
+1.22999999999999998
+Approx.tests.cpp:<line number>: passed: approx( d ) == 1.22 for: Approx( 1.22999999999999998 )
+==
+1.21999999999999997
+Approx.tests.cpp:<line number>: passed: approx( d ) == 1.24 for: Approx( 1.22999999999999998 )
+==
+1.23999999999999999
+Approx.tests.cpp:<line number>: passed: approx( d ) != 1.25 for: Approx( 1.22999999999999998 ) != 1.25
 VariadicMacros.tests.cpp:<line number>: passed: with 1 message: 'no assertions'
 Matchers.tests.cpp:<line number>: passed: empty, Approx( empty ) for: {  } is approx: {  }
 Matchers.tests.cpp:<line number>: passed: v1, Approx( v1 ) for: { 1.0, 2.0, 3.0 } is approx: { 1.0, 2.0, 3.0 }
@@ -2353,9 +2507,15 @@ Skip.tests.cpp:<line number>: skipped: 'skipping because answer = 41'
 Skip.tests.cpp:<line number>: passed:
 Skip.tests.cpp:<line number>: skipped: 'skipping because answer = 43'
 Tag.tests.cpp:<line number>: passed: Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
-InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.0920368762 == Approx( -0.0920368762 )
-InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.0598029112 == Approx( -0.0598029112 )
-InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(0.050000) == Approx(1.38590382434967796) for: 1.3859038243 == Approx( 1.3859038243 )
+InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.09203687623843014
+==
+Approx( -0.09203687623843015 )
+InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.05980291115763361
+==
+Approx( -0.05980291115763361 )
+InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(0.050000) == Approx(1.38590382434967796) for: 1.38590382434967774
+==
+Approx( 1.38590382434967796 )
 InternalBenchmark.tests.cpp:<line number>: passed: res.mean.count() == rate for: 2000.0 == 2000 (0x<hex digits>)
 InternalBenchmark.tests.cpp:<line number>: passed: res.outliers.total() == 0 for: 0 == 0
 Misc.tests.cpp:<line number>: passed:
@@ -2432,14 +2592,15 @@ Skip.tests.cpp:<line number>: skipped:
 !
 Tricky.tests.cpp:<line number>: passed: s == "7" for: "7" == "7"
 Tricky.tests.cpp:<line number>: passed: ti == typeid(int) for: {?} == {?}
-InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(0.000000) == Approx(0.50000000000000000) for: 0.5 == Approx( 0.5 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(1.000000) == Approx(0.84134474606854293) for: 0.8413447461 == Approx( 0.8413447461 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(-1.000000) == Approx(0.15865525393145705) for: 0.1586552539 == Approx( 0.1586552539 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(2.809729) == Approx(0.99752083845315409) for: 0.9975208385 == Approx( 0.9975208385 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(-1.352570) == Approx(0.08809652095066035) for: 0.088096521 == Approx( 0.088096521 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.551780) == Approx(0.13015979861484198) for: 0.1301597986 == Approx( 0.1301597986 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.533700) == Approx(0.08457408802851875) for: 0.084574088 == Approx( 0.084574088 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.025000) == Approx(-1.95996398454005449) for: -1.9599639845 == Approx( -1.9599639845 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.551780) == Approx(0.13015979861484198) for: 0.13015979861484195
+==
+Approx( 0.13015979861484198 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.533700) == Approx(0.08457408802851875) for: 0.08457408802851875
+==
+Approx( 0.08457408802851875 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.025000) == Approx(-1.95996398454005449) for: -1.95996398454005405
+==
+Approx( -1.95996398454005449 )
 Misc.tests.cpp:<line number>: passed:
 Message.tests.cpp:<line number>: passed: true with 1 message: 'this MAY be seen only for the FIRST assertion IF info is printed for passing assertions'
 Message.tests.cpp:<line number>: passed: true with 1 message: 'this MAY be seen only for the SECOND assertion IF info is printed for passing assertions'
@@ -2609,19 +2770,19 @@ EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e0) ==
 EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e1) == "1" for: "1" == "1"
 ToStringTuple.tests.cpp:<line number>: passed: "{ }" == ::Catch::Detail::stringify(type{}) for: "{ }" == "{ }"
 ToStringTuple.tests.cpp:<line number>: passed: "{ }" == ::Catch::Detail::stringify(value) for: "{ }" == "{ }"
-ToStringTuple.tests.cpp:<line number>: passed: "1.2f" == ::Catch::Detail::stringify(float(1.2)) for: "1.2f" == "1.2f"
-ToStringTuple.tests.cpp:<line number>: passed: "{ 1.2f, 0 }" == ::Catch::Detail::stringify(type{1.2f,0}) for: "{ 1.2f, 0 }" == "{ 1.2f, 0 }"
+ToStringTuple.tests.cpp:<line number>: passed: "1.5f" == ::Catch::Detail::stringify(float(1.5)) for: "1.5f" == "1.5f"
+ToStringTuple.tests.cpp:<line number>: passed: "{ 1.5f, 0 }" == ::Catch::Detail::stringify(type{1.5f,0}) for: "{ 1.5f, 0 }" == "{ 1.5f, 0 }"
 ToStringTuple.tests.cpp:<line number>: passed: "{ 0 }" == ::Catch::Detail::stringify(type{0}) for: "{ 0 }" == "{ 0 }"
 ToStringTuple.tests.cpp:<line number>: passed: "{ \"hello\", \"world\" }" == ::Catch::Detail::stringify(type{"hello","world"}) for: "{ "hello", "world" }"
 ==
 "{ "hello", "world" }"
-ToStringTuple.tests.cpp:<line number>: passed: "{ { 42 }, { }, 1.2f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.2f }"
+ToStringTuple.tests.cpp:<line number>: passed: "{ { 42 }, { }, 1.5f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.5f }"
 ==
-"{ { 42 }, { }, 1.2f }"
+"{ { 42 }, { }, 1.5f }"
 InternalBenchmark.tests.cpp:<line number>: passed: e.point == 23 for: 23.0 == 23
 InternalBenchmark.tests.cpp:<line number>: passed: e.upper_bound == 23 for: 23.0 == 23
 InternalBenchmark.tests.cpp:<line number>: passed: e.lower_bound == 23 for: 23.0 == 23
-InternalBenchmark.tests.cpp:<line number>: passed: e.confidence_interval == 0.95 for: 0.95 == 0.95
+InternalBenchmark.tests.cpp:<line number>: passed: e.confidence_interval == 0.95 for: 0.94999999999999996 == 0.94999999999999996
 RandomNumberGeneration.tests.cpp:<line number>: passed: dist.a() == -10 for: -10 == -10
 RandomNumberGeneration.tests.cpp:<line number>: passed: dist.b() == 10 for: 10 == 10
 UniquePtr.tests.cpp:<line number>: passed: !(ptr) for: !{?}
@@ -2689,7 +2850,7 @@ InternalBenchmark.tests.cpp:<line number>: passed: med == 18. for: 18.0 == 18.0
 InternalBenchmark.tests.cpp:<line number>: passed: q3 == 23. for: 23.0 == 23.0
 Misc.tests.cpp:<line number>: passed:
 Misc.tests.cpp:<line number>: passed:
-test cases:  417 |  312 passed |  85 failed | 6 skipped | 14 failed as expected
-assertions: 2260 | 2079 passed | 146 failed | 35 failed as expected
+test cases:  419 |  313 passed |  86 failed | 6 skipped | 14 failed as expected
+assertions: 2265 | 2083 passed | 147 failed | 35 failed as expected
 
 

tests/SelfTest/Baselines/compact.sw.multi.approved.txt

@@ -239,6 +239,10 @@ Class.tests.cpp:<line number>: passed: Nttp_Fixture<V>::value > 0 for: 3 > 0
 Class.tests.cpp:<line number>: passed: Nttp_Fixture<V>::value > 0 for: 6 > 0
 Class.tests.cpp:<line number>: failed: m_a == 2 for: 1 == 2
 Class.tests.cpp:<line number>: passed: m_a == 1 for: 1 == 1
+Class.tests.cpp:<line number>: passed: m_a++ == 0 for: 0 == 0
+Class.tests.cpp:<line number>: failed: m_a == 0 for: 1 == 0
+Class.tests.cpp:<line number>: passed: m_a++ == 0 for: 0 == 0
+Class.tests.cpp:<line number>: passed: m_a == 1 for: 1 == 1
 Misc.tests.cpp:<line number>: passed: x.size() == 0 for: 0 == 0
 Misc.tests.cpp:<line number>: passed: x.size() == 0 for: 0 == 0
 Misc.tests.cpp:<line number>: passed: x.size() == 0 for: 0 == 0
@@ -247,12 +251,22 @@ Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 42 > 0
 Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 9 > 0
 Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 42 > 0
 Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 9 > 0
-Approx.tests.cpp:<line number>: passed: d == 1.23_a for: 1.23 == Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: d != 1.22_a for: 1.23 != Approx( 1.22 )
-Approx.tests.cpp:<line number>: passed: -d == -1.23_a for: -1.23 == Approx( -1.23 )
-Approx.tests.cpp:<line number>: passed: d == 1.2_a .epsilon(.1) for: 1.23 == Approx( 1.2 )
-Approx.tests.cpp:<line number>: passed: d != 1.2_a .epsilon(.001) for: 1.23 != Approx( 1.2 )
-Approx.tests.cpp:<line number>: passed: d == 1_a .epsilon(.3) for: 1.23 == Approx( 1.0 )
+Approx.tests.cpp:<line number>: passed: d == 1.23_a for: 1.22999999999999998
+==
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: d != 1.22_a for: 1.22999999999999998
+!=
+Approx( 1.21999999999999997 )
+Approx.tests.cpp:<line number>: passed: -d == -1.23_a for: -1.22999999999999998
+==
+Approx( -1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: d == 1.2_a .epsilon(.1) for: 1.22999999999999998
+==
+Approx( 1.19999999999999996 )
+Approx.tests.cpp:<line number>: passed: d != 1.2_a .epsilon(.001) for: 1.22999999999999998
+!=
+Approx( 1.19999999999999996 )
+Approx.tests.cpp:<line number>: passed: d == 1_a .epsilon(.3) for: 1.22999999999999998 == Approx( 1.0 )
 Misc.tests.cpp:<line number>: passed: with 1 message: 'that's not flying - that's failing in style'
 Misc.tests.cpp:<line number>: failed: explicitly with 1 message: 'to infinity and beyond'
 Tricky.tests.cpp:<line number>: failed: &o1 == &o2 for: 0x<hex digits> == 0x<hex digits>
@@ -261,8 +275,8 @@ Approx.tests.cpp:<line number>: passed: 104.0 != Approx(100.0) for: 104.0 != App
 Approx.tests.cpp:<line number>: passed: 104.0 == Approx(100.0).margin(5) for: 104.0 == Approx( 100.0 )
 Approx.tests.cpp:<line number>: passed: 104.0 == Approx(100.0).margin(4) for: 104.0 == Approx( 100.0 )
 Approx.tests.cpp:<line number>: passed: 104.0 != Approx(100.0).margin(3) for: 104.0 != Approx( 100.0 )
-Approx.tests.cpp:<line number>: passed: 100.3 != Approx(100.0) for: 100.3 != Approx( 100.0 )
-Approx.tests.cpp:<line number>: passed: 100.3 == Approx(100.0).margin(0.5) for: 100.3 == Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 100.3 != Approx(100.0) for: 100.29999999999999716 != Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 100.3 == Approx(100.0).margin(0.5) for: 100.29999999999999716 == Approx( 100.0 )
 Tricky.tests.cpp:<line number>: passed: i++ == 7 for: 7 == 7
 Tricky.tests.cpp:<line number>: passed: i++ == 8 for: 8 == 8
 Exception.tests.cpp:<line number>: passed: 1 == 1
@@ -280,19 +294,33 @@ Approx.tests.cpp:<line number>: passed: 0.0f == Approx(0.25f).margin(0.25f) for:
 Approx.tests.cpp:<line number>: passed: 0.5f == Approx(0.25f).margin(0.25f) for: 0.5f == Approx( 0.25 )
 Approx.tests.cpp:<line number>: passed: 245.0f == Approx(245.25f).margin(0.25f) for: 245.0f == Approx( 245.25 )
 Approx.tests.cpp:<line number>: passed: 245.5f == Approx(245.25f).margin(0.25f) for: 245.5f == Approx( 245.25 )
-Approx.tests.cpp:<line number>: passed: divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) for: 3.1428571429 == Approx( 3.141 )
-Approx.tests.cpp:<line number>: passed: divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) for: 3.1428571429 != Approx( 3.141 )
-Approx.tests.cpp:<line number>: passed: d != Approx( 1.231 ) for: 1.23 != Approx( 1.231 )
-Approx.tests.cpp:<line number>: passed: d == Approx( 1.231 ).epsilon( 0.1 ) for: 1.23 == Approx( 1.231 )
-Approx.tests.cpp:<line number>: passed: 1.23f == Approx( 1.23f ) for: 1.23f == Approx( 1.2300000191 )
+Approx.tests.cpp:<line number>: passed: divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) for: 3.14285714285714279
+==
+Approx( 3.14100000000000001 )
+Approx.tests.cpp:<line number>: passed: divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) for: 3.14285714285714279
+!=
+Approx( 3.14100000000000001 )
+Approx.tests.cpp:<line number>: passed: d != Approx( 1.231 ) for: 1.22999999999999998
+!=
+Approx( 1.23100000000000009 )
+Approx.tests.cpp:<line number>: passed: d == Approx( 1.231 ).epsilon( 0.1 ) for: 1.22999999999999998
+==
+Approx( 1.23100000000000009 )
+Approx.tests.cpp:<line number>: passed: 1.23f == Approx( 1.23f ) for: 1.230000019f
+==
+Approx( 1.23000001907348633 )
 Approx.tests.cpp:<line number>: passed: 0.0f == Approx( 0.0f ) for: 0.0f == Approx( 0.0 )
 Approx.tests.cpp:<line number>: passed: 1 == Approx( 1 ) for: 1 == Approx( 1.0 )
 Approx.tests.cpp:<line number>: passed: 0 == Approx( 0 ) for: 0 == Approx( 0.0 )
 Approx.tests.cpp:<line number>: passed: 1.0f == Approx( 1 ) for: 1.0f == Approx( 1.0 )
 Approx.tests.cpp:<line number>: passed: 0 == Approx( dZero) for: 0 == Approx( 0.0 )
 Approx.tests.cpp:<line number>: passed: 0 == Approx( dSmall ).margin( 0.001 ) for: 0 == Approx( 0.00001 )
-Approx.tests.cpp:<line number>: passed: 1.234f == Approx( dMedium ) for: 1.234f == Approx( 1.234 )
-Approx.tests.cpp:<line number>: passed: dMedium == Approx( 1.234f ) for: 1.234 == Approx( 1.2339999676 )
+Approx.tests.cpp:<line number>: passed: 1.234f == Approx( dMedium ) for: 1.233999968f
+==
+Approx( 1.23399999999999999 )
+Approx.tests.cpp:<line number>: passed: dMedium == Approx( 1.234f ) for: 1.23399999999999999
+==
+Approx( 1.23399996757507324 )
 Matchers.tests.cpp:<line number>: passed: 1, Predicate<int>( alwaysTrue, "always true" ) for: 1 matches predicate: "always true"
 Matchers.tests.cpp:<line number>: passed: 1, !Predicate<int>( alwaysFalse, "always false" ) for: 1 not matches predicate: "always false"
 Matchers.tests.cpp:<line number>: passed: "Hello olleH", Predicate<std::string>( []( std::string const& str ) -> bool { return str.front() == str.back(); }, "First and last character should be equal" ) for: "Hello olleH" matches predicate: "First and last character should be equal"
@@ -359,6 +387,12 @@ ToStringGeneral.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( '\0
 ToStringGeneral.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( static_cast<char>(2) ) == "2" for: "2" == "2"
 ToStringGeneral.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( static_cast<char>(5) ) == "5" for: "5" == "5"
 Clara.tests.cpp:<line number>: passed: name.empty() for: true
+Clara.tests.cpp:<line number>: passed: result for: {?}
+Clara.tests.cpp:<line number>: passed: result.type() == Catch::Clara::Detail::ResultType::Ok for: 0 == 0
+Clara.tests.cpp:<line number>: passed: parsed.type() == Catch::Clara::ParseResultType::NoMatch for: 1 == 1
+Clara.tests.cpp:<line number>: passed: parsed.remainingTokens().count() == 2 for: 2 == 2
+Clara.tests.cpp:<line number>: passed: name.empty() for: true
+Clara.tests.cpp:<line number>: passed: name.empty() for: true
 Clara.tests.cpp:<line number>: passed: name == "foo" for: "foo" == "foo"
 Clara.tests.cpp:<line number>: passed: !(parse_result) for: !{?}
 Clara.tests.cpp:<line number>: passed: parse_result for: {?}
@@ -507,7 +541,7 @@ Stream.tests.cpp:<line number>: passed: Catch::makeStream( "-" )->isConsole() fo
 Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'custom exception - not std'; expression was: throwCustom()
 Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'custom exception - not std'; expression was: throwCustom(), std::exception
 Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'custom std exception'
-Approx.tests.cpp:<line number>: passed: 101.000001 != Approx(100).epsilon(0.01) for: 101.000001 != Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 101.000001 != Approx(100).epsilon(0.01) for: 101.00000099999999748 != Approx( 100.0 )
 Approx.tests.cpp:<line number>: passed: std::pow(10, -5) != Approx(std::pow(10, -7)) for: 0.00001 != Approx( 0.0000001 )
 ToString.tests.cpp:<line number>: passed: enumInfo->lookup(0) == "Value1" for: Value1 == "Value1"
 ToString.tests.cpp:<line number>: passed: enumInfo->lookup(1) == "Value2" for: Value2 == "Value2"
@@ -527,27 +561,39 @@ EnumToString.tests.cpp:<line number>: passed: stringify( EnumClass3::Value4 ) ==
 EnumToString.tests.cpp:<line number>: passed: stringify( ec3 ) == "Value2" for: "Value2" == "Value2"
 EnumToString.tests.cpp:<line number>: passed: stringify( Bikeshed::Colours::Red ) == "Red" for: "Red" == "Red"
 EnumToString.tests.cpp:<line number>: passed: stringify( Bikeshed::Colours::Blue ) == "Blue" for: "Blue" == "Blue"
-Approx.tests.cpp:<line number>: passed: 101.01 != Approx(100).epsilon(0.01) for: 101.01 != Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 101.01 != Approx(100).epsilon(0.01) for: 101.01000000000000512 != Approx( 100.0 )
 Condition.tests.cpp:<line number>: failed: data.int_seven == 6 for: 7 == 6
 Condition.tests.cpp:<line number>: failed: data.int_seven == 8 for: 7 == 8
 Condition.tests.cpp:<line number>: failed: data.int_seven == 0 for: 7 == 0
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 9.11f ) for: 9.1f == Approx( 9.1099996567 )
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 9.0f ) for: 9.1f == Approx( 9.0 )
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 1 ) for: 9.1f == Approx( 1.0 )
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 0 ) for: 9.1f == Approx( 0.0 )
-Condition.tests.cpp:<line number>: failed: data.double_pi == Approx( 3.1415 ) for: 3.1415926535 == Approx( 3.1415 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 9.11f ) for: 9.100000381f
+==
+Approx( 9.10999965667724609 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 9.0f ) for: 9.100000381f == Approx( 9.0 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 1 ) for: 9.100000381f == Approx( 1.0 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 0 ) for: 9.100000381f == Approx( 0.0 )
+Condition.tests.cpp:<line number>: failed: data.double_pi == Approx( 3.1415 ) for: 3.14159265350000005
+==
+Approx( 3.14150000000000018 )
 Condition.tests.cpp:<line number>: failed: data.str_hello == "goodbye" for: "hello" == "goodbye"
 Condition.tests.cpp:<line number>: failed: data.str_hello == "hell" for: "hello" == "hell"
 Condition.tests.cpp:<line number>: failed: data.str_hello == "hello1" for: "hello" == "hello1"
 Condition.tests.cpp:<line number>: failed: data.str_hello.size() == 6 for: 5 == 6
-Condition.tests.cpp:<line number>: failed: x == Approx( 1.301 ) for: 1.3 == Approx( 1.301 )
+Condition.tests.cpp:<line number>: failed: x == Approx( 1.301 ) for: 1.30000000000000027
+==
+Approx( 1.30099999999999993 )
 Condition.tests.cpp:<line number>: passed: data.int_seven == 7 for: 7 == 7
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one == Approx( 9.1f ) for: 9.1f == Approx( 9.1000003815 )
-Condition.tests.cpp:<line number>: passed: data.double_pi == Approx( 3.1415926535 ) for: 3.1415926535 == Approx( 3.1415926535 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one == Approx( 9.1f ) for: 9.100000381f
+==
+Approx( 9.10000038146972656 )
+Condition.tests.cpp:<line number>: passed: data.double_pi == Approx( 3.1415926535 ) for: 3.14159265350000005
+==
+Approx( 3.14159265350000005 )
 Condition.tests.cpp:<line number>: passed: data.str_hello == "hello" for: "hello" == "hello"
 Condition.tests.cpp:<line number>: passed: "hello" == data.str_hello for: "hello" == "hello"
 Condition.tests.cpp:<line number>: passed: data.str_hello.size() == 5 for: 5 == 5
-Condition.tests.cpp:<line number>: passed: x == Approx( 1.3 ) for: 1.3 == Approx( 1.3 )
+Condition.tests.cpp:<line number>: passed: x == Approx( 1.3 ) for: 1.30000000000000027
+==
+Approx( 1.30000000000000004 )
 Matchers.tests.cpp:<line number>: passed: testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) for: "this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring"
 Matchers.tests.cpp:<line number>: passed: testStringForMatching(), Equals( "this string contains 'ABC' as a substring", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring" (case insensitive)
 Matchers.tests.cpp:<line number>: failed: testStringForMatching(), Equals( "this string contains 'ABC' as a substring" ) for: "this string contains 'abc' as a substring" equals: "this string contains 'ABC' as a substring"
@@ -594,21 +640,21 @@ Misc.tests.cpp:<line number>: passed: Factorial(2) == 2 for: 2 == 2
 Misc.tests.cpp:<line number>: passed: Factorial(3) == 6 for: 6 == 6
 Misc.tests.cpp:<line number>: passed: Factorial(10) == 3628800 for: 3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
 GeneratorsImpl.tests.cpp:<line number>: passed: filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
-Matchers.tests.cpp:<line number>: passed: 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.1 are within 10% of each other
-Matchers.tests.cpp:<line number>: passed: 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.2 are within 10% of each other
-Matchers.tests.cpp:<line number>: passed: 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0 are within 99% of each other
-Matchers.tests.cpp:<line number>: passed: -0., WithinRel( 0. ) for: -0.0 and 0 are within 2.22045e-12% of each other
-Matchers.tests.cpp:<line number>: passed: v1, WithinRel( v2 ) for: 0.0 and 2.22507e-308 are within 2.22045e-12% of each other
+Matchers.tests.cpp:<line number>: passed: 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.09999999999999964 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.19999999999999929 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0.0 are within 99% of each other
+Matchers.tests.cpp:<line number>: passed: -0., WithinRel( 0. ) for: -0.0 and 0.0 are within 2.22045e-12% of each other
+Matchers.tests.cpp:<line number>: passed: v1, WithinRel( v2 ) for: 0.0 and 0.0 are within 2.22045e-12% of each other
 Matchers.tests.cpp:<line number>: passed: 1., WithinAbs( 1., 0 ) for: 1.0 is within 0.0 of 1.0
 Matchers.tests.cpp:<line number>: passed: 0., WithinAbs( 1., 1 ) for: 0.0 is within 1.0 of 1.0
-Matchers.tests.cpp:<line number>: passed: 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0
-Matchers.tests.cpp:<line number>: passed: 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.98999999999999999 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.98999999999999999 of 1.0
 Matchers.tests.cpp:<line number>: passed: 11., !WithinAbs( 10., 0.5 ) for: 11.0 not is within 0.5 of 10.0
 Matchers.tests.cpp:<line number>: passed: 10., !WithinAbs( 11., 0.5 ) for: 10.0 not is within 0.5 of 11.0
 Matchers.tests.cpp:<line number>: passed: -10., WithinAbs( -10., 0.5 ) for: -10.0 is within 0.5 of -10.0
-Matchers.tests.cpp:<line number>: passed: -10., WithinAbs( -9.6, 0.5 ) for: -10.0 is within 0.5 of -9.6
+Matchers.tests.cpp:<line number>: passed: -10., WithinAbs( -9.6, 0.5 ) for: -10.0 is within 0.5 of -9.59999999999999964
 Matchers.tests.cpp:<line number>: passed: 1., WithinULP( 1., 0 ) for: 1.0 is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00])
-Matchers.tests.cpp:<line number>: passed: nextafter( 1., 2. ), WithinULP( 1., 1 ) for: 1.0 is within 1 ULPs of 1.0000000000000000e+00 ([9.9999999999999989e-01, 1.0000000000000002e+00])
+Matchers.tests.cpp:<line number>: passed: nextafter( 1., 2. ), WithinULP( 1., 1 ) for: 1.00000000000000022 is within 1 ULPs of 1.0000000000000000e+00 ([9.9999999999999989e-01, 1.0000000000000002e+00])
 Matchers.tests.cpp:<line number>: passed: 0., WithinULP( nextafter( 0., 1. ), 1 ) for: 0.0 is within 1 ULPs of 4.9406564584124654e-324 ([0.0000000000000000e+00, 9.8813129168249309e-324])
 Matchers.tests.cpp:<line number>: passed: 1., WithinULP( nextafter( 1., 0. ), 1 ) for: 1.0 is within 1 ULPs of 9.9999999999999989e-01 ([9.9999999999999978e-01, 1.0000000000000000e+00])
 Matchers.tests.cpp:<line number>: passed: 1., !WithinULP( nextafter( 1., 2. ), 0 ) for: 1.0 not is within 0 ULPs of 1.0000000000000002e+00 ([1.0000000000000002e+00, 1.0000000000000002e+00])
@@ -616,7 +662,7 @@ Matchers.tests.cpp:<line number>: passed: 1., WithinULP( 1., 0 ) for: 1.0 is wit
 Matchers.tests.cpp:<line number>: passed: -0., WithinULP( 0., 0 ) for: -0.0 is within 0 ULPs of 0.0000000000000000e+00 ([0.0000000000000000e+00, 0.0000000000000000e+00])
 Matchers.tests.cpp:<line number>: passed: 1., WithinAbs( 1., 0.5 ) || WithinULP( 2., 1 ) for: 1.0 ( is within 0.5 of 1.0 or is within 1 ULPs of 2.0000000000000000e+00 ([1.9999999999999998e+00, 2.0000000000000004e+00]) )
 Matchers.tests.cpp:<line number>: passed: 1., WithinAbs( 2., 0.5 ) || WithinULP( 1., 0 ) for: 1.0 ( is within 0.5 of 2.0 or is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00]) )
-Matchers.tests.cpp:<line number>: passed: 0.0001, WithinAbs( 0., 0.001 ) || WithinRel( 0., 0.1 ) for: 0.0001 ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+Matchers.tests.cpp:<line number>: passed: 0.0001, WithinAbs( 0., 0.001 ) || WithinRel( 0., 0.1 ) for: 0.0001 ( is within 0.001 of 0.0 or and 0.0 are within 10% of each other )
 Matchers.tests.cpp:<line number>: passed: WithinAbs( 1., 0. )
 Matchers.tests.cpp:<line number>: passed: WithinAbs( 1., -1. ), std::domain_error
 Matchers.tests.cpp:<line number>: passed: WithinULP( 1., 0 )
@@ -624,23 +670,23 @@ Matchers.tests.cpp:<line number>: passed: WithinRel( 1., 0. )
 Matchers.tests.cpp:<line number>: passed: WithinRel( 1., -0.2 ), std::domain_error
 Matchers.tests.cpp:<line number>: passed: WithinRel( 1., 1. ), std::domain_error
 Matchers.tests.cpp:<line number>: passed: 1., !IsNaN() for: 1.0 not is NaN
-Matchers.tests.cpp:<line number>: passed: 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.1 are within 10% of each other
-Matchers.tests.cpp:<line number>: passed: 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.2 are within 10% of each other
-Matchers.tests.cpp:<line number>: passed: 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0 are within 99% of each other
-Matchers.tests.cpp:<line number>: passed: -0.f, WithinRel( 0.f ) for: -0.0f and 0 are within 0.00119209% of each other
-Matchers.tests.cpp:<line number>: passed: v1, WithinRel( v2 ) for: 0.0f and 1.17549e-38 are within 0.00119209% of each other
+Matchers.tests.cpp:<line number>: passed: 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.10000038146972656 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.19999980926513672 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0.0 are within 99% of each other
+Matchers.tests.cpp:<line number>: passed: -0.f, WithinRel( 0.f ) for: -0.0f and 0.0 are within 0.00119209% of each other
+Matchers.tests.cpp:<line number>: passed: v1, WithinRel( v2 ) for: 0.0f and 0.0 are within 0.00119209% of each other
 Matchers.tests.cpp:<line number>: passed: 1.f, WithinAbs( 1.f, 0 ) for: 1.0f is within 0.0 of 1.0
 Matchers.tests.cpp:<line number>: passed: 0.f, WithinAbs( 1.f, 1 ) for: 0.0f is within 1.0 of 1.0
-Matchers.tests.cpp:<line number>: passed: 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0
-Matchers.tests.cpp:<line number>: passed: 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.99000000953674316 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.99000000953674316 of 1.0
 Matchers.tests.cpp:<line number>: passed: 0.f, WithinAbs( -0.f, 0 ) for: 0.0f is within 0.0 of -0.0
 Matchers.tests.cpp:<line number>: passed: 11.f, !WithinAbs( 10.f, 0.5f ) for: 11.0f not is within 0.5 of 10.0
 Matchers.tests.cpp:<line number>: passed: 10.f, !WithinAbs( 11.f, 0.5f ) for: 10.0f not is within 0.5 of 11.0
 Matchers.tests.cpp:<line number>: passed: -10.f, WithinAbs( -10.f, 0.5f ) for: -10.0f is within 0.5 of -10.0
-Matchers.tests.cpp:<line number>: passed: -10.f, WithinAbs( -9.6f, 0.5f ) for: -10.0f is within 0.5 of -9.6000003815
+Matchers.tests.cpp:<line number>: passed: -10.f, WithinAbs( -9.6f, 0.5f ) for: -10.0f is within 0.5 of -9.60000038146972656
 Matchers.tests.cpp:<line number>: passed: 1.f, WithinULP( 1.f, 0 ) for: 1.0f is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00])
 Matchers.tests.cpp:<line number>: passed: -1.f, WithinULP( -1.f, 0 ) for: -1.0f is within 0 ULPs of -1.00000000e+00f ([-1.00000000e+00, -1.00000000e+00])
-Matchers.tests.cpp:<line number>: passed: nextafter( 1.f, 2.f ), WithinULP( 1.f, 1 ) for: 1.0f is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00])
+Matchers.tests.cpp:<line number>: passed: nextafter( 1.f, 2.f ), WithinULP( 1.f, 1 ) for: 1.000000119f is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00])
 Matchers.tests.cpp:<line number>: passed: 0.f, WithinULP( nextafter( 0.f, 1.f ), 1 ) for: 0.0f is within 1 ULPs of 1.40129846e-45f ([0.00000000e+00, 2.80259693e-45])
 Matchers.tests.cpp:<line number>: passed: 1.f, WithinULP( nextafter( 1.f, 0.f ), 1 ) for: 1.0f is within 1 ULPs of 9.99999940e-01f ([9.99999881e-01, 1.00000000e+00])
 Matchers.tests.cpp:<line number>: passed: 1.f, !WithinULP( nextafter( 1.f, 2.f ), 0 ) for: 1.0f not is within 0 ULPs of 1.00000012e+00f ([1.00000012e+00, 1.00000012e+00])
@@ -648,7 +694,7 @@ Matchers.tests.cpp:<line number>: passed: 1.f, WithinULP( 1.f, 0 ) for: 1.0f is
 Matchers.tests.cpp:<line number>: passed: -0.f, WithinULP( 0.f, 0 ) for: -0.0f is within 0 ULPs of 0.00000000e+00f ([0.00000000e+00, 0.00000000e+00])
 Matchers.tests.cpp:<line number>: passed: 1.f, WithinAbs( 1.f, 0.5 ) || WithinULP( 1.f, 1 ) for: 1.0f ( is within 0.5 of 1.0 or is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00]) )
 Matchers.tests.cpp:<line number>: passed: 1.f, WithinAbs( 2.f, 0.5 ) || WithinULP( 1.f, 0 ) for: 1.0f ( is within 0.5 of 2.0 or is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00]) )
-Matchers.tests.cpp:<line number>: passed: 0.0001f, WithinAbs( 0.f, 0.001f ) || WithinRel( 0.f, 0.1f ) for: 0.0001f ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+Matchers.tests.cpp:<line number>: passed: 0.0001f, WithinAbs( 0.f, 0.001f ) || WithinRel( 0.f, 0.1f ) for: 0.0001f ( is within 0.00100000004749745 of 0.0 or and 0.0 are within 10% of each other )
 Matchers.tests.cpp:<line number>: passed: WithinAbs( 1.f, 0.f )
 Matchers.tests.cpp:<line number>: passed: WithinAbs( 1.f, -1.f ), std::domain_error
 Matchers.tests.cpp:<line number>: passed: WithinULP( 1.f, 0 )
@@ -828,68 +874,122 @@ GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 5 for: 5 == 5
 GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.9 == Approx( -0.9 ) with 1 message: 'Current expected value is -0.9'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.90000000000000002
+==
+Approx( -0.90000000000000002 ) with 1 message: 'Current expected value is -0.9'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.9'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.8 == Approx( -0.8 ) with 1 message: 'Current expected value is -0.8'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.80000000000000004
+==
+Approx( -0.80000000000000004 ) with 1 message: 'Current expected value is -0.8'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.8'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.70000000000000007
+==
+Approx( -0.70000000000000007 ) with 1 message: 'Current expected value is -0.7'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.7'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.6 == Approx( -0.6 ) with 1 message: 'Current expected value is -0.6'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.60000000000000009
+==
+Approx( -0.60000000000000009 ) with 1 message: 'Current expected value is -0.6'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.6'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.5 == Approx( -0.5 ) with 1 message: 'Current expected value is -0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.50000000000000011
+==
+Approx( -0.50000000000000011 ) with 1 message: 'Current expected value is -0.5'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.5'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.40000000000000013
+==
+Approx( -0.40000000000000013 ) with 1 message: 'Current expected value is -0.4'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.4'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.3 == Approx( -0.3 ) with 1 message: 'Current expected value is -0.3'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.30000000000000016
+==
+Approx( -0.30000000000000016 ) with 1 message: 'Current expected value is -0.3'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.3'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.2 == Approx( -0.2 ) with 1 message: 'Current expected value is -0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.20000000000000015
+==
+Approx( -0.20000000000000015 ) with 1 message: 'Current expected value is -0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.2'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.10000000000000014
+==
+Approx( -0.10000000000000014 ) with 1 message: 'Current expected value is -0.1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.0 == Approx( -0.0 ) with 1 message: 'Current expected value is -1.38778e-16'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.00000000000000014
+==
+Approx( -0.00000000000000014 ) with 1 message: 'Current expected value is -1.38778e-16'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1.38778e-16'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.1 == Approx( 0.1 ) with 1 message: 'Current expected value is 0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.09999999999999987
+==
+Approx( 0.09999999999999987 ) with 1 message: 'Current expected value is 0.1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.19999999999999987
+==
+Approx( 0.19999999999999987 ) with 1 message: 'Current expected value is 0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.2'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.3 == Approx( 0.3 ) with 1 message: 'Current expected value is 0.3'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.29999999999999988
+==
+Approx( 0.29999999999999988 ) with 1 message: 'Current expected value is 0.3'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.3'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.4 == Approx( 0.4 ) with 1 message: 'Current expected value is 0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.39999999999999991
+==
+Approx( 0.39999999999999991 ) with 1 message: 'Current expected value is 0.4'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.4'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.49999999999999989
+==
+Approx( 0.49999999999999989 ) with 1 message: 'Current expected value is 0.5'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.5'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.6 == Approx( 0.6 ) with 1 message: 'Current expected value is 0.6'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.59999999999999987
+==
+Approx( 0.59999999999999987 ) with 1 message: 'Current expected value is 0.6'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.6'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.7 == Approx( 0.7 ) with 1 message: 'Current expected value is 0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.69999999999999984
+==
+Approx( 0.69999999999999984 ) with 1 message: 'Current expected value is 0.7'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.7'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.8 == Approx( 0.8 ) with 1 message: 'Current expected value is 0.8'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.79999999999999982
+==
+Approx( 0.79999999999999982 ) with 1 message: 'Current expected value is 0.8'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.8'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.9 == Approx( 0.9 ) with 1 message: 'Current expected value is 0.9'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.8999999999999998
+==
+Approx( 0.8999999999999998 ) with 1 message: 'Current expected value is 0.9'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.9'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx( rangeEnd ) for: 1.0 == Approx( 1.0 )
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx( rangeEnd ) for: 0.99999999999999978 == Approx( 1.0 )
 GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.69999999999999996
+==
+Approx( -0.69999999999999996 ) with 1 message: 'Current expected value is -0.7'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.7'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.39999999999999997
+==
+Approx( -0.39999999999999997 ) with 1 message: 'Current expected value is -0.4'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.4'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.09999999999999998
+==
+Approx( -0.09999999999999998 ) with 1 message: 'Current expected value is -0.1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.20000000000000001
+==
+Approx( 0.20000000000000001 ) with 1 message: 'Current expected value is 0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.5'
 GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.69999999999999996
+==
+Approx( -0.69999999999999996 ) with 1 message: 'Current expected value is -0.7'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.7'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.39999999999999997
+==
+Approx( -0.39999999999999997 ) with 1 message: 'Current expected value is -0.4'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.4'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.09999999999999998
+==
+Approx( -0.09999999999999998 ) with 1 message: 'Current expected value is -0.1'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.1'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.20000000000000001
+==
+Approx( 0.20000000000000001 ) with 1 message: 'Current expected value is 0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.2'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5'
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.5'
@@ -920,10 +1020,18 @@ GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -4 for: -4 == -4
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
 GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -7 for: -7 == -7
 GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
-Approx.tests.cpp:<line number>: passed: d >= Approx( 1.22 ) for: 1.23 >= Approx( 1.22 )
-Approx.tests.cpp:<line number>: passed: d >= Approx( 1.23 ) for: 1.23 >= Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: !(d >= Approx( 1.24 )) for: !(1.23 >= Approx( 1.24 ))
-Approx.tests.cpp:<line number>: passed: d >= Approx( 1.24 ).epsilon(0.1) for: 1.23 >= Approx( 1.24 )
+Approx.tests.cpp:<line number>: passed: d >= Approx( 1.22 ) for: 1.22999999999999998
+>=
+Approx( 1.21999999999999997 )
+Approx.tests.cpp:<line number>: passed: d >= Approx( 1.23 ) for: 1.22999999999999998
+>=
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: !(d >= Approx( 1.24 )) for: !(1.22999999999999998
+>=
+Approx( 1.23999999999999999 ))
+Approx.tests.cpp:<line number>: passed: d >= Approx( 1.24 ).epsilon(0.1) for: 1.22999999999999998
+>=
+Approx( 1.23999999999999999 )
 TestCaseInfoHasher.tests.cpp:<line number>: passed: h1( dummy ) != h2( dummy ) for: 3422778688 (0x<hex digits>)
 !=
 130711275 (0x<hex digits>)
@@ -962,17 +1070,25 @@ Message.tests.cpp:<line number>: passed: i < 10 for: 9 < 10 with 2 messages: 'cu
 Message.tests.cpp:<line number>: failed: i < 10 for: 10 < 10 with 2 messages: 'current counter 10' and 'i := 10'
 AssertionHandler.tests.cpp:<line number>: failed: unexpected exception with message: 'Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE'; expression was: Dummy
 Condition.tests.cpp:<line number>: failed: data.int_seven != 7 for: 7 != 7
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one != Approx( 9.1f ) for: 9.1f != Approx( 9.1000003815 )
-Condition.tests.cpp:<line number>: failed: data.double_pi != Approx( 3.1415926535 ) for: 3.1415926535 != Approx( 3.1415926535 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one != Approx( 9.1f ) for: 9.100000381f
+!=
+Approx( 9.10000038146972656 )
+Condition.tests.cpp:<line number>: failed: data.double_pi != Approx( 3.1415926535 ) for: 3.14159265350000005
+!=
+Approx( 3.14159265350000005 )
 Condition.tests.cpp:<line number>: failed: data.str_hello != "hello" for: "hello" != "hello"
 Condition.tests.cpp:<line number>: failed: data.str_hello.size() != 5 for: 5 != 5
 Condition.tests.cpp:<line number>: passed: data.int_seven != 6 for: 7 != 6
 Condition.tests.cpp:<line number>: passed: data.int_seven != 8 for: 7 != 8
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 9.11f ) for: 9.1f != Approx( 9.1099996567 )
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 9.0f ) for: 9.1f != Approx( 9.0 )
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 1 ) for: 9.1f != Approx( 1.0 )
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 0 ) for: 9.1f != Approx( 0.0 )
-Condition.tests.cpp:<line number>: passed: data.double_pi != Approx( 3.1415 ) for: 3.1415926535 != Approx( 3.1415 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 9.11f ) for: 9.100000381f
+!=
+Approx( 9.10999965667724609 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 9.0f ) for: 9.100000381f != Approx( 9.0 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 1 ) for: 9.100000381f != Approx( 1.0 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 0 ) for: 9.100000381f != Approx( 0.0 )
+Condition.tests.cpp:<line number>: passed: data.double_pi != Approx( 3.1415 ) for: 3.14159265350000005
+!=
+Approx( 3.14150000000000018 )
 Condition.tests.cpp:<line number>: passed: data.str_hello != "goodbye" for: "hello" != "goodbye"
 Condition.tests.cpp:<line number>: passed: data.str_hello != "hell" for: "hello" != "hell"
 Condition.tests.cpp:<line number>: passed: data.str_hello != "hello1" for: "hello" != "hello1"
@@ -1063,10 +1179,18 @@ Json.tests.cpp:<line number>: passed: sstream.str() == "\"\\r\"" for: ""\r"" ==
 Json.tests.cpp:<line number>: passed: sstream.str() == "\"\\t\"" for: ""\t"" == ""\t""
 Json.tests.cpp:<line number>: passed: sstream.str() == "\"\\\\/\\t\\r\\n\"" for: ""\\/\t\r\n"" == ""\\/\t\r\n""
 Compilation.tests.cpp:<line number>: passed: []() { return true; }() for: true
-Approx.tests.cpp:<line number>: passed: d <= Approx( 1.24 ) for: 1.23 <= Approx( 1.24 )
-Approx.tests.cpp:<line number>: passed: d <= Approx( 1.23 ) for: 1.23 <= Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: !(d <= Approx( 1.22 )) for: !(1.23 <= Approx( 1.22 ))
-Approx.tests.cpp:<line number>: passed: d <= Approx( 1.22 ).epsilon(0.1) for: 1.23 <= Approx( 1.22 )
+Approx.tests.cpp:<line number>: passed: d <= Approx( 1.24 ) for: 1.22999999999999998
+<=
+Approx( 1.23999999999999999 )
+Approx.tests.cpp:<line number>: passed: d <= Approx( 1.23 ) for: 1.22999999999999998
+<=
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: !(d <= Approx( 1.22 )) for: !(1.22999999999999998
+<=
+Approx( 1.21999999999999997 ))
+Approx.tests.cpp:<line number>: passed: d <= Approx( 1.22 ).epsilon(0.1) for: 1.22999999999999998
+<=
+Approx( 1.21999999999999997 )
 Misc.tests.cpp:<line number>: passed: with 1 message: 'was called'
 Matchers.tests.cpp:<line number>: passed: testStringForMatching(), ContainsSubstring( "string" ) && ContainsSubstring( "abc" ) && ContainsSubstring( "substring" ) && ContainsSubstring( "contains" ) for: "this string contains 'abc' as a substring" ( contains: "string" and contains: "abc" and contains: "substring" and contains: "contains" )
 Matchers.tests.cpp:<line number>: passed: testStringForMatching(), ContainsSubstring( "string" ) || ContainsSubstring( "different" ) || ContainsSubstring( "random" ) for: "this string contains 'abc' as a substring" ( contains: "string" or contains: "different" or contains: "random" )
@@ -1133,9 +1257,9 @@ Condition.tests.cpp:<line number>: failed: data.int_seven < 0 for: 7 < 0
 Condition.tests.cpp:<line number>: failed: data.int_seven < -1 for: 7 < -1
 Condition.tests.cpp:<line number>: failed: data.int_seven >= 8 for: 7 >= 8
 Condition.tests.cpp:<line number>: failed: data.int_seven <= 6 for: 7 <= 6
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one < 9 for: 9.1f < 9
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one > 10 for: 9.1f > 10
-Condition.tests.cpp:<line number>: failed: data.float_nine_point_one > 9.2 for: 9.1f > 9.2
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one < 9 for: 9.100000381f < 9
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one > 10 for: 9.100000381f > 10
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one > 9.2 for: 9.100000381f > 9.19999999999999929
 Condition.tests.cpp:<line number>: failed: data.str_hello > "hello" for: "hello" > "hello"
 Condition.tests.cpp:<line number>: failed: data.str_hello < "hello" for: "hello" < "hello"
 Condition.tests.cpp:<line number>: failed: data.str_hello > "hellp" for: "hello" > "hellp"
@@ -1152,9 +1276,9 @@ Condition.tests.cpp:<line number>: passed: data.int_seven >= 7 for: 7 >= 7
 Condition.tests.cpp:<line number>: passed: data.int_seven >= 6 for: 7 >= 6
 Condition.tests.cpp:<line number>: passed: data.int_seven <= 7 for: 7 <= 7
 Condition.tests.cpp:<line number>: passed: data.int_seven <= 8 for: 7 <= 8
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one > 9 for: 9.1f > 9
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one < 10 for: 9.1f < 10
-Condition.tests.cpp:<line number>: passed: data.float_nine_point_one < 9.2 for: 9.1f < 9.2
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one > 9 for: 9.100000381f > 9
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one < 10 for: 9.100000381f < 10
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one < 9.2 for: 9.100000381f < 9.19999999999999929
 Condition.tests.cpp:<line number>: passed: data.str_hello <= "hello" for: "hello" <= "hello"
 Condition.tests.cpp:<line number>: passed: data.str_hello >= "hello" for: "hello" >= "hello"
 Condition.tests.cpp:<line number>: passed: data.str_hello < "hellp" for: "hello" < "hellp"
@@ -1352,7 +1476,9 @@ CmdLine.tests.cpp:<line number>: passed: config.benchmarkSamples == 200 for: 200
 CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-resamples=20000" }) for: {?}
 CmdLine.tests.cpp:<line number>: passed: config.benchmarkResamples == 20000 for: 20000 (0x<hex digits>) == 20000 (0x<hex digits>)
 CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-confidence-interval=0.99" }) for: {?}
-CmdLine.tests.cpp:<line number>: passed: config.benchmarkConfidenceInterval == Catch::Approx(0.99) for: 0.99 == Approx( 0.99 )
+CmdLine.tests.cpp:<line number>: passed: config.benchmarkConfidenceInterval == Catch::Approx(0.99) for: 0.98999999999999999
+==
+Approx( 0.98999999999999999 )
 CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-no-analysis" }) for: {?}
 CmdLine.tests.cpp:<line number>: passed: config.benchmarkNoAnalysis for: true
 CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-warmup-time=10" }) for: {?}
@@ -1604,14 +1730,30 @@ BDD.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
 BDD.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
 BDD.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
 BDD.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
-Approx.tests.cpp:<line number>: passed: d == Approx( 1.23 ) for: 1.23 == Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: d != Approx( 1.22 ) for: 1.23 != Approx( 1.22 )
-Approx.tests.cpp:<line number>: passed: d != Approx( 1.24 ) for: 1.23 != Approx( 1.24 )
-Approx.tests.cpp:<line number>: passed: d == 1.23_a for: 1.23 == Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: d != 1.22_a for: 1.23 != Approx( 1.22 )
-Approx.tests.cpp:<line number>: passed: Approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23
-Approx.tests.cpp:<line number>: passed: Approx( d ) != 1.22 for: Approx( 1.23 ) != 1.22
-Approx.tests.cpp:<line number>: passed: Approx( d ) != 1.24 for: Approx( 1.23 ) != 1.24
+Approx.tests.cpp:<line number>: passed: d == Approx( 1.23 ) for: 1.22999999999999998
+==
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: d != Approx( 1.22 ) for: 1.22999999999999998
+!=
+Approx( 1.21999999999999997 )
+Approx.tests.cpp:<line number>: passed: d != Approx( 1.24 ) for: 1.22999999999999998
+!=
+Approx( 1.23999999999999999 )
+Approx.tests.cpp:<line number>: passed: d == 1.23_a for: 1.22999999999999998
+==
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: d != 1.22_a for: 1.22999999999999998
+!=
+Approx( 1.21999999999999997 )
+Approx.tests.cpp:<line number>: passed: Approx( d ) == 1.23 for: Approx( 1.22999999999999998 )
+==
+1.22999999999999998
+Approx.tests.cpp:<line number>: passed: Approx( d ) != 1.22 for: Approx( 1.22999999999999998 )
+!=
+1.21999999999999997
+Approx.tests.cpp:<line number>: passed: Approx( d ) != 1.24 for: Approx( 1.22999999999999998 )
+!=
+1.23999999999999999
 Matchers.tests.cpp:<line number>: failed: testStringForMatching(), StartsWith( "This String" ) for: "this string contains 'abc' as a substring" starts with: "This String"
 Matchers.tests.cpp:<line number>: failed: testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" starts with: "string" (case insensitive)
 ToStringGeneral.tests.cpp:<line number>: passed: Catch::Detail::stringify(singular) == "{ 1 }" for: "{ 1 }" == "{ 1 }"
@@ -2018,7 +2160,7 @@ MatchersRanges.tests.cpp:<line number>: passed: a, !RangeEquals( b ) for: { 1, 2
 MatchersRanges.tests.cpp:<line number>: passed: a, UnorderedRangeEquals( b ) for: { 1, 2, 3 } unordered elements are { 3, 2, 1 }
 MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
 MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
-Exception.tests.cpp:<line number>: failed: unexpected exception with message: '3.14'
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: '3.14000000000000012'
 UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
 UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
 MatchersRanges.tests.cpp:<line number>: passed: data, AllMatch(SizeIs(5)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } all match has size == 5
@@ -2164,14 +2306,26 @@ MatchersRanges.tests.cpp:<line number>: passed: arr, !SizeIs(!Lt(3)) for: { 0, 0
 MatchersRanges.tests.cpp:<line number>: passed: map, SizeIs(3) for: { {?}, {?}, {?} } has size == 3
 MatchersRanges.tests.cpp:<line number>: passed: unrelated::ADL_size{}, SizeIs(12) for: {?} has size == 12
 MatchersRanges.tests.cpp:<line number>: passed: has_size{}, SizeIs(13) for: {?} has size == 13
-Approx.tests.cpp:<line number>: passed: d == approx( 1.23 ) for: 1.23 == Approx( 1.23 )
-Approx.tests.cpp:<line number>: passed: d == approx( 1.22 ) for: 1.23 == Approx( 1.22 )
-Approx.tests.cpp:<line number>: passed: d == approx( 1.24 ) for: 1.23 == Approx( 1.24 )
-Approx.tests.cpp:<line number>: passed: d != approx( 1.25 ) for: 1.23 != Approx( 1.25 )
-Approx.tests.cpp:<line number>: passed: approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23
-Approx.tests.cpp:<line number>: passed: approx( d ) == 1.22 for: Approx( 1.23 ) == 1.22
-Approx.tests.cpp:<line number>: passed: approx( d ) == 1.24 for: Approx( 1.23 ) == 1.24
-Approx.tests.cpp:<line number>: passed: approx( d ) != 1.25 for: Approx( 1.23 ) != 1.25
+Approx.tests.cpp:<line number>: passed: d == approx( 1.23 ) for: 1.22999999999999998
+==
+Approx( 1.22999999999999998 )
+Approx.tests.cpp:<line number>: passed: d == approx( 1.22 ) for: 1.22999999999999998
+==
+Approx( 1.21999999999999997 )
+Approx.tests.cpp:<line number>: passed: d == approx( 1.24 ) for: 1.22999999999999998
+==
+Approx( 1.23999999999999999 )
+Approx.tests.cpp:<line number>: passed: d != approx( 1.25 ) for: 1.22999999999999998 != Approx( 1.25 )
+Approx.tests.cpp:<line number>: passed: approx( d ) == 1.23 for: Approx( 1.22999999999999998 )
+==
+1.22999999999999998
+Approx.tests.cpp:<line number>: passed: approx( d ) == 1.22 for: Approx( 1.22999999999999998 )
+==
+1.21999999999999997
+Approx.tests.cpp:<line number>: passed: approx( d ) == 1.24 for: Approx( 1.22999999999999998 )
+==
+1.23999999999999999
+Approx.tests.cpp:<line number>: passed: approx( d ) != 1.25 for: Approx( 1.22999999999999998 ) != 1.25
 VariadicMacros.tests.cpp:<line number>: passed: with 1 message: 'no assertions'
 Matchers.tests.cpp:<line number>: passed: empty, Approx( empty ) for: {  } is approx: {  }
 Matchers.tests.cpp:<line number>: passed: v1, Approx( v1 ) for: { 1.0, 2.0, 3.0 } is approx: { 1.0, 2.0, 3.0 }
@@ -2346,9 +2500,15 @@ Skip.tests.cpp:<line number>: skipped: 'skipping because answer = 41'
 Skip.tests.cpp:<line number>: passed:
 Skip.tests.cpp:<line number>: skipped: 'skipping because answer = 43'
 Tag.tests.cpp:<line number>: passed: Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
-InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.0920368762 == Approx( -0.0920368762 )
-InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.0598029112 == Approx( -0.0598029112 )
-InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(0.050000) == Approx(1.38590382434967796) for: 1.3859038243 == Approx( 1.3859038243 )
+InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.09203687623843014
+==
+Approx( -0.09203687623843015 )
+InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.05980291115763361
+==
+Approx( -0.05980291115763361 )
+InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(0.050000) == Approx(1.38590382434967796) for: 1.38590382434967774
+==
+Approx( 1.38590382434967796 )
 InternalBenchmark.tests.cpp:<line number>: passed: res.mean.count() == rate for: 2000.0 == 2000 (0x<hex digits>)
 InternalBenchmark.tests.cpp:<line number>: passed: res.outliers.total() == 0 for: 0 == 0
 Misc.tests.cpp:<line number>: passed:
@@ -2421,14 +2581,15 @@ Misc.tests.cpp:<line number>: passed: a != b for: 1 != 2
 Skip.tests.cpp:<line number>: skipped:
 Tricky.tests.cpp:<line number>: passed: s == "7" for: "7" == "7"
 Tricky.tests.cpp:<line number>: passed: ti == typeid(int) for: {?} == {?}
-InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(0.000000) == Approx(0.50000000000000000) for: 0.5 == Approx( 0.5 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(1.000000) == Approx(0.84134474606854293) for: 0.8413447461 == Approx( 0.8413447461 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(-1.000000) == Approx(0.15865525393145705) for: 0.1586552539 == Approx( 0.1586552539 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(2.809729) == Approx(0.99752083845315409) for: 0.9975208385 == Approx( 0.9975208385 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(-1.352570) == Approx(0.08809652095066035) for: 0.088096521 == Approx( 0.088096521 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.551780) == Approx(0.13015979861484198) for: 0.1301597986 == Approx( 0.1301597986 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.533700) == Approx(0.08457408802851875) for: 0.084574088 == Approx( 0.084574088 )
-InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.025000) == Approx(-1.95996398454005449) for: -1.9599639845 == Approx( -1.9599639845 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.551780) == Approx(0.13015979861484198) for: 0.13015979861484195
+==
+Approx( 0.13015979861484198 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.533700) == Approx(0.08457408802851875) for: 0.08457408802851875
+==
+Approx( 0.08457408802851875 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.025000) == Approx(-1.95996398454005449) for: -1.95996398454005405
+==
+Approx( -1.95996398454005449 )
 Misc.tests.cpp:<line number>: passed:
 Message.tests.cpp:<line number>: passed: true with 1 message: 'this MAY be seen only for the FIRST assertion IF info is printed for passing assertions'
 Message.tests.cpp:<line number>: passed: true with 1 message: 'this MAY be seen only for the SECOND assertion IF info is printed for passing assertions'
@@ -2598,19 +2759,19 @@ EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e0) ==
 EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e1) == "1" for: "1" == "1"
 ToStringTuple.tests.cpp:<line number>: passed: "{ }" == ::Catch::Detail::stringify(type{}) for: "{ }" == "{ }"
 ToStringTuple.tests.cpp:<line number>: passed: "{ }" == ::Catch::Detail::stringify(value) for: "{ }" == "{ }"
-ToStringTuple.tests.cpp:<line number>: passed: "1.2f" == ::Catch::Detail::stringify(float(1.2)) for: "1.2f" == "1.2f"
-ToStringTuple.tests.cpp:<line number>: passed: "{ 1.2f, 0 }" == ::Catch::Detail::stringify(type{1.2f,0}) for: "{ 1.2f, 0 }" == "{ 1.2f, 0 }"
+ToStringTuple.tests.cpp:<line number>: passed: "1.5f" == ::Catch::Detail::stringify(float(1.5)) for: "1.5f" == "1.5f"
+ToStringTuple.tests.cpp:<line number>: passed: "{ 1.5f, 0 }" == ::Catch::Detail::stringify(type{1.5f,0}) for: "{ 1.5f, 0 }" == "{ 1.5f, 0 }"
 ToStringTuple.tests.cpp:<line number>: passed: "{ 0 }" == ::Catch::Detail::stringify(type{0}) for: "{ 0 }" == "{ 0 }"
 ToStringTuple.tests.cpp:<line number>: passed: "{ \"hello\", \"world\" }" == ::Catch::Detail::stringify(type{"hello","world"}) for: "{ "hello", "world" }"
 ==
 "{ "hello", "world" }"
-ToStringTuple.tests.cpp:<line number>: passed: "{ { 42 }, { }, 1.2f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.2f }"
+ToStringTuple.tests.cpp:<line number>: passed: "{ { 42 }, { }, 1.5f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.5f }"
 ==
-"{ { 42 }, { }, 1.2f }"
+"{ { 42 }, { }, 1.5f }"
 InternalBenchmark.tests.cpp:<line number>: passed: e.point == 23 for: 23.0 == 23
 InternalBenchmark.tests.cpp:<line number>: passed: e.upper_bound == 23 for: 23.0 == 23
 InternalBenchmark.tests.cpp:<line number>: passed: e.lower_bound == 23 for: 23.0 == 23
-InternalBenchmark.tests.cpp:<line number>: passed: e.confidence_interval == 0.95 for: 0.95 == 0.95
+InternalBenchmark.tests.cpp:<line number>: passed: e.confidence_interval == 0.95 for: 0.94999999999999996 == 0.94999999999999996
 RandomNumberGeneration.tests.cpp:<line number>: passed: dist.a() == -10 for: -10 == -10
 RandomNumberGeneration.tests.cpp:<line number>: passed: dist.b() == 10 for: 10 == 10
 UniquePtr.tests.cpp:<line number>: passed: !(ptr) for: !{?}
@@ -2678,7 +2839,7 @@ InternalBenchmark.tests.cpp:<line number>: passed: med == 18. for: 18.0 == 18.0
 InternalBenchmark.tests.cpp:<line number>: passed: q3 == 23. for: 23.0 == 23.0
 Misc.tests.cpp:<line number>: passed:
 Misc.tests.cpp:<line number>: passed:
-test cases:  417 |  312 passed |  85 failed | 6 skipped | 14 failed as expected
-assertions: 2260 | 2079 passed | 146 failed | 35 failed as expected
+test cases:  419 |  313 passed |  86 failed | 6 skipped | 14 failed as expected
+assertions: 2265 | 2083 passed | 147 failed | 35 failed as expected
 
 

tests/SelfTest/Baselines/console.std.approved.txt

@@ -297,6 +297,18 @@ Class.tests.cpp:<line number>: FAILED:
 with expansion:
   1 == 2
 
+-------------------------------------------------------------------------------
+A TEST_CASE_PERSISTENT_FIXTURE based test run that fails
+  Second partial run
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( m_a == 0 )
+with expansion:
+  1 == 0
+
 -------------------------------------------------------------------------------
 A couple of nested sections followed by a failure
 -------------------------------------------------------------------------------
@@ -434,27 +446,31 @@ with expansion:
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.float_nine_point_one == Approx( 9.11f ) )
 with expansion:
-  9.1f == Approx( 9.1099996567 )
+  9.100000381f
+  ==
+  Approx( 9.10999965667724609 )
 
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.float_nine_point_one == Approx( 9.0f ) )
 with expansion:
-  9.1f == Approx( 9.0 )
+  9.100000381f == Approx( 9.0 )
 
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.float_nine_point_one == Approx( 1 ) )
 with expansion:
-  9.1f == Approx( 1.0 )
+  9.100000381f == Approx( 1.0 )
 
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.float_nine_point_one == Approx( 0 ) )
 with expansion:
-  9.1f == Approx( 0.0 )
+  9.100000381f == Approx( 0.0 )
 
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.double_pi == Approx( 3.1415 ) )
 with expansion:
-  3.1415926535 == Approx( 3.1415 )
+  3.14159265350000005
+  ==
+  Approx( 3.14150000000000018 )
 
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.str_hello == "goodbye" )
@@ -479,7 +495,9 @@ with expansion:
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( x == Approx( 1.301 ) )
 with expansion:
-  1.3 == Approx( 1.301 )
+  1.30000000000000027
+  ==
+  Approx( 1.30099999999999993 )
 
 -------------------------------------------------------------------------------
 Equals string matcher
@@ -696,12 +714,16 @@ with expansion:
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.float_nine_point_one != Approx( 9.1f ) )
 with expansion:
-  9.1f != Approx( 9.1000003815 )
+  9.100000381f
+  !=
+  Approx( 9.10000038146972656 )
 
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.double_pi != Approx( 3.1415926535 ) )
 with expansion:
-  3.1415926535 != Approx( 3.1415926535 )
+  3.14159265350000005
+  !=
+  Approx( 3.14159265350000005 )
 
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.str_hello != "hello" )
@@ -855,17 +877,17 @@ with expansion:
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.float_nine_point_one < 9 )
 with expansion:
-  9.1f < 9
+  9.100000381f < 9
 
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.float_nine_point_one > 10 )
 with expansion:
-  9.1f > 10
+  9.100000381f > 10
 
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.float_nine_point_one > 9.2 )
 with expansion:
-  9.1f > 9.2
+  9.100000381f > 9.19999999999999929
 
 Condition.tests.cpp:<line number>: FAILED:
   CHECK( data.str_hello > "hello" )
@@ -1060,7 +1082,7 @@ Exception.tests.cpp:<line number>
 
 Exception.tests.cpp:<line number>: FAILED:
 due to unexpected exception with message:
-  3.14
+  3.14000000000000012
 
 -------------------------------------------------------------------------------
 Vector Approx matcher -- failing
@@ -1588,6 +1610,6 @@ due to unexpected exception with message:
   Why would you throw a std::string?
 
 ===============================================================================
-test cases:  417 |  326 passed |  70 failed | 7 skipped | 14 failed as expected
-assertions: 2243 | 2079 passed | 129 failed | 35 failed as expected
+test cases:  419 |  327 passed |  71 failed | 7 skipped | 14 failed as expected
+assertions: 2248 | 2083 passed | 130 failed | 35 failed as expected
 

tests/SelfTest/Baselines/junit.sw.approved.txt

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuitesloose text artifact
 >
-  <testsuite name="<exe-name>" errors="17" failures="129" skipped="12" tests="2272" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+  <testsuite name="<exe-name>" errors="17" failures="130" skipped="12" tests="2277" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
     <properties>
       <property name="random-seed" value="1"/>
       <property name="filters" value="&quot;*&quot; ~[!nonportable] ~[!benchmark] ~[approvals]"/>
@@ -12,6 +12,7 @@
     <testcase classname="<exe-name>.global" name="#1175 - Hidden Test" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1238" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.(Fixture_1245&lt;int, int>)" name="#1245" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="#1319: Sections can have description (even if it is not saved" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1319: Sections can have description (even if it is not saved/SectionName" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1403" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1455 - INFO and WARN can start with a linebreak" time="{duration}" status="run"/>
@@ -30,10 +31,12 @@ Nor would this
     </testcase>
     <testcase classname="<exe-name>.global" name="#1548" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1905 -- test spec parser properly clears internal state between compound tests" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="#1912 -- test spec parser handles escaping" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1912 -- test spec parser handles escaping/Various parentheses" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1912 -- test spec parser handles escaping/backslash in test name" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1913 - GENERATE inside a for loop should not keep recreating the generator" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1913 - GENERATEs can share a line" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="#1938 - GENERATE after a section" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1938 - GENERATE after a section/A" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1938 - GENERATE after a section/B" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1938 - Section followed by flat generate" time="{duration}" status="run"/>
@@ -56,6 +59,7 @@ failure to init
 at Generators.tests.cpp:<line number>
       </error>
     </testcase>
+    <testcase classname="<exe-name>.global" name="#748 - captures with unexpected exceptions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#748 - captures with unexpected exceptions/outside assertions" time="{duration}" status="run">
       <skipped message="TEST_CASE tagged with !mayfail"/>
       <error type="TEST_CASE">
@@ -89,6 +93,7 @@ at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="#872" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="#961 -- Dynamically created sections should all be reported" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#961 -- Dynamically created sections should all be reported/Looped section 0" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#961 -- Dynamically created sections should all be reported/Looped section 1" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#961 -- Dynamically created sections should all be reported/Looped section 2" time="{duration}" status="run"/>
@@ -147,6 +152,7 @@ at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="'Not' checks that should succeed" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="(unimplemented) static bools can be evaluated" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="(unimplemented) static bools can be evaluated/compare to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="(unimplemented) static bools can be evaluated/compare to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="(unimplemented) static bools can be evaluated/negation" time="{duration}" status="run"/>
@@ -313,6 +319,19 @@ at Class.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.Fixture" name="A TEST_CASE_METHOD based test run that succeeds" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Persistent_Fixture" name="A TEST_CASE_PERSISTENT_FIXTURE based test run that fails/First partial run" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Persistent_Fixture" name="A TEST_CASE_PERSISTENT_FIXTURE based test run that fails/Second partial run" time="{duration}" status="run">
+      <failure message="m_a == 0" type="REQUIRE">
+FAILED:
+  REQUIRE( m_a == 0 )
+with expansion:
+  1 == 0
+at Class.tests.cpp:<line number>
+      </failure>
+    </testcase>
+    <testcase classname="<exe-name>.Persistent_Fixture" name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Persistent_Fixture" name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds/First partial run" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Persistent_Fixture" name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds/Second partial run" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="A Template product test case - Foo&lt;float>" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="A Template product test case - Foo&lt;int>" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="A Template product test case - std::vector&lt;float>" time="{duration}" status="run"/>
@@ -329,6 +348,7 @@ to infinity and beyond
 at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="A couple of nested sections followed by a failure/Outer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="A couple of nested sections followed by a failure/Outer/Inner" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="A failing expression with a non streamable type is still captured" time="{duration}" status="run">
       <failure message="&amp;o1 == &amp;o2" type="CHECK">
@@ -347,6 +367,7 @@ at Tricky.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="Absolute margin" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="An empty test with no assertions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="An expression with side-effects should only be evaluated once" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="An unchecked exception reports the line of the last assertion" time="{duration}" status="run">
       <error message="{Unknown expression after the reported line}">
@@ -364,6 +385,7 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Approximate comparisons with floats" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Approximate comparisons with ints" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Approximate comparisons with mixed numeric types" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Arbitrary predicate matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Arbitrary predicate matcher/Function pointer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Arbitrary predicate matcher/Lambdas + different type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Assertion macros support bit operators and bool conversions" time="{duration}" status="run"/>
@@ -371,30 +393,39 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Assertions then sections/A section" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Assertions then sections/A section/Another section" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Assertions then sections/A section/Another other section" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Different argument ranges, same element type, default comparison" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Different argument ranges, same element type, custom comparison" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Different element type, custom comparisons" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Can handle type that requires ADL-found free function begin and end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Initialization with move only types" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Matching using matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Basic use of the Empty range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Empty range matcher/Simple, std-provided containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Empty range matcher/Type with empty" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Empty range matcher/Type requires ADL found empty free function" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CAPTURE can deal with complex expressions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CAPTURE can deal with complex expressions involving commas" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CAPTURE parses string and character constants" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Capture and info messages" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Capture and info messages/Capture should stringify like assertions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Capture and info messages/Info should NOT stringify the way assertions do" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="CaseInsensitiveEqualsTo is case insensitive" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CaseInsensitiveEqualsTo is case insensitive/Degenerate cases" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CaseInsensitiveEqualsTo is case insensitive/Plain comparisons" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="CaseInsensitiveLess is case insensitive" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CaseInsensitiveLess is case insensitive/Degenerate cases" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CaseInsensitiveLess is case insensitive/Plain comparisons" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Character pretty printing" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Character pretty printing/Specifically escaped" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Character pretty printing/General chars" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Character pretty printing/Low ASCII" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Clara::Arg does not crash on incomplete input" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Clara::Arg supports single-arg parse the way Opt does" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Clara::Opt supports accept-many lambdas" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Clara::Opt supports accept-many lambdas/Parsing fails on multiple options without accept_many" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Clara::Opt supports accept-many lambdas/Parsing succeeds on multiple options with accept_many" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="ColourGuard behaviour" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="ColourGuard behaviour/ColourGuard is disengaged by default" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="ColourGuard behaviour/ColourGuard is engaged by op&lt;&lt;" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="ColourGuard behaviour/ColourGuard can be engaged explicitly" time="{duration}" status="run"/>
@@ -412,8 +443,10 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Comparisons between ints where one side is computed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Comparisons with int literals don't warn when mixing signed/ unsigned" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Composed generic matchers shortcircuit" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Composed generic matchers shortcircuit/MatchAllOf" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Composed generic matchers shortcircuit/MatchAnyOf" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Composed matchers shortcircuit" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Composed matchers shortcircuit/MatchAllOf" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Composed matchers shortcircuit/MatchAnyOf" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Contains string matcher" time="{duration}" status="run">
@@ -433,6 +466,7 @@ with expansion:
 at Matchers.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Copy and then generate a range" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Copy and then generate a range/from var and iterators" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Copy and then generate a range/From a temporary container" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Copy and then generate a range/Final validation" time="{duration}" status="run"/>
@@ -517,35 +551,39 @@ at Condition.tests.cpp:<line number>
 FAILED:
   CHECK( data.float_nine_point_one == Approx( 9.11f ) )
 with expansion:
-  9.1f == Approx( 9.1099996567 )
+  9.100000381f
+  ==
+  Approx( 9.10999965667724609 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.float_nine_point_one == Approx( 9.0f )" type="CHECK">
 FAILED:
   CHECK( data.float_nine_point_one == Approx( 9.0f ) )
 with expansion:
-  9.1f == Approx( 9.0 )
+  9.100000381f == Approx( 9.0 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.float_nine_point_one == Approx( 1 )" type="CHECK">
 FAILED:
   CHECK( data.float_nine_point_one == Approx( 1 ) )
 with expansion:
-  9.1f == Approx( 1.0 )
+  9.100000381f == Approx( 1.0 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.float_nine_point_one == Approx( 0 )" type="CHECK">
 FAILED:
   CHECK( data.float_nine_point_one == Approx( 0 ) )
 with expansion:
-  9.1f == Approx( 0.0 )
+  9.100000381f == Approx( 0.0 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.double_pi == Approx( 3.1415 )" type="CHECK">
 FAILED:
   CHECK( data.double_pi == Approx( 3.1415 ) )
 with expansion:
-  3.1415926535 == Approx( 3.1415 )
+  3.14159265350000005
+  ==
+  Approx( 3.14150000000000018 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.str_hello == &quot;goodbye&quot;" type="CHECK">
@@ -580,7 +618,9 @@ at Condition.tests.cpp:<line number>
 FAILED:
   CHECK( x == Approx( 1.301 ) )
 with expansion:
-  1.3 == Approx( 1.301 )
+  1.30000000000000027
+  ==
+  Approx( 1.30099999999999993 )
 at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
@@ -649,6 +689,7 @@ at Matchers.tests.cpp:<line number>
     </testcase>
     <testcase classname="<exe-name>.global" name="Exception matchers that succeed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Exception message can be matched" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Exception messages can be tested for" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Exception messages can be tested for/exact match" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Exception messages can be tested for/different case" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Exception messages can be tested for/wildcarded" time="{duration}" status="run"/>
@@ -694,6 +735,7 @@ at Message.tests.cpp:<line number>
     </testcase>
     <testcase classname="<exe-name>.global" name="Factorials are computed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Filter generator throws exception for empty generator" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Floating point matchers: double" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/Relative" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/Relative/Some subnormal values" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/Margin" time="{duration}" status="run"/>
@@ -701,6 +743,7 @@ at Message.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/Composed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/Constructor validation" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/IsNaN" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Floating point matchers: float" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: float/Relative" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: float/Relative/Some subnormal values" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: float/Margin" time="{duration}" status="run"/>
@@ -709,46 +752,64 @@ at Message.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Floating point matchers: float/Constructor validation" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: float/IsNaN" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="GENERATE can combine literals and generators" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators -- adapters" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators -- adapters/Filtering by predicate" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Filtering by predicate/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Filtering by predicate/Throws if there are no matching values" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Shortening a range" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators -- adapters/Transforming elements" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Transforming elements/Same type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Transforming elements/Different type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Transforming elements/Different deduced type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Repeating a generator" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators -- adapters/Chunking a generator into sized pieces" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Chunking a generator into sized pieces/Number of elements in source is divisible by chunk size" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Chunking a generator into sized pieces/Number of elements in source is not divisible by chunk size" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Chunking a generator into sized pieces/Chunk size of zero" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Chunking a generator into sized pieces/Throws on too small generators" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators -- simple" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- simple/one" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- simple/two" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Single value" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Preset values" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Generator combinator" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Explicitly typed generator sequence" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Filter generator" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Filter generator/Simple filtering" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Filter generator/Filter out multiple elements at the start and end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Filter generator/Throws on construction if it can't get initial element" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Take generator" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Take generator/Take less" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Take generator/Take more" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Map with explicit return type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Map with deduced return type" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Repeat" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Repeat/Singular repeat" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Repeat/Actual repeat" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive auto step" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive auto step/Integer" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative auto step" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative auto step/Integer" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Integer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Integer/Exact" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Integer/Slightly over end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Integer/Slightly under end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Floating Point" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Floating Point/Exact" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Floating Point/Slightly over end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Floating Point/Slightly under end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative manual step" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative manual step/Integer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative manual step/Integer/Exact" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative manual step/Integer/Slightly over end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative manual step/Integer/Slightly under end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Greater-than inequalities with different epsilons" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Hashers with different seed produce different hash with same test case" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Hashers with same seed produce same hash" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Hashing different test cases produces different result" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Hashing different test cases produces different result/Different test name" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Hashing different test cases produces different result/Different classname" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Hashing different test cases produces different result/Different tags" time="{duration}" status="run"/>
@@ -828,14 +889,18 @@ at Condition.tests.cpp:<line number>
 FAILED:
   CHECK( data.float_nine_point_one != Approx( 9.1f ) )
 with expansion:
-  9.1f != Approx( 9.1000003815 )
+  9.100000381f
+  !=
+  Approx( 9.10000038146972656 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.double_pi != Approx( 3.1415926535 )" type="CHECK">
 FAILED:
   CHECK( data.double_pi != Approx( 3.1415926535 ) )
 with expansion:
-  3.1415926535 != Approx( 3.1415926535 )
+  3.14159265350000005
+  !=
+  Approx( 3.14159265350000005 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.str_hello != &quot;hello&quot;" type="CHECK">
@@ -854,6 +919,7 @@ at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="Inequality checks that should succeed" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Newly constructed JsonWriter does nothing" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Calling writeObject will create an empty pair of braces" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Calling writeObject with key will create an object to write the value" time="{duration}" status="run"/>
@@ -863,6 +929,7 @@ at Condition.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="JsonWriter/Moved from JsonObjectWriter shall not insert superfluous brace" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Moved from JsonArrayWriter shall not insert superfluous bracket" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Custom class shall be quoted" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Quote in a string is escaped" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Backslash in a string is escaped" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Forward slash in a string is **not** escaped" time="{duration}" status="run"/>
@@ -898,6 +965,9 @@ with expansion:
 at Matchers.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1" time="{duration}" status="run">
+      <skipped message="TEST_CASE tagged with !mayfail"/>
+    </testcase>
     <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1/A" time="{duration}" status="run">
       <skipped message="TEST_CASE tagged with !mayfail"/>
       <failure type="FAIL">
@@ -905,6 +975,9 @@ FAILED:
 at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2" time="{duration}" status="run">
+      <skipped message="TEST_CASE tagged with !mayfail"/>
+    </testcase>
     <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2/A" time="{duration}" status="run">
       <skipped message="TEST_CASE tagged with !mayfail"/>
       <failure type="FAIL">
@@ -912,6 +985,9 @@ FAILED:
 at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1" time="{duration}" status="run">
+      <skipped message="TEST_CASE tagged with !mayfail"/>
+    </testcase>
     <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1/B" time="{duration}" status="run">
       <skipped message="TEST_CASE tagged with !mayfail"/>
       <failure type="FAIL">
@@ -919,6 +995,9 @@ FAILED:
 at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2" time="{duration}" status="run">
+      <skipped message="TEST_CASE tagged with !mayfail"/>
+    </testcase>
     <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2/B" time="{duration}" status="run">
       <skipped message="TEST_CASE tagged with !mayfail"/>
       <failure type="FAIL">
@@ -1011,21 +1090,21 @@ at Condition.tests.cpp:<line number>
 FAILED:
   CHECK( data.float_nine_point_one &lt; 9 )
 with expansion:
-  9.1f &lt; 9
+  9.100000381f &lt; 9
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.float_nine_point_one > 10" type="CHECK">
 FAILED:
   CHECK( data.float_nine_point_one > 10 )
 with expansion:
-  9.1f > 10
+  9.100000381f > 10
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.float_nine_point_one > 9.2" type="CHECK">
 FAILED:
   CHECK( data.float_nine_point_one > 9.2 )
 with expansion:
-  9.1f > 9.2
+  9.100000381f > 9.19999999999999929
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.str_hello > &quot;hello&quot;" type="CHECK">
@@ -1086,6 +1165,7 @@ at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="Ordering comparison checks that should succeed" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Our PCG implementation provides expected results for known seeds" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Our PCG implementation provides expected results for known seeds/Default seeded" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Our PCG implementation provides expected results for known seeds/Specific seed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Output from all sections is reported/one" time="{duration}" status="run">
@@ -1103,9 +1183,11 @@ at Message.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="Overloaded comma or address-of operators are not used" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Parse uints" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parse uints/proper inputs" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parse uints/Bad inputs" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsed tags are matched case insensitive" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/shard-count" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/Negative shard count reports error" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/Zero shard count reports error" time="{duration}" status="run"/>
@@ -1113,44 +1195,58 @@ at Message.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/Negative shard index reports error" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/Shard index 0 is accepted" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing tags with non-alphabetical characters is pass-through" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Parsing warnings" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing warnings/NoAssertions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing warnings/NoTests is no longer supported" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing warnings/Combining multiple warnings" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Pointers can be compared to null" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Precision of floating point stringification can be set" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Precision of floating point stringification can be set/Floats" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Precision of floating point stringification can be set/Double" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Predicate matcher can accept const char*" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/empty args don't cause a crash" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/default - no arguments" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/test lists" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/test lists/Specify one test case using" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/test lists/Specify one test case exclusion using exclude:" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/test lists/Specify one test case exclusion using ~" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/-r/console" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/-r/xml" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/--reporter/junit" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/must match one of the available ones" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/With output file" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/With Windows-like absolute path as output file" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/Multiple reporters" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/Multiple reporters/All with output files" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/Multiple reporters/Mixed output files and default output" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/Multiple reporters/cannot have multiple reporters with default output" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/debugger" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/debugger/-b" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/debugger/--break" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/-a aborts after first failure" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/-x 2 aborts after two failures" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/-x must be numeric" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/wait-for-keypress" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/wait-for-keypress/Accepted options" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/wait-for-keypress/invalid options are reported" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/nothrow" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/nothrow/-e" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/nothrow/--nothrow" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/output filename" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/output filename/-o filename" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/output filename/--out" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/combinations" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/combinations/Single character flags can be combined" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour/without option" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour/auto" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour/yes" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour/no" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour/error" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/samples" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/resamples" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/confidence-interval" time="{duration}" status="run"/>
@@ -1230,14 +1326,27 @@ at Matchers.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="SUCCEED counts as a test pass" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="SUCCEED does not require an argument" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Fixture" name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.Fixture" name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Fixture" name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me/When: We get the count" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.Fixture" name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me/When: We get the count/Then: Subsequently values are higher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing/Given: This stuff exists" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this/Then: it should do this" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this/Then: it should do this/And: do that" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: This is a really long scenario name to see how the list command deals with wrapping" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width/When: The test headers are printed as part of the normal running of the scenario" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width/When: The test headers are printed as part of the normal running of the scenario/Then: The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up/And when: it is made smaller again" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up/And when: it is made smaller again/Then: the size goes down but the capacity stays the same" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: we reserve more space" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: we reserve more space/Then: The capacity is increased but the size remains the same" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Sends stuff to stdout and stderr" time="{duration}" status="run">
       <system-out>
@@ -1249,6 +1358,8 @@ A string sent to stderr via clog
       </system-err>
     </testcase>
     <testcase classname="<exe-name>.global" name="Some simple comparisons between doubles" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Standard output from all sections is reported" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Standard output from all sections is reported/one" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Standard output from all sections is reported/two" time="{duration}" status="run">
       <system-out>
 Message from section one
@@ -1272,15 +1383,18 @@ with expansion:
 at Matchers.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Static arrays are convertible to string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Static arrays are convertible to string/Single item" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Static arrays are convertible to string/Multiple" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Static arrays are convertible to string/Non-trivial inner items" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="String matchers" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="StringRef" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Empty string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/From string literal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/From sub-string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Copy construction is shallow" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Copy assignment is shallow" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="StringRef/Substrings" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Substrings/zero-based substring" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Substrings/non-zero-based substring" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Substrings/Pointer values of full refs should match" time="{duration}" status="run"/>
@@ -1289,13 +1403,16 @@ at Matchers.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="StringRef/Substrings/Substring off the end are trimmed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Substrings/substring start after the end is empty" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Comparisons are deep" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="StringRef/from std::string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/from std::string/implicitly constructed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/from std::string/explicitly constructed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/from std::string/assigned" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="StringRef/to std::string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/to std::string/explicitly constructed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/to std::string/assigned" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/std::string += StringRef" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/StringRef + StringRef" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="StringRef at compilation time" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef at compilation time/Simple constructors" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef at compilation time/UDL construction" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Stringifying char arrays with statically known sizes - char" time="{duration}" status="run"/>
@@ -1320,6 +1437,7 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Tag alias can be registered against tag patterns" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Tag alias can be registered against tag patterns/The same tag alias can only be registered once" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Tag alias can be registered against tag patterns/Tag aliases must be of the form [@name]" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Tags with spaces and non-alphanumerical characters are accepted" time="{duration}" status="run"/>
@@ -1419,6 +1537,7 @@ at Misc.tests.cpp:<line number>
       </error>
     </testcase>
     <testcase classname="<exe-name>.global" name="The NO_FAIL macro reports a failure but does not fail the test" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="The default listing implementation write to provided stream" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="The default listing implementation write to provided stream/Listing tags" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="The default listing implementation write to provided stream/Listing reporters" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="The default listing implementation write to provided stream/Listing tests" time="{duration}" status="run"/>
@@ -1442,91 +1561,126 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Tracker/successfully close one section, then find another/Re-enter - skips S1 and enters S2/fail S2" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Tracker/open a nested section" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Trim strings" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Custom predicate" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Unexpected exceptions can be translated" time="{duration}" status="run">
       <error type="TEST_CASE">
 FAILED:
-3.14
+3.14000000000000012
 at Exception.tests.cpp:<line number>
       </error>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Upcasting special member functions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Upcasting special member functions/Move constructor" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Upcasting special member functions/move assignment" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/One false evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/One true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/One true evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Some with stdlib containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type requires ADL found size free function" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type has size member" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Use a custom approx" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Variadic macros" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Variadic macros/Section with one argument" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Vector Approx matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector Approx matcher/Empty vector is roughly equal to an empty vector" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Vector Approx matcher/Vectors with elements" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector Approx matcher/Vectors with elements/A vector is approx equal to itself" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector Approx matcher/Vectors with elements/Different length" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector Approx matcher/Vectors with elements/Same length, different elements" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Vector Approx matcher -- failing" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector Approx matcher -- failing/Empty and non empty vectors are not approx equal" time="{duration}" status="run">
       <failure message="empty, Approx( t1 )" type="CHECK_THAT">
 FAILED:
@@ -1545,11 +1699,13 @@ with expansion:
 at Matchers.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Vector matchers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers/Contains (element)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers/Contains (vector)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers/Contains (element), composed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers/Equals" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers/UnorderedEquals" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Vector matchers that fail" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers that fail/Contains (element)" time="{duration}" status="run">
       <failure message="v, VectorContains( -1 )" type="CHECK_THAT">
 FAILED:
@@ -1681,10 +1837,12 @@ unexpected exception
 at Exception.tests.cpp:<line number>
       </error>
     </testcase>
+    <testcase classname="<exe-name>.global" name="When unchecked exceptions are thrown, but caught, they do not affect the test" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="X/level/0/a" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="X/level/0/b" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="X/level/1/a" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="X/level/1/b" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="XmlEncode" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="XmlEncode/normal string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="XmlEncode/empty string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="XmlEncode/string with ampersand" time="{duration}" status="run"/>
@@ -1702,6 +1860,7 @@ at Skip.tests.cpp:<line number>
     </testcase>
     <testcase classname="<exe-name>.global" name="analyse no analysis" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="array&lt;int, N> -> toString" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="benchmark function call" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="benchmark function call/without chronometer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="benchmark function call/with chronometer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="boolean member" time="{duration}" status="run"/>
@@ -1725,6 +1884,7 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="classify_outliers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="classify_outliers/none" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="classify_outliers/low severe" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="classify_outliers/low mild" time="{duration}" status="run"/>
@@ -1749,6 +1909,8 @@ at Skip.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="empty tags are not allowed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="erfc_inv" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="estimate_clock_resolution" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="even more nested SECTION tests" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="even more nested SECTION tests/c" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="even more nested SECTION tests/c/d (leaf)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="even more nested SECTION tests/c/e (leaf)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="even more nested SECTION tests/f (leaf)" time="{duration}" status="run"/>
@@ -1795,6 +1957,8 @@ FAILED:
 at Skip.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="first tag" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="has printf" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="is_unary_function" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="just failure" time="{duration}" status="run">
       <failure type="FAIL">
@@ -1810,7 +1974,10 @@ previous unscoped info SHOULD not be seen
 at Message.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="just info" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="just unscoped info" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="long long" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="looped SECTION tests" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="looped SECTION tests/b is currently: 0" time="{duration}" status="run">
       <failure message="b > a" type="CHECK">
 FAILED:
@@ -1888,12 +2055,15 @@ at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="makeStream recognizes %debug stream name" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="make_unique reimplementation" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="make_unique reimplementation/From lvalue copies" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="make_unique reimplementation/From rvalue moves" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="make_unique reimplementation/Variadic constructor" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="mean" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="measure" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="mix info, unscoped info and warning" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="more nested SECTION tests" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="more nested SECTION tests/equal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="more nested SECTION tests/equal/doesn't equal" time="{duration}" status="run">
       <failure message="a == b" type="REQUIRE">
 FAILED:
@@ -1903,10 +2073,15 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="more nested SECTION tests/doesn't equal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="more nested SECTION tests/doesn't equal/not equal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="more nested SECTION tests/doesn't equal/less than" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="nested SECTION tests" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="nested SECTION tests/doesn't equal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="nested SECTION tests/doesn't equal/not equal" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/A" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/B2" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/B2/B1" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/B2/B" time="{duration}" status="run">
       <skipped type="SKIP">
 SKIPPED
@@ -1922,7 +2097,6 @@ b1!
     </testcase>
     <testcase classname="<exe-name>.global" name="non streamable - with conv. op" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="non-copyable objects" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="normal_cdf" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="normal_quantile" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="not allowed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="not prints unscoped info from previous failures" time="{duration}" status="run">
@@ -1936,6 +2110,7 @@ at Message.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="null strings" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="null_ptr" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="pair&lt;pair&lt;int,const char *,pair&lt;std::string,int> > -> toString" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="parseEnums" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="parseEnums/No enums" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="parseEnums/One enum value" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="parseEnums/Multiple enum values" time="{duration}" status="run"/>
@@ -1958,14 +2133,17 @@ this SHOULD be seen only ONCE
 at Message.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="random SECTION tests" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="random SECTION tests/doesn't equal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="random SECTION tests/not equal" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="replaceInPlace" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace single char" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace two chars" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace first char" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace last char" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace all chars" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace no chars" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="replaceInPlace/no replace in already-replaced string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/no replace in already-replaced string/lengthening" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/no replace in already-replaced string/shortening" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/escape '" time="{duration}" status="run"/>
@@ -1973,6 +2151,8 @@ at Message.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="resolution" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="run_for_at_least, chronometer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="run_for_at_least, int" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="second tag" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime/not skipped" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime/skipped" time="{duration}" status="run">
       <skipped type="SKIP">
@@ -2028,11 +2208,13 @@ at Message.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="startsWith" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="std::map is convertible string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::map is convertible string/empty" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::map is convertible string/single item" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::map is convertible string/several items" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::pair&lt;int,const std::string> -> toString" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::pair&lt;int,std::string> -> toString" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="std::set is convertible string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::set is convertible string/empty" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::set is convertible string/single item" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::set is convertible string/several items" time="{duration}" status="run"/>
@@ -2078,6 +2260,7 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="tuple&lt;tuple&lt;int>,tuple&lt;>,float>" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="uniform samples" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="uniform_integer_distribution can return the bounds" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="unique_ptr reimplementation: basic functionality" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="unique_ptr reimplementation: basic functionality/Default constructed unique_ptr is empty" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="unique_ptr reimplementation: basic functionality/Take ownership of allocation" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="unique_ptr reimplementation: basic functionality/Take ownership of allocation/Plain reset deallocates" time="{duration}" status="run"/>
@@ -2099,6 +2282,7 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="vectors can be sized and resized/reserving smaller does not change size or capacity" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="warmup" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="weighted_average_quantile" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="xmlentitycheck" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="xmlentitycheck/embedded xml: &lt;test>it should be possible to embed xml characters, such as &lt;, &quot; or &amp;, or even whole &lt;xml>documents&lt;/xml> within an attribute&lt;/test>" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="xmlentitycheck/encoded chars: these should all be encoded: &amp;&amp;&amp;&quot;&quot;&quot;&lt;&lt;&lt;&amp;&quot;&lt;&lt;&amp;&quot;" time="{duration}" status="run"/>
     <system-out>

tests/SelfTest/Baselines/junit.sw.multi.approved.txt

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuites>
-  <testsuite name="<exe-name>" errors="17" failures="129" skipped="12" tests="2272" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+  <testsuite name="<exe-name>" errors="17" failures="130" skipped="12" tests="2277" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
     <properties>
       <property name="random-seed" value="1"/>
       <property name="filters" value="&quot;*&quot; ~[!nonportable] ~[!benchmark] ~[approvals]"/>
@@ -11,6 +11,7 @@
     <testcase classname="<exe-name>.global" name="#1175 - Hidden Test" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1238" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.(Fixture_1245&lt;int, int>)" name="#1245" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="#1319: Sections can have description (even if it is not saved" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1319: Sections can have description (even if it is not saved/SectionName" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1403" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1455 - INFO and WARN can start with a linebreak" time="{duration}" status="run"/>
@@ -29,10 +30,12 @@ Nor would this
     </testcase>
     <testcase classname="<exe-name>.global" name="#1548" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1905 -- test spec parser properly clears internal state between compound tests" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="#1912 -- test spec parser handles escaping" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1912 -- test spec parser handles escaping/Various parentheses" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1912 -- test spec parser handles escaping/backslash in test name" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1913 - GENERATE inside a for loop should not keep recreating the generator" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1913 - GENERATEs can share a line" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="#1938 - GENERATE after a section" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1938 - GENERATE after a section/A" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1938 - GENERATE after a section/B" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#1938 - Section followed by flat generate" time="{duration}" status="run"/>
@@ -55,6 +58,7 @@ failure to init
 at Generators.tests.cpp:<line number>
       </error>
     </testcase>
+    <testcase classname="<exe-name>.global" name="#748 - captures with unexpected exceptions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#748 - captures with unexpected exceptions/outside assertions" time="{duration}" status="run">
       <skipped message="TEST_CASE tagged with !mayfail"/>
       <error type="TEST_CASE">
@@ -88,6 +92,7 @@ at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="#872" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="#961 -- Dynamically created sections should all be reported" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#961 -- Dynamically created sections should all be reported/Looped section 0" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#961 -- Dynamically created sections should all be reported/Looped section 1" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="#961 -- Dynamically created sections should all be reported/Looped section 2" time="{duration}" status="run"/>
@@ -146,6 +151,7 @@ at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="'Not' checks that should succeed" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="(unimplemented) static bools can be evaluated" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="(unimplemented) static bools can be evaluated/compare to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="(unimplemented) static bools can be evaluated/compare to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="(unimplemented) static bools can be evaluated/negation" time="{duration}" status="run"/>
@@ -312,6 +318,19 @@ at Class.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.Fixture" name="A TEST_CASE_METHOD based test run that succeeds" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Persistent_Fixture" name="A TEST_CASE_PERSISTENT_FIXTURE based test run that fails/First partial run" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Persistent_Fixture" name="A TEST_CASE_PERSISTENT_FIXTURE based test run that fails/Second partial run" time="{duration}" status="run">
+      <failure message="m_a == 0" type="REQUIRE">
+FAILED:
+  REQUIRE( m_a == 0 )
+with expansion:
+  1 == 0
+at Class.tests.cpp:<line number>
+      </failure>
+    </testcase>
+    <testcase classname="<exe-name>.Persistent_Fixture" name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Persistent_Fixture" name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds/First partial run" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Persistent_Fixture" name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds/Second partial run" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="A Template product test case - Foo&lt;float>" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="A Template product test case - Foo&lt;int>" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="A Template product test case - std::vector&lt;float>" time="{duration}" status="run"/>
@@ -328,6 +347,7 @@ to infinity and beyond
 at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="A couple of nested sections followed by a failure/Outer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="A couple of nested sections followed by a failure/Outer/Inner" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="A failing expression with a non streamable type is still captured" time="{duration}" status="run">
       <failure message="&amp;o1 == &amp;o2" type="CHECK">
@@ -346,6 +366,7 @@ at Tricky.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="Absolute margin" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="An empty test with no assertions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="An expression with side-effects should only be evaluated once" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="An unchecked exception reports the line of the last assertion" time="{duration}" status="run">
       <error message="{Unknown expression after the reported line}">
@@ -363,6 +384,7 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Approximate comparisons with floats" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Approximate comparisons with ints" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Approximate comparisons with mixed numeric types" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Arbitrary predicate matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Arbitrary predicate matcher/Function pointer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Arbitrary predicate matcher/Lambdas + different type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Assertion macros support bit operators and bool conversions" time="{duration}" status="run"/>
@@ -370,30 +392,39 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Assertions then sections/A section" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Assertions then sections/A section/Another section" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Assertions then sections/A section/Another other section" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Different argument ranges, same element type, default comparison" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Different argument ranges, same element type, custom comparison" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Different element type, custom comparisons" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Can handle type that requires ADL-found free function begin and end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Initialization with move only types" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Contains range matcher/Matching using matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Basic use of the Empty range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Empty range matcher/Simple, std-provided containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Empty range matcher/Type with empty" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Basic use of the Empty range matcher/Type requires ADL found empty free function" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CAPTURE can deal with complex expressions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CAPTURE can deal with complex expressions involving commas" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CAPTURE parses string and character constants" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Capture and info messages" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Capture and info messages/Capture should stringify like assertions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Capture and info messages/Info should NOT stringify the way assertions do" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="CaseInsensitiveEqualsTo is case insensitive" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CaseInsensitiveEqualsTo is case insensitive/Degenerate cases" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CaseInsensitiveEqualsTo is case insensitive/Plain comparisons" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="CaseInsensitiveLess is case insensitive" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CaseInsensitiveLess is case insensitive/Degenerate cases" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="CaseInsensitiveLess is case insensitive/Plain comparisons" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Character pretty printing" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Character pretty printing/Specifically escaped" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Character pretty printing/General chars" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Character pretty printing/Low ASCII" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Clara::Arg does not crash on incomplete input" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Clara::Arg supports single-arg parse the way Opt does" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Clara::Opt supports accept-many lambdas" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Clara::Opt supports accept-many lambdas/Parsing fails on multiple options without accept_many" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Clara::Opt supports accept-many lambdas/Parsing succeeds on multiple options with accept_many" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="ColourGuard behaviour" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="ColourGuard behaviour/ColourGuard is disengaged by default" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="ColourGuard behaviour/ColourGuard is engaged by op&lt;&lt;" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="ColourGuard behaviour/ColourGuard can be engaged explicitly" time="{duration}" status="run"/>
@@ -411,8 +442,10 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Comparisons between ints where one side is computed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Comparisons with int literals don't warn when mixing signed/ unsigned" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Composed generic matchers shortcircuit" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Composed generic matchers shortcircuit/MatchAllOf" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Composed generic matchers shortcircuit/MatchAnyOf" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Composed matchers shortcircuit" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Composed matchers shortcircuit/MatchAllOf" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Composed matchers shortcircuit/MatchAnyOf" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Contains string matcher" time="{duration}" status="run">
@@ -432,6 +465,7 @@ with expansion:
 at Matchers.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Copy and then generate a range" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Copy and then generate a range/from var and iterators" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Copy and then generate a range/From a temporary container" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Copy and then generate a range/Final validation" time="{duration}" status="run"/>
@@ -516,35 +550,39 @@ at Condition.tests.cpp:<line number>
 FAILED:
   CHECK( data.float_nine_point_one == Approx( 9.11f ) )
 with expansion:
-  9.1f == Approx( 9.1099996567 )
+  9.100000381f
+  ==
+  Approx( 9.10999965667724609 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.float_nine_point_one == Approx( 9.0f )" type="CHECK">
 FAILED:
   CHECK( data.float_nine_point_one == Approx( 9.0f ) )
 with expansion:
-  9.1f == Approx( 9.0 )
+  9.100000381f == Approx( 9.0 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.float_nine_point_one == Approx( 1 )" type="CHECK">
 FAILED:
   CHECK( data.float_nine_point_one == Approx( 1 ) )
 with expansion:
-  9.1f == Approx( 1.0 )
+  9.100000381f == Approx( 1.0 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.float_nine_point_one == Approx( 0 )" type="CHECK">
 FAILED:
   CHECK( data.float_nine_point_one == Approx( 0 ) )
 with expansion:
-  9.1f == Approx( 0.0 )
+  9.100000381f == Approx( 0.0 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.double_pi == Approx( 3.1415 )" type="CHECK">
 FAILED:
   CHECK( data.double_pi == Approx( 3.1415 ) )
 with expansion:
-  3.1415926535 == Approx( 3.1415 )
+  3.14159265350000005
+  ==
+  Approx( 3.14150000000000018 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.str_hello == &quot;goodbye&quot;" type="CHECK">
@@ -579,7 +617,9 @@ at Condition.tests.cpp:<line number>
 FAILED:
   CHECK( x == Approx( 1.301 ) )
 with expansion:
-  1.3 == Approx( 1.301 )
+  1.30000000000000027
+  ==
+  Approx( 1.30099999999999993 )
 at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
@@ -648,6 +688,7 @@ at Matchers.tests.cpp:<line number>
     </testcase>
     <testcase classname="<exe-name>.global" name="Exception matchers that succeed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Exception message can be matched" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Exception messages can be tested for" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Exception messages can be tested for/exact match" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Exception messages can be tested for/different case" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Exception messages can be tested for/wildcarded" time="{duration}" status="run"/>
@@ -693,6 +734,7 @@ at Message.tests.cpp:<line number>
     </testcase>
     <testcase classname="<exe-name>.global" name="Factorials are computed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Filter generator throws exception for empty generator" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Floating point matchers: double" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/Relative" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/Relative/Some subnormal values" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/Margin" time="{duration}" status="run"/>
@@ -700,6 +742,7 @@ at Message.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/Composed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/Constructor validation" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: double/IsNaN" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Floating point matchers: float" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: float/Relative" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: float/Relative/Some subnormal values" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: float/Margin" time="{duration}" status="run"/>
@@ -708,46 +751,64 @@ at Message.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Floating point matchers: float/Constructor validation" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Floating point matchers: float/IsNaN" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="GENERATE can combine literals and generators" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators -- adapters" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators -- adapters/Filtering by predicate" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Filtering by predicate/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Filtering by predicate/Throws if there are no matching values" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Shortening a range" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators -- adapters/Transforming elements" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Transforming elements/Same type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Transforming elements/Different type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Transforming elements/Different deduced type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Repeating a generator" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators -- adapters/Chunking a generator into sized pieces" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Chunking a generator into sized pieces/Number of elements in source is divisible by chunk size" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Chunking a generator into sized pieces/Number of elements in source is not divisible by chunk size" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Chunking a generator into sized pieces/Chunk size of zero" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- adapters/Chunking a generator into sized pieces/Throws on too small generators" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators -- simple" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- simple/one" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators -- simple/two" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Single value" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Preset values" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Generator combinator" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Explicitly typed generator sequence" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Filter generator" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Filter generator/Simple filtering" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Filter generator/Filter out multiple elements at the start and end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Filter generator/Throws on construction if it can't get initial element" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Take generator" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Take generator/Take less" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Take generator/Take more" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Map with explicit return type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Map with deduced return type" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Repeat" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Repeat/Singular repeat" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Repeat/Actual repeat" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive auto step" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive auto step/Integer" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative auto step" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative auto step/Integer" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Integer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Integer/Exact" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Integer/Slightly over end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Integer/Slightly under end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Floating Point" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Floating Point/Exact" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Floating Point/Slightly over end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Positive manual step/Floating Point/Slightly under end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative manual step" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative manual step/Integer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative manual step/Integer/Exact" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative manual step/Integer/Slightly over end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Generators internals/Range/Negative manual step/Integer/Slightly under end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Greater-than inequalities with different epsilons" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Hashers with different seed produce different hash with same test case" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Hashers with same seed produce same hash" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Hashing different test cases produces different result" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Hashing different test cases produces different result/Different test name" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Hashing different test cases produces different result/Different classname" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Hashing different test cases produces different result/Different tags" time="{duration}" status="run"/>
@@ -827,14 +888,18 @@ at Condition.tests.cpp:<line number>
 FAILED:
   CHECK( data.float_nine_point_one != Approx( 9.1f ) )
 with expansion:
-  9.1f != Approx( 9.1000003815 )
+  9.100000381f
+  !=
+  Approx( 9.10000038146972656 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.double_pi != Approx( 3.1415926535 )" type="CHECK">
 FAILED:
   CHECK( data.double_pi != Approx( 3.1415926535 ) )
 with expansion:
-  3.1415926535 != Approx( 3.1415926535 )
+  3.14159265350000005
+  !=
+  Approx( 3.14159265350000005 )
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.str_hello != &quot;hello&quot;" type="CHECK">
@@ -853,6 +918,7 @@ at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="Inequality checks that should succeed" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Newly constructed JsonWriter does nothing" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Calling writeObject will create an empty pair of braces" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Calling writeObject with key will create an object to write the value" time="{duration}" status="run"/>
@@ -862,6 +928,7 @@ at Condition.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="JsonWriter/Moved from JsonObjectWriter shall not insert superfluous brace" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Moved from JsonArrayWriter shall not insert superfluous bracket" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Custom class shall be quoted" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Quote in a string is escaped" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Backslash in a string is escaped" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Forward slash in a string is **not** escaped" time="{duration}" status="run"/>
@@ -897,6 +964,9 @@ with expansion:
 at Matchers.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1" time="{duration}" status="run">
+      <skipped message="TEST_CASE tagged with !mayfail"/>
+    </testcase>
     <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1/A" time="{duration}" status="run">
       <skipped message="TEST_CASE tagged with !mayfail"/>
       <failure type="FAIL">
@@ -904,6 +974,9 @@ FAILED:
 at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2" time="{duration}" status="run">
+      <skipped message="TEST_CASE tagged with !mayfail"/>
+    </testcase>
     <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2/A" time="{duration}" status="run">
       <skipped message="TEST_CASE tagged with !mayfail"/>
       <failure type="FAIL">
@@ -911,6 +984,9 @@ FAILED:
 at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1" time="{duration}" status="run">
+      <skipped message="TEST_CASE tagged with !mayfail"/>
+    </testcase>
     <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1/B" time="{duration}" status="run">
       <skipped message="TEST_CASE tagged with !mayfail"/>
       <failure type="FAIL">
@@ -918,6 +994,9 @@ FAILED:
 at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2" time="{duration}" status="run">
+      <skipped message="TEST_CASE tagged with !mayfail"/>
+    </testcase>
     <testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2/B" time="{duration}" status="run">
       <skipped message="TEST_CASE tagged with !mayfail"/>
       <failure type="FAIL">
@@ -1010,21 +1089,21 @@ at Condition.tests.cpp:<line number>
 FAILED:
   CHECK( data.float_nine_point_one &lt; 9 )
 with expansion:
-  9.1f &lt; 9
+  9.100000381f &lt; 9
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.float_nine_point_one > 10" type="CHECK">
 FAILED:
   CHECK( data.float_nine_point_one > 10 )
 with expansion:
-  9.1f > 10
+  9.100000381f > 10
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.float_nine_point_one > 9.2" type="CHECK">
 FAILED:
   CHECK( data.float_nine_point_one > 9.2 )
 with expansion:
-  9.1f > 9.2
+  9.100000381f > 9.19999999999999929
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="data.str_hello > &quot;hello&quot;" type="CHECK">
@@ -1085,6 +1164,7 @@ at Condition.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="Ordering comparison checks that should succeed" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Our PCG implementation provides expected results for known seeds" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Our PCG implementation provides expected results for known seeds/Default seeded" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Our PCG implementation provides expected results for known seeds/Specific seed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Output from all sections is reported/one" time="{duration}" status="run">
@@ -1102,9 +1182,11 @@ at Message.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="Overloaded comma or address-of operators are not used" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Parse uints" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parse uints/proper inputs" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parse uints/Bad inputs" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsed tags are matched case insensitive" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/shard-count" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/Negative shard count reports error" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/Zero shard count reports error" time="{duration}" status="run"/>
@@ -1112,44 +1194,58 @@ at Message.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/Negative shard index reports error" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/Shard index 0 is accepted" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing tags with non-alphabetical characters is pass-through" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Parsing warnings" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing warnings/NoAssertions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing warnings/NoTests is no longer supported" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Parsing warnings/Combining multiple warnings" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Pointers can be compared to null" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Precision of floating point stringification can be set" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Precision of floating point stringification can be set/Floats" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Precision of floating point stringification can be set/Double" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Predicate matcher can accept const char*" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/empty args don't cause a crash" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/default - no arguments" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/test lists" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/test lists/Specify one test case using" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/test lists/Specify one test case exclusion using exclude:" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/test lists/Specify one test case exclusion using ~" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/-r/console" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/-r/xml" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/--reporter/junit" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/must match one of the available ones" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/With output file" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/With Windows-like absolute path as output file" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/Multiple reporters" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/Multiple reporters/All with output files" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/Multiple reporters/Mixed output files and default output" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/reporter/Multiple reporters/cannot have multiple reporters with default output" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/debugger" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/debugger/-b" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/debugger/--break" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/-a aborts after first failure" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/-x 2 aborts after two failures" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/-x must be numeric" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/wait-for-keypress" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/wait-for-keypress/Accepted options" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/wait-for-keypress/invalid options are reported" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/nothrow" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/nothrow/-e" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/nothrow/--nothrow" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/output filename" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/output filename/-o filename" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/output filename/--out" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/combinations" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/combinations/Single character flags can be combined" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour/without option" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour/auto" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour/yes" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour/no" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour/error" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/samples" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/resamples" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/confidence-interval" time="{duration}" status="run"/>
@@ -1229,14 +1325,27 @@ at Matchers.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="SUCCEED counts as a test pass" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="SUCCEED does not require an argument" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Fixture" name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.Fixture" name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.Fixture" name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me/When: We get the count" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.Fixture" name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me/When: We get the count/Then: Subsequently values are higher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing/Given: This stuff exists" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this/Then: it should do this" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this/Then: it should do this/And: do that" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: This is a really long scenario name to see how the list command deals with wrapping" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width/When: The test headers are printed as part of the normal running of the scenario" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width/When: The test headers are printed as part of the normal running of the scenario/Then: The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up/And when: it is made smaller again" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up/And when: it is made smaller again/Then: the size goes down but the capacity stays the same" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: we reserve more space" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: we reserve more space/Then: The capacity is increased but the size remains the same" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Sends stuff to stdout and stderr" time="{duration}" status="run">
       <system-out>
@@ -1248,6 +1357,8 @@ A string sent to stderr via clog
       </system-err>
     </testcase>
     <testcase classname="<exe-name>.global" name="Some simple comparisons between doubles" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Standard output from all sections is reported" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Standard output from all sections is reported/one" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Standard output from all sections is reported/two" time="{duration}" status="run">
       <system-out>
 Message from section one
@@ -1271,15 +1382,18 @@ with expansion:
 at Matchers.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Static arrays are convertible to string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Static arrays are convertible to string/Single item" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Static arrays are convertible to string/Multiple" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Static arrays are convertible to string/Non-trivial inner items" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="String matchers" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="StringRef" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Empty string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/From string literal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/From sub-string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Copy construction is shallow" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Copy assignment is shallow" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="StringRef/Substrings" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Substrings/zero-based substring" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Substrings/non-zero-based substring" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Substrings/Pointer values of full refs should match" time="{duration}" status="run"/>
@@ -1288,13 +1402,16 @@ at Matchers.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="StringRef/Substrings/Substring off the end are trimmed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Substrings/substring start after the end is empty" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/Comparisons are deep" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="StringRef/from std::string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/from std::string/implicitly constructed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/from std::string/explicitly constructed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/from std::string/assigned" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="StringRef/to std::string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/to std::string/explicitly constructed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/to std::string/assigned" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/std::string += StringRef" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef/StringRef + StringRef" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="StringRef at compilation time" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef at compilation time/Simple constructors" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="StringRef at compilation time/UDL construction" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Stringifying char arrays with statically known sizes - char" time="{duration}" status="run"/>
@@ -1319,6 +1436,7 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Tag alias can be registered against tag patterns" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Tag alias can be registered against tag patterns/The same tag alias can only be registered once" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Tag alias can be registered against tag patterns/Tag aliases must be of the form [@name]" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Tags with spaces and non-alphanumerical characters are accepted" time="{duration}" status="run"/>
@@ -1418,6 +1536,7 @@ at Misc.tests.cpp:<line number>
       </error>
     </testcase>
     <testcase classname="<exe-name>.global" name="The NO_FAIL macro reports a failure but does not fail the test" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="The default listing implementation write to provided stream" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="The default listing implementation write to provided stream/Listing tags" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="The default listing implementation write to provided stream/Listing reporters" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="The default listing implementation write to provided stream/Listing tests" time="{duration}" status="run"/>
@@ -1441,91 +1560,126 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Tracker/successfully close one section, then find another/Re-enter - skips S1 and enters S2/fail S2" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Tracker/open a nested section" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Trim strings" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Custom predicate" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Unexpected exceptions can be translated" time="{duration}" status="run">
       <error type="TEST_CASE">
 FAILED:
-3.14
+3.14000000000000012
 at Exception.tests.cpp:<line number>
       </error>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Upcasting special member functions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Upcasting special member functions/Move constructor" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Upcasting special member functions/move assignment" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/One false evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/One true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/One true evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evaluates to false" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Some with stdlib containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type requires ADL found size free function" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type has size member" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Use a custom approx" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Variadic macros" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Variadic macros/Section with one argument" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Vector Approx matcher" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector Approx matcher/Empty vector is roughly equal to an empty vector" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Vector Approx matcher/Vectors with elements" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector Approx matcher/Vectors with elements/A vector is approx equal to itself" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector Approx matcher/Vectors with elements/Different length" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector Approx matcher/Vectors with elements/Same length, different elements" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Vector Approx matcher -- failing" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector Approx matcher -- failing/Empty and non empty vectors are not approx equal" time="{duration}" status="run">
       <failure message="empty, Approx( t1 )" type="CHECK_THAT">
 FAILED:
@@ -1544,11 +1698,13 @@ with expansion:
 at Matchers.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="Vector matchers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers/Contains (element)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers/Contains (vector)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers/Contains (element), composed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers/Equals" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers/UnorderedEquals" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Vector matchers that fail" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Vector matchers that fail/Contains (element)" time="{duration}" status="run">
       <failure message="v, VectorContains( -1 )" type="CHECK_THAT">
 FAILED:
@@ -1680,10 +1836,12 @@ unexpected exception
 at Exception.tests.cpp:<line number>
       </error>
     </testcase>
+    <testcase classname="<exe-name>.global" name="When unchecked exceptions are thrown, but caught, they do not affect the test" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="X/level/0/a" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="X/level/0/b" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="X/level/1/a" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="X/level/1/b" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="XmlEncode" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="XmlEncode/normal string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="XmlEncode/empty string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="XmlEncode/string with ampersand" time="{duration}" status="run"/>
@@ -1701,6 +1859,7 @@ at Skip.tests.cpp:<line number>
     </testcase>
     <testcase classname="<exe-name>.global" name="analyse no analysis" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="array&lt;int, N> -> toString" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="benchmark function call" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="benchmark function call/without chronometer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="benchmark function call/with chronometer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="boolean member" time="{duration}" status="run"/>
@@ -1724,6 +1883,7 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="classify_outliers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="classify_outliers/none" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="classify_outliers/low severe" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="classify_outliers/low mild" time="{duration}" status="run"/>
@@ -1748,6 +1908,8 @@ at Skip.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="empty tags are not allowed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="erfc_inv" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="estimate_clock_resolution" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="even more nested SECTION tests" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="even more nested SECTION tests/c" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="even more nested SECTION tests/c/d (leaf)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="even more nested SECTION tests/c/e (leaf)" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="even more nested SECTION tests/f (leaf)" time="{duration}" status="run"/>
@@ -1794,6 +1956,8 @@ FAILED:
 at Skip.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="first tag" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="has printf" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="is_unary_function" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="just failure" time="{duration}" status="run">
       <failure type="FAIL">
@@ -1809,7 +1973,10 @@ previous unscoped info SHOULD not be seen
 at Message.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="just info" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="just unscoped info" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="long long" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="looped SECTION tests" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="looped SECTION tests/b is currently: 0" time="{duration}" status="run">
       <failure message="b > a" type="CHECK">
 FAILED:
@@ -1887,12 +2054,15 @@ at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="makeStream recognizes %debug stream name" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="make_unique reimplementation" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="make_unique reimplementation/From lvalue copies" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="make_unique reimplementation/From rvalue moves" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="make_unique reimplementation/Variadic constructor" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="mean" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="measure" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="mix info, unscoped info and warning" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="more nested SECTION tests" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="more nested SECTION tests/equal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="more nested SECTION tests/equal/doesn't equal" time="{duration}" status="run">
       <failure message="a == b" type="REQUIRE">
 FAILED:
@@ -1902,10 +2072,15 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="more nested SECTION tests/doesn't equal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="more nested SECTION tests/doesn't equal/not equal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="more nested SECTION tests/doesn't equal/less than" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="nested SECTION tests" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="nested SECTION tests/doesn't equal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="nested SECTION tests/doesn't equal/not equal" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/A" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/B2" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/B2/B1" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/B2/B" time="{duration}" status="run">
       <skipped type="SKIP">
 SKIPPED
@@ -1921,7 +2096,6 @@ b1!
     </testcase>
     <testcase classname="<exe-name>.global" name="non streamable - with conv. op" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="non-copyable objects" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="normal_cdf" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="normal_quantile" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="not allowed" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="not prints unscoped info from previous failures" time="{duration}" status="run">
@@ -1935,6 +2109,7 @@ at Message.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="null strings" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="null_ptr" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="pair&lt;pair&lt;int,const char *,pair&lt;std::string,int> > -> toString" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="parseEnums" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="parseEnums/No enums" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="parseEnums/One enum value" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="parseEnums/Multiple enum values" time="{duration}" status="run"/>
@@ -1957,14 +2132,17 @@ this SHOULD be seen only ONCE
 at Message.tests.cpp:<line number>
       </failure>
     </testcase>
+    <testcase classname="<exe-name>.global" name="random SECTION tests" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="random SECTION tests/doesn't equal" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="random SECTION tests/not equal" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="replaceInPlace" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace single char" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace two chars" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace first char" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace last char" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace all chars" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/replace no chars" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="replaceInPlace/no replace in already-replaced string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/no replace in already-replaced string/lengthening" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/no replace in already-replaced string/shortening" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="replaceInPlace/escape '" time="{duration}" status="run"/>
@@ -1972,6 +2150,8 @@ at Message.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="resolution" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="run_for_at_least, chronometer" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="run_for_at_least, int" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="second tag" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime/not skipped" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime/skipped" time="{duration}" status="run">
       <skipped type="SKIP">
@@ -2027,11 +2207,13 @@ at Message.tests.cpp:<line number>
       </failure>
     </testcase>
     <testcase classname="<exe-name>.global" name="startsWith" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="std::map is convertible string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::map is convertible string/empty" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::map is convertible string/single item" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::map is convertible string/several items" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::pair&lt;int,const std::string> -> toString" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::pair&lt;int,std::string> -> toString" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="std::set is convertible string" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::set is convertible string/empty" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::set is convertible string/single item" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="std::set is convertible string/several items" time="{duration}" status="run"/>
@@ -2077,6 +2259,7 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="tuple&lt;tuple&lt;int>,tuple&lt;>,float>" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="uniform samples" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="uniform_integer_distribution can return the bounds" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="unique_ptr reimplementation: basic functionality" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="unique_ptr reimplementation: basic functionality/Default constructed unique_ptr is empty" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="unique_ptr reimplementation: basic functionality/Take ownership of allocation" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="unique_ptr reimplementation: basic functionality/Take ownership of allocation/Plain reset deallocates" time="{duration}" status="run"/>
@@ -2098,6 +2281,7 @@ at Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="vectors can be sized and resized/reserving smaller does not change size or capacity" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="warmup" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="weighted_average_quantile" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="xmlentitycheck" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="xmlentitycheck/embedded xml: &lt;test>it should be possible to embed xml characters, such as &lt;, &quot; or &amp;, or even whole &lt;xml>documents&lt;/xml> within an attribute&lt;/test>" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="xmlentitycheck/encoded chars: these should all be encoded: &amp;&amp;&amp;&quot;&quot;&quot;&lt;&lt;&lt;&amp;&quot;&lt;&lt;&amp;&quot;" time="{duration}" status="run"/>
     <system-out>

tests/SelfTest/Baselines/sonarqube.sw.approved.txt

@@ -13,52 +13,68 @@ at AssertionHandler.tests.cpp:<line number>
     </testCase>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp">
+    <testCase name="Clara::Arg does not crash on incomplete input" duration="{duration}"/>
     <testCase name="Clara::Arg supports single-arg parse the way Opt does" duration="{duration}"/>
+    <testCase name="Clara::Opt supports accept-many lambdas" duration="{duration}"/>
     <testCase name="Clara::Opt supports accept-many lambdas/Parsing fails on multiple options without accept_many" duration="{duration}"/>
     <testCase name="Clara::Opt supports accept-many lambdas/Parsing succeeds on multiple options with accept_many" duration="{duration}"/>
     <testCase name="is_unary_function" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp">
+    <testCase name="Parsing sharding-related cli flags" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/shard-count" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/Negative shard count reports error" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/Zero shard count reports error" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/shard-index" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/Negative shard index reports error" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/Shard index 0 is accepted" duration="{duration}"/>
+    <testCase name="Parsing warnings" duration="{duration}"/>
     <testCase name="Parsing warnings/NoAssertions" duration="{duration}"/>
     <testCase name="Parsing warnings/NoTests is no longer supported" duration="{duration}"/>
     <testCase name="Parsing warnings/Combining multiple warnings" duration="{duration}"/>
+    <testCase name="Process can be configured on command line" duration="{duration}"/>
     <testCase name="Process can be configured on command line/empty args don't cause a crash" duration="{duration}"/>
     <testCase name="Process can be configured on command line/default - no arguments" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/test lists" duration="{duration}"/>
     <testCase name="Process can be configured on command line/test lists/Specify one test case using" duration="{duration}"/>
     <testCase name="Process can be configured on command line/test lists/Specify one test case exclusion using exclude:" duration="{duration}"/>
     <testCase name="Process can be configured on command line/test lists/Specify one test case exclusion using ~" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/reporter" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/-r/console" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/-r/xml" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/--reporter/junit" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/must match one of the available ones" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/With output file" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/With Windows-like absolute path as output file" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/reporter/Multiple reporters" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/Multiple reporters/All with output files" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/Multiple reporters/Mixed output files and default output" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/Multiple reporters/cannot have multiple reporters with default output" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/debugger" duration="{duration}"/>
     <testCase name="Process can be configured on command line/debugger/-b" duration="{duration}"/>
     <testCase name="Process can be configured on command line/debugger/--break" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/abort" duration="{duration}"/>
     <testCase name="Process can be configured on command line/abort/-a aborts after first failure" duration="{duration}"/>
     <testCase name="Process can be configured on command line/abort/-x 2 aborts after two failures" duration="{duration}"/>
     <testCase name="Process can be configured on command line/abort/-x must be numeric" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/abort/wait-for-keypress" duration="{duration}"/>
     <testCase name="Process can be configured on command line/abort/wait-for-keypress/Accepted options" duration="{duration}"/>
     <testCase name="Process can be configured on command line/abort/wait-for-keypress/invalid options are reported" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/nothrow" duration="{duration}"/>
     <testCase name="Process can be configured on command line/nothrow/-e" duration="{duration}"/>
     <testCase name="Process can be configured on command line/nothrow/--nothrow" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/output filename" duration="{duration}"/>
     <testCase name="Process can be configured on command line/output filename/-o filename" duration="{duration}"/>
     <testCase name="Process can be configured on command line/output filename/--out" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/combinations" duration="{duration}"/>
     <testCase name="Process can be configured on command line/combinations/Single character flags can be combined" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/use-colour" duration="{duration}"/>
     <testCase name="Process can be configured on command line/use-colour/without option" duration="{duration}"/>
     <testCase name="Process can be configured on command line/use-colour/auto" duration="{duration}"/>
     <testCase name="Process can be configured on command line/use-colour/yes" duration="{duration}"/>
     <testCase name="Process can be configured on command line/use-colour/no" duration="{duration}"/>
     <testCase name="Process can be configured on command line/use-colour/error" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/Benchmark options" duration="{duration}"/>
     <testCase name="Process can be configured on command line/Benchmark options/samples" duration="{duration}"/>
     <testCase name="Process can be configured on command line/Benchmark options/resamples" duration="{duration}"/>
     <testCase name="Process can be configured on command line/Benchmark options/confidence-interval" duration="{duration}"/>
@@ -67,13 +83,16 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="Test with special, characters &quot;in name" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp">
+    <testCase name="ColourGuard behaviour" duration="{duration}"/>
     <testCase name="ColourGuard behaviour/ColourGuard is disengaged by default" duration="{duration}"/>
     <testCase name="ColourGuard behaviour/ColourGuard is engaged by op&lt;&lt;" duration="{duration}"/>
     <testCase name="ColourGuard behaviour/ColourGuard can be engaged explicitly" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp">
+    <testCase name="CaseInsensitiveEqualsTo is case insensitive" duration="{duration}"/>
     <testCase name="CaseInsensitiveEqualsTo is case insensitive/Degenerate cases" duration="{duration}"/>
     <testCase name="CaseInsensitiveEqualsTo is case insensitive/Plain comparisons" duration="{duration}"/>
+    <testCase name="CaseInsensitiveLess is case insensitive" duration="{duration}"/>
     <testCase name="CaseInsensitiveLess is case insensitive/Degenerate cases" duration="{duration}"/>
     <testCase name="CaseInsensitiveLess is case insensitive/Plain comparisons" duration="{duration}"/>
   </file>
@@ -82,35 +101,49 @@ at AssertionHandler.tests.cpp:<line number>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp">
     <testCase name="Filter generator throws exception for empty generator" duration="{duration}"/>
+    <testCase name="Generators internals" duration="{duration}"/>
     <testCase name="Generators internals/Single value" duration="{duration}"/>
     <testCase name="Generators internals/Preset values" duration="{duration}"/>
     <testCase name="Generators internals/Generator combinator" duration="{duration}"/>
     <testCase name="Generators internals/Explicitly typed generator sequence" duration="{duration}"/>
+    <testCase name="Generators internals/Filter generator" duration="{duration}"/>
     <testCase name="Generators internals/Filter generator/Simple filtering" duration="{duration}"/>
     <testCase name="Generators internals/Filter generator/Filter out multiple elements at the start and end" duration="{duration}"/>
     <testCase name="Generators internals/Filter generator/Throws on construction if it can't get initial element" duration="{duration}"/>
+    <testCase name="Generators internals/Take generator" duration="{duration}"/>
     <testCase name="Generators internals/Take generator/Take less" duration="{duration}"/>
     <testCase name="Generators internals/Take generator/Take more" duration="{duration}"/>
     <testCase name="Generators internals/Map with explicit return type" duration="{duration}"/>
     <testCase name="Generators internals/Map with deduced return type" duration="{duration}"/>
+    <testCase name="Generators internals/Repeat" duration="{duration}"/>
     <testCase name="Generators internals/Repeat/Singular repeat" duration="{duration}"/>
     <testCase name="Generators internals/Repeat/Actual repeat" duration="{duration}"/>
+    <testCase name="Generators internals/Range" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Positive auto step" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive auto step/Integer" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Negative auto step" duration="{duration}"/>
     <testCase name="Generators internals/Range/Negative auto step/Integer" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Positive manual step" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Positive manual step/Integer" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Integer/Exact" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Integer/Slightly over end" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Integer/Slightly under end" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Positive manual step/Floating Point" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Floating Point/Exact" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Floating Point/Slightly over end" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Floating Point/Slightly under end" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Negative manual step" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Negative manual step/Integer" duration="{duration}"/>
     <testCase name="Generators internals/Range/Negative manual step/Integer/Exact" duration="{duration}"/>
     <testCase name="Generators internals/Range/Negative manual step/Integer/Slightly over end" duration="{duration}"/>
     <testCase name="Generators internals/Range/Negative manual step/Integer/Slightly under end" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp">
     <testCase name="analyse no analysis" duration="{duration}"/>
+    <testCase name="benchmark function call" duration="{duration}"/>
     <testCase name="benchmark function call/without chronometer" duration="{duration}"/>
     <testCase name="benchmark function call/with chronometer" duration="{duration}"/>
+    <testCase name="classify_outliers" duration="{duration}"/>
     <testCase name="classify_outliers/none" duration="{duration}"/>
     <testCase name="classify_outliers/low severe" duration="{duration}"/>
     <testCase name="classify_outliers/low mild" duration="{duration}"/>
@@ -121,7 +154,6 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="estimate_clock_resolution" duration="{duration}"/>
     <testCase name="mean" duration="{duration}"/>
     <testCase name="measure" duration="{duration}"/>
-    <testCase name="normal_cdf" duration="{duration}"/>
     <testCase name="normal_quantile" duration="{duration}"/>
     <testCase name="resolution" duration="{duration}"/>
     <testCase name="run_for_at_least, chronometer" duration="{duration}"/>
@@ -131,6 +163,7 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="weighted_average_quantile" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Json.tests.cpp">
+    <testCase name="JsonWriter" duration="{duration}"/>
     <testCase name="JsonWriter/Newly constructed JsonWriter does nothing" duration="{duration}"/>
     <testCase name="JsonWriter/Calling writeObject will create an empty pair of braces" duration="{duration}"/>
     <testCase name="JsonWriter/Calling writeObject with key will create an object to write the value" duration="{duration}"/>
@@ -140,6 +173,7 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="JsonWriter/Moved from JsonObjectWriter shall not insert superfluous brace" duration="{duration}"/>
     <testCase name="JsonWriter/Moved from JsonArrayWriter shall not insert superfluous bracket" duration="{duration}"/>
     <testCase name="JsonWriter/Custom class shall be quoted" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly" duration="{duration}"/>
     <testCase name="JsonWriter escapes charaters in strings properly/Quote in a string is escaped" duration="{duration}"/>
     <testCase name="JsonWriter escapes charaters in strings properly/Backslash in a string is escaped" duration="{duration}"/>
     <testCase name="JsonWriter escapes charaters in strings properly/Forward slash in a string is **not** escaped" duration="{duration}"/>
@@ -151,10 +185,12 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="JsonWriter escapes charaters in strings properly/combination of characters is escaped" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp">
+    <testCase name="Parse uints" duration="{duration}"/>
     <testCase name="Parse uints/proper inputs" duration="{duration}"/>
     <testCase name="Parse uints/Bad inputs" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp">
+    <testCase name="#1938 - GENERATE after a section" duration="{duration}"/>
     <testCase name="#1938 - GENERATE after a section/A" duration="{duration}"/>
     <testCase name="#1938 - GENERATE after a section/B" duration="{duration}"/>
     <testCase name="#1938 - Section followed by flat generate" duration="{duration}"/>
@@ -177,6 +213,7 @@ at AssertionHandler.tests.cpp:<line number>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp">
     <testCase name="Comparison ops" duration="{duration}"/>
+    <testCase name="Our PCG implementation provides expected results for known seeds" duration="{duration}"/>
     <testCase name="Our PCG implementation provides expected results for known seeds/Default seeded" duration="{duration}"/>
     <testCase name="Our PCG implementation provides expected results for known seeds/Specific seed" duration="{duration}"/>
     <testCase name="Random seed generation accepts known methods" duration="{duration}"/>
@@ -218,6 +255,7 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="Reporter's write listings to provided stream/XML reporter lists reporters" duration="{duration}"/>
     <testCase name="Reporter's write listings to provided stream/XML reporter lists tests" duration="{duration}"/>
     <testCase name="Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla" duration="{duration}"/>
+    <testCase name="The default listing implementation write to provided stream" duration="{duration}"/>
     <testCase name="The default listing implementation write to provided stream/Listing tags" duration="{duration}"/>
     <testCase name="The default listing implementation write to provided stream/Listing reporters" duration="{duration}"/>
     <testCase name="The default listing implementation write to provided stream/Listing tests" duration="{duration}"/>
@@ -231,11 +269,13 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="stdout and stderr streams have %-starting name" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/String.tests.cpp">
+    <testCase name="StringRef" duration="{duration}"/>
     <testCase name="StringRef/Empty string" duration="{duration}"/>
     <testCase name="StringRef/From string literal" duration="{duration}"/>
     <testCase name="StringRef/From sub-string" duration="{duration}"/>
     <testCase name="StringRef/Copy construction is shallow" duration="{duration}"/>
     <testCase name="StringRef/Copy assignment is shallow" duration="{duration}"/>
+    <testCase name="StringRef/Substrings" duration="{duration}"/>
     <testCase name="StringRef/Substrings/zero-based substring" duration="{duration}"/>
     <testCase name="StringRef/Substrings/non-zero-based substring" duration="{duration}"/>
     <testCase name="StringRef/Substrings/Pointer values of full refs should match" duration="{duration}"/>
@@ -244,24 +284,29 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="StringRef/Substrings/Substring off the end are trimmed" duration="{duration}"/>
     <testCase name="StringRef/Substrings/substring start after the end is empty" duration="{duration}"/>
     <testCase name="StringRef/Comparisons are deep" duration="{duration}"/>
+    <testCase name="StringRef/from std::string" duration="{duration}"/>
     <testCase name="StringRef/from std::string/implicitly constructed" duration="{duration}"/>
     <testCase name="StringRef/from std::string/explicitly constructed" duration="{duration}"/>
     <testCase name="StringRef/from std::string/assigned" duration="{duration}"/>
+    <testCase name="StringRef/to std::string" duration="{duration}"/>
     <testCase name="StringRef/to std::string/explicitly constructed" duration="{duration}"/>
     <testCase name="StringRef/to std::string/assigned" duration="{duration}"/>
     <testCase name="StringRef/std::string += StringRef" duration="{duration}"/>
     <testCase name="StringRef/StringRef + StringRef" duration="{duration}"/>
+    <testCase name="StringRef at compilation time" duration="{duration}"/>
     <testCase name="StringRef at compilation time/Simple constructors" duration="{duration}"/>
     <testCase name="StringRef at compilation time/UDL construction" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp">
     <testCase name="Trim strings" duration="{duration}"/>
+    <testCase name="replaceInPlace" duration="{duration}"/>
     <testCase name="replaceInPlace/replace single char" duration="{duration}"/>
     <testCase name="replaceInPlace/replace two chars" duration="{duration}"/>
     <testCase name="replaceInPlace/replace first char" duration="{duration}"/>
     <testCase name="replaceInPlace/replace last char" duration="{duration}"/>
     <testCase name="replaceInPlace/replace all chars" duration="{duration}"/>
     <testCase name="replaceInPlace/replace no chars" duration="{duration}"/>
+    <testCase name="replaceInPlace/no replace in already-replaced string" duration="{duration}"/>
     <testCase name="replaceInPlace/no replace in already-replaced string/lengthening" duration="{duration}"/>
     <testCase name="replaceInPlace/no replace in already-replaced string/shortening" duration="{duration}"/>
     <testCase name="replaceInPlace/escape '" duration="{duration}"/>
@@ -269,6 +314,7 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="startsWith" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp">
+    <testCase name="Tag alias can be registered against tag patterns" duration="{duration}"/>
     <testCase name="Tag alias can be registered against tag patterns/The same tag alias can only be registered once" duration="{duration}"/>
     <testCase name="Tag alias can be registered against tag patterns/Tag aliases must be of the form [@name]" duration="{duration}"/>
     <testCase name="Tags with spaces and non-alphanumerical characters are accepted" duration="{duration}"/>
@@ -280,6 +326,7 @@ at AssertionHandler.tests.cpp:<line number>
   <file path="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp">
     <testCase name="Hashers with different seed produce different hash with same test case" duration="{duration}"/>
     <testCase name="Hashers with same seed produce same hash" duration="{duration}"/>
+    <testCase name="Hashing different test cases produces different result" duration="{duration}"/>
     <testCase name="Hashing different test cases produces different result/Different test name" duration="{duration}"/>
     <testCase name="Hashing different test cases produces different result/Different classname" duration="{duration}"/>
     <testCase name="Hashing different test cases produces different result/Different tags" duration="{duration}"/>
@@ -287,6 +334,7 @@ at AssertionHandler.tests.cpp:<line number>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp">
     <testCase name="#1905 -- test spec parser properly clears internal state between compound tests" duration="{duration}"/>
+    <testCase name="#1912 -- test spec parser handles escaping" duration="{duration}"/>
     <testCase name="#1912 -- test spec parser handles escaping/Various parentheses" duration="{duration}"/>
     <testCase name="#1912 -- test spec parser handles escaping/backslash in test name" duration="{duration}"/>
   </file>
@@ -300,16 +348,20 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="Stringifying char arrays with statically known sizes - char" duration="{duration}"/>
     <testCase name="Stringifying char arrays with statically known sizes - signed char" duration="{duration}"/>
     <testCase name="Stringifying char arrays with statically known sizes - unsigned char" duration="{duration}"/>
+    <testCase name="parseEnums" duration="{duration}"/>
     <testCase name="parseEnums/No enums" duration="{duration}"/>
     <testCase name="parseEnums/One enum value" duration="{duration}"/>
     <testCase name="parseEnums/Multiple enum values" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp">
+    <testCase name="Upcasting special member functions" duration="{duration}"/>
     <testCase name="Upcasting special member functions/Move constructor" duration="{duration}"/>
     <testCase name="Upcasting special member functions/move assignment" duration="{duration}"/>
+    <testCase name="make_unique reimplementation" duration="{duration}"/>
     <testCase name="make_unique reimplementation/From lvalue copies" duration="{duration}"/>
     <testCase name="make_unique reimplementation/From rvalue moves" duration="{duration}"/>
     <testCase name="make_unique reimplementation/Variadic constructor" duration="{duration}"/>
+    <testCase name="unique_ptr reimplementation: basic functionality" duration="{duration}"/>
     <testCase name="unique_ptr reimplementation: basic functionality/Default constructed unique_ptr is empty" duration="{duration}"/>
     <testCase name="unique_ptr reimplementation: basic functionality/Take ownership of allocation" duration="{duration}"/>
     <testCase name="unique_ptr reimplementation: basic functionality/Take ownership of allocation/Plain reset deallocates" duration="{duration}"/>
@@ -320,6 +372,7 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="unique_ptr reimplementation: basic functionality/free swap" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp">
+    <testCase name="XmlEncode" duration="{duration}"/>
     <testCase name="XmlEncode/normal string" duration="{duration}"/>
     <testCase name="XmlEncode/empty string" duration="{duration}"/>
     <testCase name="XmlEncode/string with ampersand" duration="{duration}"/>
@@ -349,14 +402,27 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="Use a custom approx" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/UsageTests/BDD.tests.cpp">
+    <testCase name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods" duration="{duration}"/>
     <testCase name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me" duration="{duration}"/>
+    <testCase name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me/When: We get the count" duration="{duration}"/>
     <testCase name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me/When: We get the count/Then: Subsequently values are higher" duration="{duration}"/>
+    <testCase name="Scenario: Do that thing with the thing" duration="{duration}"/>
+    <testCase name="Scenario: Do that thing with the thing/Given: This stuff exists" duration="{duration}"/>
+    <testCase name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption" duration="{duration}"/>
+    <testCase name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this" duration="{duration}"/>
     <testCase name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this/Then: it should do this" duration="{duration}"/>
     <testCase name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this/Then: it should do this/And: do that" duration="{duration}"/>
+    <testCase name="Scenario: This is a really long scenario name to see how the list command deals with wrapping" duration="{duration}"/>
+    <testCase name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width" duration="{duration}"/>
+    <testCase name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width/When: The test headers are printed as part of the normal running of the scenario" duration="{duration}"/>
     <testCase name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width/When: The test headers are printed as part of the normal running of the scenario/Then: The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent" duration="{duration}"/>
+    <testCase name="Scenario: Vector resizing affects size and capacity" duration="{duration}"/>
     <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector" duration="{duration}"/>
+    <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger" duration="{duration}"/>
     <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up" duration="{duration}"/>
+    <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up/And when: it is made smaller again" duration="{duration}"/>
     <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up/And when: it is made smaller again/Then: the size goes down but the capacity stays the same" duration="{duration}"/>
+    <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: we reserve more space" duration="{duration}"/>
     <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: we reserve more space/Then: The capacity is increased but the size remains the same" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/UsageTests/Class.tests.cpp">
@@ -520,6 +586,19 @@ at Class.tests.cpp:<line number>
       </failure>
     </testCase>
     <testCase name="A TEST_CASE_METHOD based test run that succeeds" duration="{duration}"/>
+    <testCase name="A TEST_CASE_PERSISTENT_FIXTURE based test run that fails/First partial run" duration="{duration}"/>
+    <testCase name="A TEST_CASE_PERSISTENT_FIXTURE based test run that fails/Second partial run" duration="{duration}">
+      <failure message="REQUIRE(m_a == 0)">
+FAILED:
+	REQUIRE( m_a == 0 )
+with expansion:
+	1 == 0
+at Class.tests.cpp:<line number>
+      </failure>
+    </testCase>
+    <testCase name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds" duration="{duration}"/>
+    <testCase name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds/First partial run" duration="{duration}"/>
+    <testCase name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds/Second partial run" duration="{duration}"/>
     <testCase name="Template test case method with test types specified inside std::tuple - MyTypes - 0" duration="{duration}"/>
     <testCase name="Template test case method with test types specified inside std::tuple - MyTypes - 1" duration="{duration}"/>
     <testCase name="Template test case method with test types specified inside std::tuple - MyTypes - 2" duration="{duration}"/>
@@ -529,6 +608,7 @@ at Class.tests.cpp:<line number>
     <testCase name="#1147" duration="{duration}"/>
     <testCase name="#1238" duration="{duration}"/>
     <testCase name="#1245" duration="{duration}"/>
+    <testCase name="#1319: Sections can have description (even if it is not saved" duration="{duration}"/>
     <testCase name="#1319: Sections can have description (even if it is not saved/SectionName" duration="{duration}"/>
     <testCase name="#1403" duration="{duration}"/>
     <testCase name="#1548" duration="{duration}"/>
@@ -622,35 +702,39 @@ at Condition.tests.cpp:<line number>
 FAILED:
 	CHECK( data.float_nine_point_one == Approx( 9.11f ) )
 with expansion:
-	9.1f == Approx( 9.1099996567 )
+	9.100000381f
+==
+Approx( 9.10999965667724609 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.float_nine_point_one == Approx( 9.0f ))">
 FAILED:
 	CHECK( data.float_nine_point_one == Approx( 9.0f ) )
 with expansion:
-	9.1f == Approx( 9.0 )
+	9.100000381f == Approx( 9.0 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.float_nine_point_one == Approx( 1 ))">
 FAILED:
 	CHECK( data.float_nine_point_one == Approx( 1 ) )
 with expansion:
-	9.1f == Approx( 1.0 )
+	9.100000381f == Approx( 1.0 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.float_nine_point_one == Approx( 0 ))">
 FAILED:
 	CHECK( data.float_nine_point_one == Approx( 0 ) )
 with expansion:
-	9.1f == Approx( 0.0 )
+	9.100000381f == Approx( 0.0 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.double_pi == Approx( 3.1415 ))">
 FAILED:
 	CHECK( data.double_pi == Approx( 3.1415 ) )
 with expansion:
-	3.1415926535 == Approx( 3.1415 )
+	3.14159265350000005
+==
+Approx( 3.14150000000000018 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.str_hello == &quot;goodbye&quot;)">
@@ -685,7 +769,9 @@ at Condition.tests.cpp:<line number>
 FAILED:
 	CHECK( x == Approx( 1.301 ) )
 with expansion:
-	1.3 == Approx( 1.301 )
+	1.30000000000000027
+==
+Approx( 1.30099999999999993 )
 at Condition.tests.cpp:<line number>
       </skipped>
     </testCase>
@@ -702,14 +788,18 @@ at Condition.tests.cpp:<line number>
 FAILED:
 	CHECK( data.float_nine_point_one != Approx( 9.1f ) )
 with expansion:
-	9.1f != Approx( 9.1000003815 )
+	9.100000381f
+!=
+Approx( 9.10000038146972656 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.double_pi != Approx( 3.1415926535 ))">
 FAILED:
 	CHECK( data.double_pi != Approx( 3.1415926535 ) )
 with expansion:
-	3.1415926535 != Approx( 3.1415926535 )
+	3.14159265350000005
+!=
+Approx( 3.14159265350000005 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.str_hello != &quot;hello&quot;)">
@@ -728,24 +818,28 @@ at Condition.tests.cpp:<line number>
       </skipped>
     </testCase>
     <testCase name="Inequality checks that should succeed" duration="{duration}"/>
+    <testCase name="Mayfail test case with nested sections/1" duration="{duration}"/>
     <testCase name="Mayfail test case with nested sections/1/A" duration="{duration}">
       <skipped message="FAIL()">
 FAILED:
 at Condition.tests.cpp:<line number>
       </skipped>
     </testCase>
+    <testCase name="Mayfail test case with nested sections/2" duration="{duration}"/>
     <testCase name="Mayfail test case with nested sections/2/A" duration="{duration}">
       <skipped message="FAIL()">
 FAILED:
 at Condition.tests.cpp:<line number>
       </skipped>
     </testCase>
+    <testCase name="Mayfail test case with nested sections/1" duration="{duration}"/>
     <testCase name="Mayfail test case with nested sections/1/B" duration="{duration}">
       <skipped message="FAIL()">
 FAILED:
 at Condition.tests.cpp:<line number>
       </skipped>
     </testCase>
+    <testCase name="Mayfail test case with nested sections/2" duration="{duration}"/>
     <testCase name="Mayfail test case with nested sections/2/B" duration="{duration}">
       <skipped message="FAIL()">
 FAILED:
@@ -813,21 +907,21 @@ at Condition.tests.cpp:<line number>
 FAILED:
 	CHECK( data.float_nine_point_one &lt; 9 )
 with expansion:
-	9.1f &lt; 9
+	9.100000381f &lt; 9
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="CHECK(data.float_nine_point_one > 10)">
 FAILED:
 	CHECK( data.float_nine_point_one > 10 )
 with expansion:
-	9.1f > 10
+	9.100000381f > 10
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="CHECK(data.float_nine_point_one > 9.2)">
 FAILED:
 	CHECK( data.float_nine_point_one > 9.2 )
 with expansion:
-	9.1f > 9.2
+	9.100000381f > 9.19999999999999929
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="CHECK(data.str_hello > &quot;hello&quot;)">
@@ -912,6 +1006,7 @@ at Decomposition.tests.cpp:<line number>
     <testCase name="toString(enum)" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/UsageTests/Exception.tests.cpp">
+    <testCase name="#748 - captures with unexpected exceptions" duration="{duration}"/>
     <testCase name="#748 - captures with unexpected exceptions/outside assertions" duration="{duration}">
       <skipped message="TEST_CASE()">
 FAILED:
@@ -961,6 +1056,7 @@ custom std exception
 at Exception.tests.cpp:<line number>
       </error>
     </testCase>
+    <testCase name="Exception messages can be tested for" duration="{duration}"/>
     <testCase name="Exception messages can be tested for/exact match" duration="{duration}"/>
     <testCase name="Exception messages can be tested for/different case" duration="{duration}"/>
     <testCase name="Exception messages can be tested for/wildcarded" duration="{duration}"/>
@@ -1009,7 +1105,7 @@ at Exception.tests.cpp:<line number>
     <testCase name="Unexpected exceptions can be translated" duration="{duration}">
       <error message="TEST_CASE()">
 FAILED:
-3.14
+3.14000000000000012
 at Exception.tests.cpp:<line number>
       </error>
     </testCase>
@@ -1052,6 +1148,7 @@ unexpected exception
 at Exception.tests.cpp:<line number>
       </error>
     </testCase>
+    <testCase name="When unchecked exceptions are thrown, but caught, they do not affect the test" duration="{duration}"/>
     <testCase name="thrown std::strings are translated" duration="{duration}">
       <error message="TEST_CASE()">
 FAILED:
@@ -1071,21 +1168,27 @@ at Generators.tests.cpp:<line number>
       </skipped>
     </testCase>
     <testCase name="3x3x3 ints" duration="{duration}"/>
+    <testCase name="Copy and then generate a range" duration="{duration}"/>
     <testCase name="Copy and then generate a range/from var and iterators" duration="{duration}"/>
     <testCase name="Copy and then generate a range/From a temporary container" duration="{duration}"/>
     <testCase name="Copy and then generate a range/Final validation" duration="{duration}"/>
     <testCase name="GENERATE can combine literals and generators" duration="{duration}"/>
+    <testCase name="Generators -- adapters" duration="{duration}"/>
+    <testCase name="Generators -- adapters/Filtering by predicate" duration="{duration}"/>
     <testCase name="Generators -- adapters/Filtering by predicate/Basic usage" duration="{duration}"/>
     <testCase name="Generators -- adapters/Filtering by predicate/Throws if there are no matching values" duration="{duration}"/>
     <testCase name="Generators -- adapters/Shortening a range" duration="{duration}"/>
+    <testCase name="Generators -- adapters/Transforming elements" duration="{duration}"/>
     <testCase name="Generators -- adapters/Transforming elements/Same type" duration="{duration}"/>
     <testCase name="Generators -- adapters/Transforming elements/Different type" duration="{duration}"/>
     <testCase name="Generators -- adapters/Transforming elements/Different deduced type" duration="{duration}"/>
     <testCase name="Generators -- adapters/Repeating a generator" duration="{duration}"/>
+    <testCase name="Generators -- adapters/Chunking a generator into sized pieces" duration="{duration}"/>
     <testCase name="Generators -- adapters/Chunking a generator into sized pieces/Number of elements in source is divisible by chunk size" duration="{duration}"/>
     <testCase name="Generators -- adapters/Chunking a generator into sized pieces/Number of elements in source is not divisible by chunk size" duration="{duration}"/>
     <testCase name="Generators -- adapters/Chunking a generator into sized pieces/Chunk size of zero" duration="{duration}"/>
     <testCase name="Generators -- adapters/Chunking a generator into sized pieces/Throws on too small generators" duration="{duration}"/>
+    <testCase name="Generators -- simple" duration="{duration}"/>
     <testCase name="Generators -- simple/one" duration="{duration}"/>
     <testCase name="Generators -- simple/two" duration="{duration}"/>
     <testCase name="Nested generators and captured variables" duration="{duration}"/>
@@ -1095,6 +1198,7 @@ at Generators.tests.cpp:<line number>
   <file path="tests/<exe-name>/UsageTests/Matchers.tests.cpp">
     <testCase name="#2152 - ULP checks between differently signed values were wrong - double" duration="{duration}"/>
     <testCase name="#2152 - ULP checks between differently signed values were wrong - float" duration="{duration}"/>
+    <testCase name="Arbitrary predicate matcher" duration="{duration}"/>
     <testCase name="Arbitrary predicate matcher/Function pointer" duration="{duration}"/>
     <testCase name="Arbitrary predicate matcher/Lambdas + different type" duration="{duration}"/>
     <testCase name="Combining MatchAllOfGeneric does not nest" duration="{duration}"/>
@@ -1104,8 +1208,10 @@ at Generators.tests.cpp:<line number>
     <testCase name="Combining only templated matchers" duration="{duration}"/>
     <testCase name="Combining templated and concrete matchers" duration="{duration}"/>
     <testCase name="Combining templated matchers" duration="{duration}"/>
+    <testCase name="Composed generic matchers shortcircuit" duration="{duration}"/>
     <testCase name="Composed generic matchers shortcircuit/MatchAllOf" duration="{duration}"/>
     <testCase name="Composed generic matchers shortcircuit/MatchAnyOf" duration="{duration}"/>
+    <testCase name="Composed matchers shortcircuit" duration="{duration}"/>
     <testCase name="Composed matchers shortcircuit/MatchAllOf" duration="{duration}"/>
     <testCase name="Composed matchers shortcircuit/MatchAnyOf" duration="{duration}"/>
     <testCase name="Contains string matcher" duration="{duration}">
@@ -1202,6 +1308,7 @@ at Matchers.tests.cpp:<line number>
     <testCase name="Exception matchers that succeed" duration="{duration}"/>
     <testCase name="Exception message can be matched" duration="{duration}"/>
     <testCase name="Exceptions matchers" duration="{duration}"/>
+    <testCase name="Floating point matchers: double" duration="{duration}"/>
     <testCase name="Floating point matchers: double/Relative" duration="{duration}"/>
     <testCase name="Floating point matchers: double/Relative/Some subnormal values" duration="{duration}"/>
     <testCase name="Floating point matchers: double/Margin" duration="{duration}"/>
@@ -1209,6 +1316,7 @@ at Matchers.tests.cpp:<line number>
     <testCase name="Floating point matchers: double/Composed" duration="{duration}"/>
     <testCase name="Floating point matchers: double/Constructor validation" duration="{duration}"/>
     <testCase name="Floating point matchers: double/IsNaN" duration="{duration}"/>
+    <testCase name="Floating point matchers: float" duration="{duration}"/>
     <testCase name="Floating point matchers: float/Relative" duration="{duration}"/>
     <testCase name="Floating point matchers: float/Relative/Some subnormal values" duration="{duration}"/>
     <testCase name="Floating point matchers: float/Margin" duration="{duration}"/>
@@ -1281,10 +1389,13 @@ at Matchers.tests.cpp:<line number>
       </failure>
     </testCase>
     <testCase name="String matchers" duration="{duration}"/>
+    <testCase name="Vector Approx matcher" duration="{duration}"/>
     <testCase name="Vector Approx matcher/Empty vector is roughly equal to an empty vector" duration="{duration}"/>
+    <testCase name="Vector Approx matcher/Vectors with elements" duration="{duration}"/>
     <testCase name="Vector Approx matcher/Vectors with elements/A vector is approx equal to itself" duration="{duration}"/>
     <testCase name="Vector Approx matcher/Vectors with elements/Different length" duration="{duration}"/>
     <testCase name="Vector Approx matcher/Vectors with elements/Same length, different elements" duration="{duration}"/>
+    <testCase name="Vector Approx matcher -- failing" duration="{duration}"/>
     <testCase name="Vector Approx matcher -- failing/Empty and non empty vectors are not approx equal" duration="{duration}">
       <failure message="CHECK_THAT(empty, Approx( t1 ))">
 FAILED:
@@ -1303,11 +1414,13 @@ with expansion:
 at Matchers.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="Vector matchers" duration="{duration}"/>
     <testCase name="Vector matchers/Contains (element)" duration="{duration}"/>
     <testCase name="Vector matchers/Contains (vector)" duration="{duration}"/>
     <testCase name="Vector matchers/Contains (element), composed" duration="{duration}"/>
     <testCase name="Vector matchers/Equals" duration="{duration}"/>
     <testCase name="Vector matchers/UnorderedEquals" duration="{duration}"/>
+    <testCase name="Vector matchers that fail" duration="{duration}"/>
     <testCase name="Vector matchers that fail/Contains (element)" duration="{duration}">
       <failure message="CHECK_THAT(v, VectorContains( -1 ))">
 FAILED:
@@ -1402,82 +1515,114 @@ at Matchers.tests.cpp:<line number>
     </testCase>
   </file>
   <file path="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp">
+    <testCase name="Basic use of the Contains range matcher" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Different argument ranges, same element type, default comparison" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Different argument ranges, same element type, custom comparison" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Different element type, custom comparisons" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Can handle type that requires ADL-found free function begin and end" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Initialization with move only types" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Matching using matcher" duration="{duration}"/>
+    <testCase name="Basic use of the Empty range matcher" duration="{duration}"/>
     <testCase name="Basic use of the Empty range matcher/Simple, std-provided containers" duration="{duration}"/>
     <testCase name="Basic use of the Empty range matcher/Type with empty" duration="{duration}"/>
     <testCase name="Basic use of the Empty range matcher/Type requires ADL found empty free function" duration="{duration}"/>
+    <testCase name="Type conversions of RangeEquals and similar" duration="{duration}"/>
+    <testCase name="Type conversions of RangeEquals and similar/Container conversions" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" duration="{duration}"/>
+    <testCase name="Type conversions of RangeEquals and similar/Value type" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" duration="{duration}"/>
+    <testCase name="Type conversions of RangeEquals and similar/Custom predicate" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
+    <testCase name="Usage of AllMatch range matcher" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
+    <testCase name="Usage of AllMatch range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Basic usage/One false evaluates to false" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evaluates to false" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of AnyMatch range matcher" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
+    <testCase name="Usage of AnyMatch range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Basic usage/One true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of NoneMatch range matcher" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
+    <testCase name="Usage of NoneMatch range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Basic usage/One true evaluates to false" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evaluates to false" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of RangeEquals range matcher" duration="{duration}"/>
+    <testCase name="Usage of RangeEquals range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" duration="{duration}"/>
+    <testCase name="Usage of RangeEquals range matcher/Custom predicate" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
+    <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" duration="{duration}"/>
+    <testCase name="Usage of UnorderedRangeEquals range matcher" duration="{duration}"/>
+    <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" duration="{duration}"/>
+    <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
+    <testCase name="Usage of the SizeIs range matcher" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Some with stdlib containers" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Type requires ADL found size free function" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Type has size member" duration="{duration}"/>
@@ -1576,6 +1721,8 @@ at Message.tests.cpp:<line number>
     </testCase>
     <testCase name="SUCCEED counts as a test pass" duration="{duration}"/>
     <testCase name="SUCCEED does not require an argument" duration="{duration}"/>
+    <testCase name="Standard output from all sections is reported" duration="{duration}"/>
+    <testCase name="Standard output from all sections is reported/one" duration="{duration}"/>
     <testCase name="Standard output from all sections is reported/two" duration="{duration}"/>
     <testCase name="The NO_FAIL macro reports a failure but does not fail the test" duration="{duration}"/>
     <testCase name="just failure" duration="{duration}">
@@ -1592,6 +1739,8 @@ previous unscoped info SHOULD not be seen
 at Message.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="just info" duration="{duration}"/>
+    <testCase name="just unscoped info" duration="{duration}"/>
     <testCase name="mix info, unscoped info and warning" duration="{duration}"/>
     <testCase name="not prints unscoped info from previous failures" duration="{duration}">
       <failure message="REQUIRE(false)">
@@ -1664,6 +1813,7 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </skipped>
     </testCase>
+    <testCase name="#961 -- Dynamically created sections should all be reported" duration="{duration}"/>
     <testCase name="#961 -- Dynamically created sections should all be reported/Looped section 0" duration="{duration}"/>
     <testCase name="#961 -- Dynamically created sections should all be reported/Looped section 1" duration="{duration}"/>
     <testCase name="#961 -- Dynamically created sections should all be reported/Looped section 2" duration="{duration}"/>
@@ -1684,7 +1834,9 @@ to infinity and beyond
 at Misc.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="A couple of nested sections followed by a failure/Outer" duration="{duration}"/>
     <testCase name="A couple of nested sections followed by a failure/Outer/Inner" duration="{duration}"/>
+    <testCase name="An empty test with no assertions" duration="{duration}"/>
     <testCase name="Factorials are computed" duration="{duration}"/>
     <testCase name="ManuallyRegistered" duration="{duration}"/>
     <testCase name="Nice descriptive name" duration="{duration}"/>
@@ -1813,10 +1965,14 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="even more nested SECTION tests" duration="{duration}"/>
+    <testCase name="even more nested SECTION tests/c" duration="{duration}"/>
     <testCase name="even more nested SECTION tests/c/d (leaf)" duration="{duration}"/>
     <testCase name="even more nested SECTION tests/c/e (leaf)" duration="{duration}"/>
     <testCase name="even more nested SECTION tests/f (leaf)" duration="{duration}"/>
+    <testCase name="first tag" duration="{duration}"/>
     <testCase name="long long" duration="{duration}"/>
+    <testCase name="looped SECTION tests" duration="{duration}"/>
     <testCase name="looped SECTION tests/b is currently: 0" duration="{duration}">
       <failure message="CHECK(b > a)">
 FAILED:
@@ -1893,6 +2049,8 @@ Testing if fib[7] (21) is even
 at Misc.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="more nested SECTION tests" duration="{duration}"/>
+    <testCase name="more nested SECTION tests/equal" duration="{duration}"/>
     <testCase name="more nested SECTION tests/equal/doesn't equal" duration="{duration}">
       <failure message="REQUIRE(a == b)">
 FAILED:
@@ -1902,14 +2060,18 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="more nested SECTION tests/doesn't equal" duration="{duration}"/>
     <testCase name="more nested SECTION tests/doesn't equal/not equal" duration="{duration}"/>
     <testCase name="more nested SECTION tests/doesn't equal/less than" duration="{duration}"/>
+    <testCase name="nested SECTION tests" duration="{duration}"/>
     <testCase name="nested SECTION tests/doesn't equal" duration="{duration}"/>
     <testCase name="nested SECTION tests/doesn't equal/not equal" duration="{duration}"/>
     <testCase name="not allowed" duration="{duration}"/>
     <testCase name="null strings" duration="{duration}"/>
+    <testCase name="random SECTION tests" duration="{duration}"/>
     <testCase name="random SECTION tests/doesn't equal" duration="{duration}"/>
     <testCase name="random SECTION tests/not equal" duration="{duration}"/>
+    <testCase name="second tag" duration="{duration}"/>
     <testCase name="send a single char to INFO" duration="{duration}">
       <failure message="REQUIRE(false)">
 FAILED:
@@ -1928,6 +2090,7 @@ at Misc.tests.cpp:<line number>
     <testCase name="vectors can be sized and resized/resizing smaller changes size but not capacity/We can use the 'swap trick' to reset the capacity" duration="{duration}"/>
     <testCase name="vectors can be sized and resized/reserving bigger changes capacity but not size" duration="{duration}"/>
     <testCase name="vectors can be sized and resized/reserving smaller does not change size or capacity" duration="{duration}"/>
+    <testCase name="xmlentitycheck" duration="{duration}"/>
     <testCase name="xmlentitycheck/embedded xml: &lt;test>it should be possible to embed xml characters, such as &lt;, &quot; or &amp;, or even whole &lt;xml>documents&lt;/xml> within an attribute&lt;/test>" duration="{duration}"/>
     <testCase name="xmlentitycheck/encoded chars: these should all be encoded: &amp;&amp;&amp;&quot;&quot;&quot;&lt;&lt;&lt;&amp;&quot;&lt;&lt;&amp;&quot;" duration="{duration}"/>
   </file>
@@ -1998,6 +2161,9 @@ FAILED:
 at Skip.tests.cpp:<line number>
       </skipped>
     </testCase>
+    <testCase name="nested sections can be skipped dynamically at runtime/A" duration="{duration}"/>
+    <testCase name="nested sections can be skipped dynamically at runtime/B2" duration="{duration}"/>
+    <testCase name="nested sections can be skipped dynamically at runtime/B2/B1" duration="{duration}"/>
     <testCase name="nested sections can be skipped dynamically at runtime/B2/B" duration="{duration}">
       <skipped message="SKIP()">
 SKIPPED
@@ -2005,6 +2171,7 @@ at Skip.tests.cpp:<line number>
       </skipped>
     </testCase>
     <testCase name="nested sections can be skipped dynamically at runtime/B" duration="{duration}"/>
+    <testCase name="sections can be skipped dynamically at runtime" duration="{duration}"/>
     <testCase name="sections can be skipped dynamically at runtime/not skipped" duration="{duration}"/>
     <testCase name="sections can be skipped dynamically at runtime/skipped" duration="{duration}">
       <skipped message="SKIP()">
@@ -2033,20 +2200,26 @@ at Skip.tests.cpp:<line number>
     <testCase name="Stringifying std::chrono::time_point&lt;system_clock>" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp">
+    <testCase name="Capture and info messages" duration="{duration}"/>
     <testCase name="Capture and info messages/Capture should stringify like assertions" duration="{duration}"/>
     <testCase name="Capture and info messages/Info should NOT stringify the way assertions do" duration="{duration}"/>
+    <testCase name="Character pretty printing" duration="{duration}"/>
     <testCase name="Character pretty printing/Specifically escaped" duration="{duration}"/>
     <testCase name="Character pretty printing/General chars" duration="{duration}"/>
     <testCase name="Character pretty printing/Low ASCII" duration="{duration}"/>
     <testCase name="Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified" duration="{duration}"/>
+    <testCase name="Precision of floating point stringification can be set" duration="{duration}"/>
     <testCase name="Precision of floating point stringification can be set/Floats" duration="{duration}"/>
     <testCase name="Precision of floating point stringification can be set/Double" duration="{duration}"/>
+    <testCase name="Static arrays are convertible to string" duration="{duration}"/>
     <testCase name="Static arrays are convertible to string/Single item" duration="{duration}"/>
     <testCase name="Static arrays are convertible to string/Multiple" duration="{duration}"/>
     <testCase name="Static arrays are convertible to string/Non-trivial inner items" duration="{duration}"/>
+    <testCase name="std::map is convertible string" duration="{duration}"/>
     <testCase name="std::map is convertible string/empty" duration="{duration}"/>
     <testCase name="std::map is convertible string/single item" duration="{duration}"/>
     <testCase name="std::map is convertible string/several items" duration="{duration}"/>
+    <testCase name="std::set is convertible string" duration="{duration}"/>
     <testCase name="std::set is convertible string/empty" duration="{duration}"/>
     <testCase name="std::set is convertible string/single item" duration="{duration}"/>
     <testCase name="std::set is convertible string/several items" duration="{duration}"/>
@@ -2091,6 +2264,7 @@ FAILED:
 at Tricky.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="(unimplemented) static bools can be evaluated" duration="{duration}"/>
     <testCase name="(unimplemented) static bools can be evaluated/compare to true" duration="{duration}"/>
     <testCase name="(unimplemented) static bools can be evaluated/compare to false" duration="{duration}"/>
     <testCase name="(unimplemented) static bools can be evaluated/negation" duration="{duration}"/>
@@ -2126,6 +2300,7 @@ at Tricky.tests.cpp:<line number>
     <testCase name="X/level/1/a" duration="{duration}"/>
     <testCase name="X/level/1/b" duration="{duration}"/>
     <testCase name="boolean member" duration="{duration}"/>
+    <testCase name="has printf" duration="{duration}"/>
     <testCase name="non streamable - with conv. op" duration="{duration}"/>
     <testCase name="non-copyable objects" duration="{duration}"/>
     <testCase name="null_ptr" duration="{duration}"/>
@@ -2134,6 +2309,7 @@ at Tricky.tests.cpp:<line number>
   <file path="tests/<exe-name>/UsageTests/VariadicMacros.tests.cpp">
     <testCase name="Anonymous test case 1" duration="{duration}"/>
     <testCase name="Test case with one argument" duration="{duration}"/>
+    <testCase name="Variadic macros" duration="{duration}"/>
     <testCase name="Variadic macros/Section with one argument" duration="{duration}"/>
   </file>
 </testExecutions>

tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt

@@ -12,52 +12,68 @@ at AssertionHandler.tests.cpp:<line number>
     </testCase>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp">
+    <testCase name="Clara::Arg does not crash on incomplete input" duration="{duration}"/>
     <testCase name="Clara::Arg supports single-arg parse the way Opt does" duration="{duration}"/>
+    <testCase name="Clara::Opt supports accept-many lambdas" duration="{duration}"/>
     <testCase name="Clara::Opt supports accept-many lambdas/Parsing fails on multiple options without accept_many" duration="{duration}"/>
     <testCase name="Clara::Opt supports accept-many lambdas/Parsing succeeds on multiple options with accept_many" duration="{duration}"/>
     <testCase name="is_unary_function" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp">
+    <testCase name="Parsing sharding-related cli flags" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/shard-count" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/Negative shard count reports error" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/Zero shard count reports error" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/shard-index" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/Negative shard index reports error" duration="{duration}"/>
     <testCase name="Parsing sharding-related cli flags/Shard index 0 is accepted" duration="{duration}"/>
+    <testCase name="Parsing warnings" duration="{duration}"/>
     <testCase name="Parsing warnings/NoAssertions" duration="{duration}"/>
     <testCase name="Parsing warnings/NoTests is no longer supported" duration="{duration}"/>
     <testCase name="Parsing warnings/Combining multiple warnings" duration="{duration}"/>
+    <testCase name="Process can be configured on command line" duration="{duration}"/>
     <testCase name="Process can be configured on command line/empty args don't cause a crash" duration="{duration}"/>
     <testCase name="Process can be configured on command line/default - no arguments" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/test lists" duration="{duration}"/>
     <testCase name="Process can be configured on command line/test lists/Specify one test case using" duration="{duration}"/>
     <testCase name="Process can be configured on command line/test lists/Specify one test case exclusion using exclude:" duration="{duration}"/>
     <testCase name="Process can be configured on command line/test lists/Specify one test case exclusion using ~" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/reporter" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/-r/console" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/-r/xml" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/--reporter/junit" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/must match one of the available ones" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/With output file" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/With Windows-like absolute path as output file" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/reporter/Multiple reporters" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/Multiple reporters/All with output files" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/Multiple reporters/Mixed output files and default output" duration="{duration}"/>
     <testCase name="Process can be configured on command line/reporter/Multiple reporters/cannot have multiple reporters with default output" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/debugger" duration="{duration}"/>
     <testCase name="Process can be configured on command line/debugger/-b" duration="{duration}"/>
     <testCase name="Process can be configured on command line/debugger/--break" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/abort" duration="{duration}"/>
     <testCase name="Process can be configured on command line/abort/-a aborts after first failure" duration="{duration}"/>
     <testCase name="Process can be configured on command line/abort/-x 2 aborts after two failures" duration="{duration}"/>
     <testCase name="Process can be configured on command line/abort/-x must be numeric" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/abort/wait-for-keypress" duration="{duration}"/>
     <testCase name="Process can be configured on command line/abort/wait-for-keypress/Accepted options" duration="{duration}"/>
     <testCase name="Process can be configured on command line/abort/wait-for-keypress/invalid options are reported" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/nothrow" duration="{duration}"/>
     <testCase name="Process can be configured on command line/nothrow/-e" duration="{duration}"/>
     <testCase name="Process can be configured on command line/nothrow/--nothrow" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/output filename" duration="{duration}"/>
     <testCase name="Process can be configured on command line/output filename/-o filename" duration="{duration}"/>
     <testCase name="Process can be configured on command line/output filename/--out" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/combinations" duration="{duration}"/>
     <testCase name="Process can be configured on command line/combinations/Single character flags can be combined" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/use-colour" duration="{duration}"/>
     <testCase name="Process can be configured on command line/use-colour/without option" duration="{duration}"/>
     <testCase name="Process can be configured on command line/use-colour/auto" duration="{duration}"/>
     <testCase name="Process can be configured on command line/use-colour/yes" duration="{duration}"/>
     <testCase name="Process can be configured on command line/use-colour/no" duration="{duration}"/>
     <testCase name="Process can be configured on command line/use-colour/error" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/Benchmark options" duration="{duration}"/>
     <testCase name="Process can be configured on command line/Benchmark options/samples" duration="{duration}"/>
     <testCase name="Process can be configured on command line/Benchmark options/resamples" duration="{duration}"/>
     <testCase name="Process can be configured on command line/Benchmark options/confidence-interval" duration="{duration}"/>
@@ -66,13 +82,16 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="Test with special, characters &quot;in name" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp">
+    <testCase name="ColourGuard behaviour" duration="{duration}"/>
     <testCase name="ColourGuard behaviour/ColourGuard is disengaged by default" duration="{duration}"/>
     <testCase name="ColourGuard behaviour/ColourGuard is engaged by op&lt;&lt;" duration="{duration}"/>
     <testCase name="ColourGuard behaviour/ColourGuard can be engaged explicitly" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp">
+    <testCase name="CaseInsensitiveEqualsTo is case insensitive" duration="{duration}"/>
     <testCase name="CaseInsensitiveEqualsTo is case insensitive/Degenerate cases" duration="{duration}"/>
     <testCase name="CaseInsensitiveEqualsTo is case insensitive/Plain comparisons" duration="{duration}"/>
+    <testCase name="CaseInsensitiveLess is case insensitive" duration="{duration}"/>
     <testCase name="CaseInsensitiveLess is case insensitive/Degenerate cases" duration="{duration}"/>
     <testCase name="CaseInsensitiveLess is case insensitive/Plain comparisons" duration="{duration}"/>
   </file>
@@ -81,35 +100,49 @@ at AssertionHandler.tests.cpp:<line number>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp">
     <testCase name="Filter generator throws exception for empty generator" duration="{duration}"/>
+    <testCase name="Generators internals" duration="{duration}"/>
     <testCase name="Generators internals/Single value" duration="{duration}"/>
     <testCase name="Generators internals/Preset values" duration="{duration}"/>
     <testCase name="Generators internals/Generator combinator" duration="{duration}"/>
     <testCase name="Generators internals/Explicitly typed generator sequence" duration="{duration}"/>
+    <testCase name="Generators internals/Filter generator" duration="{duration}"/>
     <testCase name="Generators internals/Filter generator/Simple filtering" duration="{duration}"/>
     <testCase name="Generators internals/Filter generator/Filter out multiple elements at the start and end" duration="{duration}"/>
     <testCase name="Generators internals/Filter generator/Throws on construction if it can't get initial element" duration="{duration}"/>
+    <testCase name="Generators internals/Take generator" duration="{duration}"/>
     <testCase name="Generators internals/Take generator/Take less" duration="{duration}"/>
     <testCase name="Generators internals/Take generator/Take more" duration="{duration}"/>
     <testCase name="Generators internals/Map with explicit return type" duration="{duration}"/>
     <testCase name="Generators internals/Map with deduced return type" duration="{duration}"/>
+    <testCase name="Generators internals/Repeat" duration="{duration}"/>
     <testCase name="Generators internals/Repeat/Singular repeat" duration="{duration}"/>
     <testCase name="Generators internals/Repeat/Actual repeat" duration="{duration}"/>
+    <testCase name="Generators internals/Range" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Positive auto step" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive auto step/Integer" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Negative auto step" duration="{duration}"/>
     <testCase name="Generators internals/Range/Negative auto step/Integer" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Positive manual step" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Positive manual step/Integer" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Integer/Exact" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Integer/Slightly over end" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Integer/Slightly under end" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Positive manual step/Floating Point" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Floating Point/Exact" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Floating Point/Slightly over end" duration="{duration}"/>
     <testCase name="Generators internals/Range/Positive manual step/Floating Point/Slightly under end" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Negative manual step" duration="{duration}"/>
+    <testCase name="Generators internals/Range/Negative manual step/Integer" duration="{duration}"/>
     <testCase name="Generators internals/Range/Negative manual step/Integer/Exact" duration="{duration}"/>
     <testCase name="Generators internals/Range/Negative manual step/Integer/Slightly over end" duration="{duration}"/>
     <testCase name="Generators internals/Range/Negative manual step/Integer/Slightly under end" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp">
     <testCase name="analyse no analysis" duration="{duration}"/>
+    <testCase name="benchmark function call" duration="{duration}"/>
     <testCase name="benchmark function call/without chronometer" duration="{duration}"/>
     <testCase name="benchmark function call/with chronometer" duration="{duration}"/>
+    <testCase name="classify_outliers" duration="{duration}"/>
     <testCase name="classify_outliers/none" duration="{duration}"/>
     <testCase name="classify_outliers/low severe" duration="{duration}"/>
     <testCase name="classify_outliers/low mild" duration="{duration}"/>
@@ -120,7 +153,6 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="estimate_clock_resolution" duration="{duration}"/>
     <testCase name="mean" duration="{duration}"/>
     <testCase name="measure" duration="{duration}"/>
-    <testCase name="normal_cdf" duration="{duration}"/>
     <testCase name="normal_quantile" duration="{duration}"/>
     <testCase name="resolution" duration="{duration}"/>
     <testCase name="run_for_at_least, chronometer" duration="{duration}"/>
@@ -130,6 +162,7 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="weighted_average_quantile" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Json.tests.cpp">
+    <testCase name="JsonWriter" duration="{duration}"/>
     <testCase name="JsonWriter/Newly constructed JsonWriter does nothing" duration="{duration}"/>
     <testCase name="JsonWriter/Calling writeObject will create an empty pair of braces" duration="{duration}"/>
     <testCase name="JsonWriter/Calling writeObject with key will create an object to write the value" duration="{duration}"/>
@@ -139,6 +172,7 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="JsonWriter/Moved from JsonObjectWriter shall not insert superfluous brace" duration="{duration}"/>
     <testCase name="JsonWriter/Moved from JsonArrayWriter shall not insert superfluous bracket" duration="{duration}"/>
     <testCase name="JsonWriter/Custom class shall be quoted" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly" duration="{duration}"/>
     <testCase name="JsonWriter escapes charaters in strings properly/Quote in a string is escaped" duration="{duration}"/>
     <testCase name="JsonWriter escapes charaters in strings properly/Backslash in a string is escaped" duration="{duration}"/>
     <testCase name="JsonWriter escapes charaters in strings properly/Forward slash in a string is **not** escaped" duration="{duration}"/>
@@ -150,10 +184,12 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="JsonWriter escapes charaters in strings properly/combination of characters is escaped" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp">
+    <testCase name="Parse uints" duration="{duration}"/>
     <testCase name="Parse uints/proper inputs" duration="{duration}"/>
     <testCase name="Parse uints/Bad inputs" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp">
+    <testCase name="#1938 - GENERATE after a section" duration="{duration}"/>
     <testCase name="#1938 - GENERATE after a section/A" duration="{duration}"/>
     <testCase name="#1938 - GENERATE after a section/B" duration="{duration}"/>
     <testCase name="#1938 - Section followed by flat generate" duration="{duration}"/>
@@ -176,6 +212,7 @@ at AssertionHandler.tests.cpp:<line number>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp">
     <testCase name="Comparison ops" duration="{duration}"/>
+    <testCase name="Our PCG implementation provides expected results for known seeds" duration="{duration}"/>
     <testCase name="Our PCG implementation provides expected results for known seeds/Default seeded" duration="{duration}"/>
     <testCase name="Our PCG implementation provides expected results for known seeds/Specific seed" duration="{duration}"/>
     <testCase name="Random seed generation accepts known methods" duration="{duration}"/>
@@ -217,6 +254,7 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="Reporter's write listings to provided stream/XML reporter lists reporters" duration="{duration}"/>
     <testCase name="Reporter's write listings to provided stream/XML reporter lists tests" duration="{duration}"/>
     <testCase name="Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla" duration="{duration}"/>
+    <testCase name="The default listing implementation write to provided stream" duration="{duration}"/>
     <testCase name="The default listing implementation write to provided stream/Listing tags" duration="{duration}"/>
     <testCase name="The default listing implementation write to provided stream/Listing reporters" duration="{duration}"/>
     <testCase name="The default listing implementation write to provided stream/Listing tests" duration="{duration}"/>
@@ -230,11 +268,13 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="stdout and stderr streams have %-starting name" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/String.tests.cpp">
+    <testCase name="StringRef" duration="{duration}"/>
     <testCase name="StringRef/Empty string" duration="{duration}"/>
     <testCase name="StringRef/From string literal" duration="{duration}"/>
     <testCase name="StringRef/From sub-string" duration="{duration}"/>
     <testCase name="StringRef/Copy construction is shallow" duration="{duration}"/>
     <testCase name="StringRef/Copy assignment is shallow" duration="{duration}"/>
+    <testCase name="StringRef/Substrings" duration="{duration}"/>
     <testCase name="StringRef/Substrings/zero-based substring" duration="{duration}"/>
     <testCase name="StringRef/Substrings/non-zero-based substring" duration="{duration}"/>
     <testCase name="StringRef/Substrings/Pointer values of full refs should match" duration="{duration}"/>
@@ -243,24 +283,29 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="StringRef/Substrings/Substring off the end are trimmed" duration="{duration}"/>
     <testCase name="StringRef/Substrings/substring start after the end is empty" duration="{duration}"/>
     <testCase name="StringRef/Comparisons are deep" duration="{duration}"/>
+    <testCase name="StringRef/from std::string" duration="{duration}"/>
     <testCase name="StringRef/from std::string/implicitly constructed" duration="{duration}"/>
     <testCase name="StringRef/from std::string/explicitly constructed" duration="{duration}"/>
     <testCase name="StringRef/from std::string/assigned" duration="{duration}"/>
+    <testCase name="StringRef/to std::string" duration="{duration}"/>
     <testCase name="StringRef/to std::string/explicitly constructed" duration="{duration}"/>
     <testCase name="StringRef/to std::string/assigned" duration="{duration}"/>
     <testCase name="StringRef/std::string += StringRef" duration="{duration}"/>
     <testCase name="StringRef/StringRef + StringRef" duration="{duration}"/>
+    <testCase name="StringRef at compilation time" duration="{duration}"/>
     <testCase name="StringRef at compilation time/Simple constructors" duration="{duration}"/>
     <testCase name="StringRef at compilation time/UDL construction" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp">
     <testCase name="Trim strings" duration="{duration}"/>
+    <testCase name="replaceInPlace" duration="{duration}"/>
     <testCase name="replaceInPlace/replace single char" duration="{duration}"/>
     <testCase name="replaceInPlace/replace two chars" duration="{duration}"/>
     <testCase name="replaceInPlace/replace first char" duration="{duration}"/>
     <testCase name="replaceInPlace/replace last char" duration="{duration}"/>
     <testCase name="replaceInPlace/replace all chars" duration="{duration}"/>
     <testCase name="replaceInPlace/replace no chars" duration="{duration}"/>
+    <testCase name="replaceInPlace/no replace in already-replaced string" duration="{duration}"/>
     <testCase name="replaceInPlace/no replace in already-replaced string/lengthening" duration="{duration}"/>
     <testCase name="replaceInPlace/no replace in already-replaced string/shortening" duration="{duration}"/>
     <testCase name="replaceInPlace/escape '" duration="{duration}"/>
@@ -268,6 +313,7 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="startsWith" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp">
+    <testCase name="Tag alias can be registered against tag patterns" duration="{duration}"/>
     <testCase name="Tag alias can be registered against tag patterns/The same tag alias can only be registered once" duration="{duration}"/>
     <testCase name="Tag alias can be registered against tag patterns/Tag aliases must be of the form [@name]" duration="{duration}"/>
     <testCase name="Tags with spaces and non-alphanumerical characters are accepted" duration="{duration}"/>
@@ -279,6 +325,7 @@ at AssertionHandler.tests.cpp:<line number>
   <file path="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp">
     <testCase name="Hashers with different seed produce different hash with same test case" duration="{duration}"/>
     <testCase name="Hashers with same seed produce same hash" duration="{duration}"/>
+    <testCase name="Hashing different test cases produces different result" duration="{duration}"/>
     <testCase name="Hashing different test cases produces different result/Different test name" duration="{duration}"/>
     <testCase name="Hashing different test cases produces different result/Different classname" duration="{duration}"/>
     <testCase name="Hashing different test cases produces different result/Different tags" duration="{duration}"/>
@@ -286,6 +333,7 @@ at AssertionHandler.tests.cpp:<line number>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp">
     <testCase name="#1905 -- test spec parser properly clears internal state between compound tests" duration="{duration}"/>
+    <testCase name="#1912 -- test spec parser handles escaping" duration="{duration}"/>
     <testCase name="#1912 -- test spec parser handles escaping/Various parentheses" duration="{duration}"/>
     <testCase name="#1912 -- test spec parser handles escaping/backslash in test name" duration="{duration}"/>
   </file>
@@ -299,16 +347,20 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="Stringifying char arrays with statically known sizes - char" duration="{duration}"/>
     <testCase name="Stringifying char arrays with statically known sizes - signed char" duration="{duration}"/>
     <testCase name="Stringifying char arrays with statically known sizes - unsigned char" duration="{duration}"/>
+    <testCase name="parseEnums" duration="{duration}"/>
     <testCase name="parseEnums/No enums" duration="{duration}"/>
     <testCase name="parseEnums/One enum value" duration="{duration}"/>
     <testCase name="parseEnums/Multiple enum values" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp">
+    <testCase name="Upcasting special member functions" duration="{duration}"/>
     <testCase name="Upcasting special member functions/Move constructor" duration="{duration}"/>
     <testCase name="Upcasting special member functions/move assignment" duration="{duration}"/>
+    <testCase name="make_unique reimplementation" duration="{duration}"/>
     <testCase name="make_unique reimplementation/From lvalue copies" duration="{duration}"/>
     <testCase name="make_unique reimplementation/From rvalue moves" duration="{duration}"/>
     <testCase name="make_unique reimplementation/Variadic constructor" duration="{duration}"/>
+    <testCase name="unique_ptr reimplementation: basic functionality" duration="{duration}"/>
     <testCase name="unique_ptr reimplementation: basic functionality/Default constructed unique_ptr is empty" duration="{duration}"/>
     <testCase name="unique_ptr reimplementation: basic functionality/Take ownership of allocation" duration="{duration}"/>
     <testCase name="unique_ptr reimplementation: basic functionality/Take ownership of allocation/Plain reset deallocates" duration="{duration}"/>
@@ -319,6 +371,7 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="unique_ptr reimplementation: basic functionality/free swap" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp">
+    <testCase name="XmlEncode" duration="{duration}"/>
     <testCase name="XmlEncode/normal string" duration="{duration}"/>
     <testCase name="XmlEncode/empty string" duration="{duration}"/>
     <testCase name="XmlEncode/string with ampersand" duration="{duration}"/>
@@ -348,14 +401,27 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="Use a custom approx" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/UsageTests/BDD.tests.cpp">
+    <testCase name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods" duration="{duration}"/>
     <testCase name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me" duration="{duration}"/>
+    <testCase name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me/When: We get the count" duration="{duration}"/>
     <testCase name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods/Given: No operations precede me/When: We get the count/Then: Subsequently values are higher" duration="{duration}"/>
+    <testCase name="Scenario: Do that thing with the thing" duration="{duration}"/>
+    <testCase name="Scenario: Do that thing with the thing/Given: This stuff exists" duration="{duration}"/>
+    <testCase name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption" duration="{duration}"/>
+    <testCase name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this" duration="{duration}"/>
     <testCase name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this/Then: it should do this" duration="{duration}"/>
     <testCase name="Scenario: Do that thing with the thing/Given: This stuff exists/And given: And some assumption/When: I do this/Then: it should do this/And: do that" duration="{duration}"/>
+    <testCase name="Scenario: This is a really long scenario name to see how the list command deals with wrapping" duration="{duration}"/>
+    <testCase name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width" duration="{duration}"/>
+    <testCase name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width/When: The test headers are printed as part of the normal running of the scenario" duration="{duration}"/>
     <testCase name="Scenario: This is a really long scenario name to see how the list command deals with wrapping/Given: A section name that is so long that it cannot fit in a single console width/When: The test headers are printed as part of the normal running of the scenario/Then: The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent" duration="{duration}"/>
+    <testCase name="Scenario: Vector resizing affects size and capacity" duration="{duration}"/>
     <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector" duration="{duration}"/>
+    <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger" duration="{duration}"/>
     <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up" duration="{duration}"/>
+    <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up/And when: it is made smaller again" duration="{duration}"/>
     <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: it is made larger/Then: the size and capacity go up/And when: it is made smaller again/Then: the size goes down but the capacity stays the same" duration="{duration}"/>
+    <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: we reserve more space" duration="{duration}"/>
     <testCase name="Scenario: Vector resizing affects size and capacity/Given: an empty vector/When: we reserve more space/Then: The capacity is increased but the size remains the same" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/UsageTests/Class.tests.cpp">
@@ -519,6 +585,19 @@ at Class.tests.cpp:<line number>
       </failure>
     </testCase>
     <testCase name="A TEST_CASE_METHOD based test run that succeeds" duration="{duration}"/>
+    <testCase name="A TEST_CASE_PERSISTENT_FIXTURE based test run that fails/First partial run" duration="{duration}"/>
+    <testCase name="A TEST_CASE_PERSISTENT_FIXTURE based test run that fails/Second partial run" duration="{duration}">
+      <failure message="REQUIRE(m_a == 0)">
+FAILED:
+	REQUIRE( m_a == 0 )
+with expansion:
+	1 == 0
+at Class.tests.cpp:<line number>
+      </failure>
+    </testCase>
+    <testCase name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds" duration="{duration}"/>
+    <testCase name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds/First partial run" duration="{duration}"/>
+    <testCase name="A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds/Second partial run" duration="{duration}"/>
     <testCase name="Template test case method with test types specified inside std::tuple - MyTypes - 0" duration="{duration}"/>
     <testCase name="Template test case method with test types specified inside std::tuple - MyTypes - 1" duration="{duration}"/>
     <testCase name="Template test case method with test types specified inside std::tuple - MyTypes - 2" duration="{duration}"/>
@@ -528,6 +607,7 @@ at Class.tests.cpp:<line number>
     <testCase name="#1147" duration="{duration}"/>
     <testCase name="#1238" duration="{duration}"/>
     <testCase name="#1245" duration="{duration}"/>
+    <testCase name="#1319: Sections can have description (even if it is not saved" duration="{duration}"/>
     <testCase name="#1319: Sections can have description (even if it is not saved/SectionName" duration="{duration}"/>
     <testCase name="#1403" duration="{duration}"/>
     <testCase name="#1548" duration="{duration}"/>
@@ -621,35 +701,39 @@ at Condition.tests.cpp:<line number>
 FAILED:
 	CHECK( data.float_nine_point_one == Approx( 9.11f ) )
 with expansion:
-	9.1f == Approx( 9.1099996567 )
+	9.100000381f
+==
+Approx( 9.10999965667724609 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.float_nine_point_one == Approx( 9.0f ))">
 FAILED:
 	CHECK( data.float_nine_point_one == Approx( 9.0f ) )
 with expansion:
-	9.1f == Approx( 9.0 )
+	9.100000381f == Approx( 9.0 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.float_nine_point_one == Approx( 1 ))">
 FAILED:
 	CHECK( data.float_nine_point_one == Approx( 1 ) )
 with expansion:
-	9.1f == Approx( 1.0 )
+	9.100000381f == Approx( 1.0 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.float_nine_point_one == Approx( 0 ))">
 FAILED:
 	CHECK( data.float_nine_point_one == Approx( 0 ) )
 with expansion:
-	9.1f == Approx( 0.0 )
+	9.100000381f == Approx( 0.0 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.double_pi == Approx( 3.1415 ))">
 FAILED:
 	CHECK( data.double_pi == Approx( 3.1415 ) )
 with expansion:
-	3.1415926535 == Approx( 3.1415 )
+	3.14159265350000005
+==
+Approx( 3.14150000000000018 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.str_hello == &quot;goodbye&quot;)">
@@ -684,7 +768,9 @@ at Condition.tests.cpp:<line number>
 FAILED:
 	CHECK( x == Approx( 1.301 ) )
 with expansion:
-	1.3 == Approx( 1.301 )
+	1.30000000000000027
+==
+Approx( 1.30099999999999993 )
 at Condition.tests.cpp:<line number>
       </skipped>
     </testCase>
@@ -701,14 +787,18 @@ at Condition.tests.cpp:<line number>
 FAILED:
 	CHECK( data.float_nine_point_one != Approx( 9.1f ) )
 with expansion:
-	9.1f != Approx( 9.1000003815 )
+	9.100000381f
+!=
+Approx( 9.10000038146972656 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.double_pi != Approx( 3.1415926535 ))">
 FAILED:
 	CHECK( data.double_pi != Approx( 3.1415926535 ) )
 with expansion:
-	3.1415926535 != Approx( 3.1415926535 )
+	3.14159265350000005
+!=
+Approx( 3.14159265350000005 )
 at Condition.tests.cpp:<line number>
       </skipped>
       <skipped message="CHECK(data.str_hello != &quot;hello&quot;)">
@@ -727,24 +817,28 @@ at Condition.tests.cpp:<line number>
       </skipped>
     </testCase>
     <testCase name="Inequality checks that should succeed" duration="{duration}"/>
+    <testCase name="Mayfail test case with nested sections/1" duration="{duration}"/>
     <testCase name="Mayfail test case with nested sections/1/A" duration="{duration}">
       <skipped message="FAIL()">
 FAILED:
 at Condition.tests.cpp:<line number>
       </skipped>
     </testCase>
+    <testCase name="Mayfail test case with nested sections/2" duration="{duration}"/>
     <testCase name="Mayfail test case with nested sections/2/A" duration="{duration}">
       <skipped message="FAIL()">
 FAILED:
 at Condition.tests.cpp:<line number>
       </skipped>
     </testCase>
+    <testCase name="Mayfail test case with nested sections/1" duration="{duration}"/>
     <testCase name="Mayfail test case with nested sections/1/B" duration="{duration}">
       <skipped message="FAIL()">
 FAILED:
 at Condition.tests.cpp:<line number>
       </skipped>
     </testCase>
+    <testCase name="Mayfail test case with nested sections/2" duration="{duration}"/>
     <testCase name="Mayfail test case with nested sections/2/B" duration="{duration}">
       <skipped message="FAIL()">
 FAILED:
@@ -812,21 +906,21 @@ at Condition.tests.cpp:<line number>
 FAILED:
 	CHECK( data.float_nine_point_one &lt; 9 )
 with expansion:
-	9.1f &lt; 9
+	9.100000381f &lt; 9
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="CHECK(data.float_nine_point_one > 10)">
 FAILED:
 	CHECK( data.float_nine_point_one > 10 )
 with expansion:
-	9.1f > 10
+	9.100000381f > 10
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="CHECK(data.float_nine_point_one > 9.2)">
 FAILED:
 	CHECK( data.float_nine_point_one > 9.2 )
 with expansion:
-	9.1f > 9.2
+	9.100000381f > 9.19999999999999929
 at Condition.tests.cpp:<line number>
       </failure>
       <failure message="CHECK(data.str_hello > &quot;hello&quot;)">
@@ -911,6 +1005,7 @@ at Decomposition.tests.cpp:<line number>
     <testCase name="toString(enum)" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/UsageTests/Exception.tests.cpp">
+    <testCase name="#748 - captures with unexpected exceptions" duration="{duration}"/>
     <testCase name="#748 - captures with unexpected exceptions/outside assertions" duration="{duration}">
       <skipped message="TEST_CASE()">
 FAILED:
@@ -960,6 +1055,7 @@ custom std exception
 at Exception.tests.cpp:<line number>
       </error>
     </testCase>
+    <testCase name="Exception messages can be tested for" duration="{duration}"/>
     <testCase name="Exception messages can be tested for/exact match" duration="{duration}"/>
     <testCase name="Exception messages can be tested for/different case" duration="{duration}"/>
     <testCase name="Exception messages can be tested for/wildcarded" duration="{duration}"/>
@@ -1008,7 +1104,7 @@ at Exception.tests.cpp:<line number>
     <testCase name="Unexpected exceptions can be translated" duration="{duration}">
       <error message="TEST_CASE()">
 FAILED:
-3.14
+3.14000000000000012
 at Exception.tests.cpp:<line number>
       </error>
     </testCase>
@@ -1051,6 +1147,7 @@ unexpected exception
 at Exception.tests.cpp:<line number>
       </error>
     </testCase>
+    <testCase name="When unchecked exceptions are thrown, but caught, they do not affect the test" duration="{duration}"/>
     <testCase name="thrown std::strings are translated" duration="{duration}">
       <error message="TEST_CASE()">
 FAILED:
@@ -1070,21 +1167,27 @@ at Generators.tests.cpp:<line number>
       </skipped>
     </testCase>
     <testCase name="3x3x3 ints" duration="{duration}"/>
+    <testCase name="Copy and then generate a range" duration="{duration}"/>
     <testCase name="Copy and then generate a range/from var and iterators" duration="{duration}"/>
     <testCase name="Copy and then generate a range/From a temporary container" duration="{duration}"/>
     <testCase name="Copy and then generate a range/Final validation" duration="{duration}"/>
     <testCase name="GENERATE can combine literals and generators" duration="{duration}"/>
+    <testCase name="Generators -- adapters" duration="{duration}"/>
+    <testCase name="Generators -- adapters/Filtering by predicate" duration="{duration}"/>
     <testCase name="Generators -- adapters/Filtering by predicate/Basic usage" duration="{duration}"/>
     <testCase name="Generators -- adapters/Filtering by predicate/Throws if there are no matching values" duration="{duration}"/>
     <testCase name="Generators -- adapters/Shortening a range" duration="{duration}"/>
+    <testCase name="Generators -- adapters/Transforming elements" duration="{duration}"/>
     <testCase name="Generators -- adapters/Transforming elements/Same type" duration="{duration}"/>
     <testCase name="Generators -- adapters/Transforming elements/Different type" duration="{duration}"/>
     <testCase name="Generators -- adapters/Transforming elements/Different deduced type" duration="{duration}"/>
     <testCase name="Generators -- adapters/Repeating a generator" duration="{duration}"/>
+    <testCase name="Generators -- adapters/Chunking a generator into sized pieces" duration="{duration}"/>
     <testCase name="Generators -- adapters/Chunking a generator into sized pieces/Number of elements in source is divisible by chunk size" duration="{duration}"/>
     <testCase name="Generators -- adapters/Chunking a generator into sized pieces/Number of elements in source is not divisible by chunk size" duration="{duration}"/>
     <testCase name="Generators -- adapters/Chunking a generator into sized pieces/Chunk size of zero" duration="{duration}"/>
     <testCase name="Generators -- adapters/Chunking a generator into sized pieces/Throws on too small generators" duration="{duration}"/>
+    <testCase name="Generators -- simple" duration="{duration}"/>
     <testCase name="Generators -- simple/one" duration="{duration}"/>
     <testCase name="Generators -- simple/two" duration="{duration}"/>
     <testCase name="Nested generators and captured variables" duration="{duration}"/>
@@ -1094,6 +1197,7 @@ at Generators.tests.cpp:<line number>
   <file path="tests/<exe-name>/UsageTests/Matchers.tests.cpp">
     <testCase name="#2152 - ULP checks between differently signed values were wrong - double" duration="{duration}"/>
     <testCase name="#2152 - ULP checks between differently signed values were wrong - float" duration="{duration}"/>
+    <testCase name="Arbitrary predicate matcher" duration="{duration}"/>
     <testCase name="Arbitrary predicate matcher/Function pointer" duration="{duration}"/>
     <testCase name="Arbitrary predicate matcher/Lambdas + different type" duration="{duration}"/>
     <testCase name="Combining MatchAllOfGeneric does not nest" duration="{duration}"/>
@@ -1103,8 +1207,10 @@ at Generators.tests.cpp:<line number>
     <testCase name="Combining only templated matchers" duration="{duration}"/>
     <testCase name="Combining templated and concrete matchers" duration="{duration}"/>
     <testCase name="Combining templated matchers" duration="{duration}"/>
+    <testCase name="Composed generic matchers shortcircuit" duration="{duration}"/>
     <testCase name="Composed generic matchers shortcircuit/MatchAllOf" duration="{duration}"/>
     <testCase name="Composed generic matchers shortcircuit/MatchAnyOf" duration="{duration}"/>
+    <testCase name="Composed matchers shortcircuit" duration="{duration}"/>
     <testCase name="Composed matchers shortcircuit/MatchAllOf" duration="{duration}"/>
     <testCase name="Composed matchers shortcircuit/MatchAnyOf" duration="{duration}"/>
     <testCase name="Contains string matcher" duration="{duration}">
@@ -1201,6 +1307,7 @@ at Matchers.tests.cpp:<line number>
     <testCase name="Exception matchers that succeed" duration="{duration}"/>
     <testCase name="Exception message can be matched" duration="{duration}"/>
     <testCase name="Exceptions matchers" duration="{duration}"/>
+    <testCase name="Floating point matchers: double" duration="{duration}"/>
     <testCase name="Floating point matchers: double/Relative" duration="{duration}"/>
     <testCase name="Floating point matchers: double/Relative/Some subnormal values" duration="{duration}"/>
     <testCase name="Floating point matchers: double/Margin" duration="{duration}"/>
@@ -1208,6 +1315,7 @@ at Matchers.tests.cpp:<line number>
     <testCase name="Floating point matchers: double/Composed" duration="{duration}"/>
     <testCase name="Floating point matchers: double/Constructor validation" duration="{duration}"/>
     <testCase name="Floating point matchers: double/IsNaN" duration="{duration}"/>
+    <testCase name="Floating point matchers: float" duration="{duration}"/>
     <testCase name="Floating point matchers: float/Relative" duration="{duration}"/>
     <testCase name="Floating point matchers: float/Relative/Some subnormal values" duration="{duration}"/>
     <testCase name="Floating point matchers: float/Margin" duration="{duration}"/>
@@ -1280,10 +1388,13 @@ at Matchers.tests.cpp:<line number>
       </failure>
     </testCase>
     <testCase name="String matchers" duration="{duration}"/>
+    <testCase name="Vector Approx matcher" duration="{duration}"/>
     <testCase name="Vector Approx matcher/Empty vector is roughly equal to an empty vector" duration="{duration}"/>
+    <testCase name="Vector Approx matcher/Vectors with elements" duration="{duration}"/>
     <testCase name="Vector Approx matcher/Vectors with elements/A vector is approx equal to itself" duration="{duration}"/>
     <testCase name="Vector Approx matcher/Vectors with elements/Different length" duration="{duration}"/>
     <testCase name="Vector Approx matcher/Vectors with elements/Same length, different elements" duration="{duration}"/>
+    <testCase name="Vector Approx matcher -- failing" duration="{duration}"/>
     <testCase name="Vector Approx matcher -- failing/Empty and non empty vectors are not approx equal" duration="{duration}">
       <failure message="CHECK_THAT(empty, Approx( t1 ))">
 FAILED:
@@ -1302,11 +1413,13 @@ with expansion:
 at Matchers.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="Vector matchers" duration="{duration}"/>
     <testCase name="Vector matchers/Contains (element)" duration="{duration}"/>
     <testCase name="Vector matchers/Contains (vector)" duration="{duration}"/>
     <testCase name="Vector matchers/Contains (element), composed" duration="{duration}"/>
     <testCase name="Vector matchers/Equals" duration="{duration}"/>
     <testCase name="Vector matchers/UnorderedEquals" duration="{duration}"/>
+    <testCase name="Vector matchers that fail" duration="{duration}"/>
     <testCase name="Vector matchers that fail/Contains (element)" duration="{duration}">
       <failure message="CHECK_THAT(v, VectorContains( -1 ))">
 FAILED:
@@ -1401,82 +1514,114 @@ at Matchers.tests.cpp:<line number>
     </testCase>
   </file>
   <file path="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp">
+    <testCase name="Basic use of the Contains range matcher" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Different argument ranges, same element type, default comparison" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Different argument ranges, same element type, custom comparison" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Different element type, custom comparisons" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Can handle type that requires ADL-found free function begin and end" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Initialization with move only types" duration="{duration}"/>
     <testCase name="Basic use of the Contains range matcher/Matching using matcher" duration="{duration}"/>
+    <testCase name="Basic use of the Empty range matcher" duration="{duration}"/>
     <testCase name="Basic use of the Empty range matcher/Simple, std-provided containers" duration="{duration}"/>
     <testCase name="Basic use of the Empty range matcher/Type with empty" duration="{duration}"/>
     <testCase name="Basic use of the Empty range matcher/Type requires ADL found empty free function" duration="{duration}"/>
+    <testCase name="Type conversions of RangeEquals and similar" duration="{duration}"/>
+    <testCase name="Type conversions of RangeEquals and similar/Container conversions" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" duration="{duration}"/>
+    <testCase name="Type conversions of RangeEquals and similar/Value type" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" duration="{duration}"/>
+    <testCase name="Type conversions of RangeEquals and similar/Custom predicate" duration="{duration}"/>
     <testCase name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
+    <testCase name="Usage of AllMatch range matcher" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
+    <testCase name="Usage of AllMatch range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Basic usage/One false evaluates to false" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evaluates to false" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of AnyMatch range matcher" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
+    <testCase name="Usage of AnyMatch range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Basic usage/One true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evaluates to true" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of NoneMatch range matcher" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
+    <testCase name="Usage of NoneMatch range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Basic usage/One true evaluates to false" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evaluates to false" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Shortcircuiting" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of RangeEquals range matcher" duration="{duration}"/>
+    <testCase name="Usage of RangeEquals range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" duration="{duration}"/>
+    <testCase name="Usage of RangeEquals range matcher/Custom predicate" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
+    <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" duration="{duration}"/>
     <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" duration="{duration}"/>
+    <testCase name="Usage of UnorderedRangeEquals range matcher" duration="{duration}"/>
+    <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" duration="{duration}"/>
+    <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
     <testCase name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
+    <testCase name="Usage of the SizeIs range matcher" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Some with stdlib containers" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Type requires ADL found size free function" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Type has size member" duration="{duration}"/>
@@ -1575,6 +1720,8 @@ at Message.tests.cpp:<line number>
     </testCase>
     <testCase name="SUCCEED counts as a test pass" duration="{duration}"/>
     <testCase name="SUCCEED does not require an argument" duration="{duration}"/>
+    <testCase name="Standard output from all sections is reported" duration="{duration}"/>
+    <testCase name="Standard output from all sections is reported/one" duration="{duration}"/>
     <testCase name="Standard output from all sections is reported/two" duration="{duration}"/>
     <testCase name="The NO_FAIL macro reports a failure but does not fail the test" duration="{duration}"/>
     <testCase name="just failure" duration="{duration}">
@@ -1591,6 +1738,8 @@ previous unscoped info SHOULD not be seen
 at Message.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="just info" duration="{duration}"/>
+    <testCase name="just unscoped info" duration="{duration}"/>
     <testCase name="mix info, unscoped info and warning" duration="{duration}"/>
     <testCase name="not prints unscoped info from previous failures" duration="{duration}">
       <failure message="REQUIRE(false)">
@@ -1663,6 +1812,7 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </skipped>
     </testCase>
+    <testCase name="#961 -- Dynamically created sections should all be reported" duration="{duration}"/>
     <testCase name="#961 -- Dynamically created sections should all be reported/Looped section 0" duration="{duration}"/>
     <testCase name="#961 -- Dynamically created sections should all be reported/Looped section 1" duration="{duration}"/>
     <testCase name="#961 -- Dynamically created sections should all be reported/Looped section 2" duration="{duration}"/>
@@ -1683,7 +1833,9 @@ to infinity and beyond
 at Misc.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="A couple of nested sections followed by a failure/Outer" duration="{duration}"/>
     <testCase name="A couple of nested sections followed by a failure/Outer/Inner" duration="{duration}"/>
+    <testCase name="An empty test with no assertions" duration="{duration}"/>
     <testCase name="Factorials are computed" duration="{duration}"/>
     <testCase name="ManuallyRegistered" duration="{duration}"/>
     <testCase name="Nice descriptive name" duration="{duration}"/>
@@ -1812,10 +1964,14 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="even more nested SECTION tests" duration="{duration}"/>
+    <testCase name="even more nested SECTION tests/c" duration="{duration}"/>
     <testCase name="even more nested SECTION tests/c/d (leaf)" duration="{duration}"/>
     <testCase name="even more nested SECTION tests/c/e (leaf)" duration="{duration}"/>
     <testCase name="even more nested SECTION tests/f (leaf)" duration="{duration}"/>
+    <testCase name="first tag" duration="{duration}"/>
     <testCase name="long long" duration="{duration}"/>
+    <testCase name="looped SECTION tests" duration="{duration}"/>
     <testCase name="looped SECTION tests/b is currently: 0" duration="{duration}">
       <failure message="CHECK(b > a)">
 FAILED:
@@ -1892,6 +2048,8 @@ Testing if fib[7] (21) is even
 at Misc.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="more nested SECTION tests" duration="{duration}"/>
+    <testCase name="more nested SECTION tests/equal" duration="{duration}"/>
     <testCase name="more nested SECTION tests/equal/doesn't equal" duration="{duration}">
       <failure message="REQUIRE(a == b)">
 FAILED:
@@ -1901,14 +2059,18 @@ with expansion:
 at Misc.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="more nested SECTION tests/doesn't equal" duration="{duration}"/>
     <testCase name="more nested SECTION tests/doesn't equal/not equal" duration="{duration}"/>
     <testCase name="more nested SECTION tests/doesn't equal/less than" duration="{duration}"/>
+    <testCase name="nested SECTION tests" duration="{duration}"/>
     <testCase name="nested SECTION tests/doesn't equal" duration="{duration}"/>
     <testCase name="nested SECTION tests/doesn't equal/not equal" duration="{duration}"/>
     <testCase name="not allowed" duration="{duration}"/>
     <testCase name="null strings" duration="{duration}"/>
+    <testCase name="random SECTION tests" duration="{duration}"/>
     <testCase name="random SECTION tests/doesn't equal" duration="{duration}"/>
     <testCase name="random SECTION tests/not equal" duration="{duration}"/>
+    <testCase name="second tag" duration="{duration}"/>
     <testCase name="send a single char to INFO" duration="{duration}">
       <failure message="REQUIRE(false)">
 FAILED:
@@ -1927,6 +2089,7 @@ at Misc.tests.cpp:<line number>
     <testCase name="vectors can be sized and resized/resizing smaller changes size but not capacity/We can use the 'swap trick' to reset the capacity" duration="{duration}"/>
     <testCase name="vectors can be sized and resized/reserving bigger changes capacity but not size" duration="{duration}"/>
     <testCase name="vectors can be sized and resized/reserving smaller does not change size or capacity" duration="{duration}"/>
+    <testCase name="xmlentitycheck" duration="{duration}"/>
     <testCase name="xmlentitycheck/embedded xml: &lt;test>it should be possible to embed xml characters, such as &lt;, &quot; or &amp;, or even whole &lt;xml>documents&lt;/xml> within an attribute&lt;/test>" duration="{duration}"/>
     <testCase name="xmlentitycheck/encoded chars: these should all be encoded: &amp;&amp;&amp;&quot;&quot;&quot;&lt;&lt;&lt;&amp;&quot;&lt;&lt;&amp;&quot;" duration="{duration}"/>
   </file>
@@ -1997,6 +2160,9 @@ FAILED:
 at Skip.tests.cpp:<line number>
       </skipped>
     </testCase>
+    <testCase name="nested sections can be skipped dynamically at runtime/A" duration="{duration}"/>
+    <testCase name="nested sections can be skipped dynamically at runtime/B2" duration="{duration}"/>
+    <testCase name="nested sections can be skipped dynamically at runtime/B2/B1" duration="{duration}"/>
     <testCase name="nested sections can be skipped dynamically at runtime/B2/B" duration="{duration}">
       <skipped message="SKIP()">
 SKIPPED
@@ -2004,6 +2170,7 @@ at Skip.tests.cpp:<line number>
       </skipped>
     </testCase>
     <testCase name="nested sections can be skipped dynamically at runtime/B" duration="{duration}"/>
+    <testCase name="sections can be skipped dynamically at runtime" duration="{duration}"/>
     <testCase name="sections can be skipped dynamically at runtime/not skipped" duration="{duration}"/>
     <testCase name="sections can be skipped dynamically at runtime/skipped" duration="{duration}">
       <skipped message="SKIP()">
@@ -2032,20 +2199,26 @@ at Skip.tests.cpp:<line number>
     <testCase name="Stringifying std::chrono::time_point&lt;system_clock>" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp">
+    <testCase name="Capture and info messages" duration="{duration}"/>
     <testCase name="Capture and info messages/Capture should stringify like assertions" duration="{duration}"/>
     <testCase name="Capture and info messages/Info should NOT stringify the way assertions do" duration="{duration}"/>
+    <testCase name="Character pretty printing" duration="{duration}"/>
     <testCase name="Character pretty printing/Specifically escaped" duration="{duration}"/>
     <testCase name="Character pretty printing/General chars" duration="{duration}"/>
     <testCase name="Character pretty printing/Low ASCII" duration="{duration}"/>
     <testCase name="Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified" duration="{duration}"/>
+    <testCase name="Precision of floating point stringification can be set" duration="{duration}"/>
     <testCase name="Precision of floating point stringification can be set/Floats" duration="{duration}"/>
     <testCase name="Precision of floating point stringification can be set/Double" duration="{duration}"/>
+    <testCase name="Static arrays are convertible to string" duration="{duration}"/>
     <testCase name="Static arrays are convertible to string/Single item" duration="{duration}"/>
     <testCase name="Static arrays are convertible to string/Multiple" duration="{duration}"/>
     <testCase name="Static arrays are convertible to string/Non-trivial inner items" duration="{duration}"/>
+    <testCase name="std::map is convertible string" duration="{duration}"/>
     <testCase name="std::map is convertible string/empty" duration="{duration}"/>
     <testCase name="std::map is convertible string/single item" duration="{duration}"/>
     <testCase name="std::map is convertible string/several items" duration="{duration}"/>
+    <testCase name="std::set is convertible string" duration="{duration}"/>
     <testCase name="std::set is convertible string/empty" duration="{duration}"/>
     <testCase name="std::set is convertible string/single item" duration="{duration}"/>
     <testCase name="std::set is convertible string/several items" duration="{duration}"/>
@@ -2090,6 +2263,7 @@ FAILED:
 at Tricky.tests.cpp:<line number>
       </failure>
     </testCase>
+    <testCase name="(unimplemented) static bools can be evaluated" duration="{duration}"/>
     <testCase name="(unimplemented) static bools can be evaluated/compare to true" duration="{duration}"/>
     <testCase name="(unimplemented) static bools can be evaluated/compare to false" duration="{duration}"/>
     <testCase name="(unimplemented) static bools can be evaluated/negation" duration="{duration}"/>
@@ -2125,6 +2299,7 @@ at Tricky.tests.cpp:<line number>
     <testCase name="X/level/1/a" duration="{duration}"/>
     <testCase name="X/level/1/b" duration="{duration}"/>
     <testCase name="boolean member" duration="{duration}"/>
+    <testCase name="has printf" duration="{duration}"/>
     <testCase name="non streamable - with conv. op" duration="{duration}"/>
     <testCase name="non-copyable objects" duration="{duration}"/>
     <testCase name="null_ptr" duration="{duration}"/>
@@ -2133,6 +2308,7 @@ at Tricky.tests.cpp:<line number>
   <file path="tests/<exe-name>/UsageTests/VariadicMacros.tests.cpp">
     <testCase name="Anonymous test case 1" duration="{duration}"/>
     <testCase name="Test case with one argument" duration="{duration}"/>
+    <testCase name="Variadic macros" duration="{duration}"/>
     <testCase name="Variadic macros/Section with one argument" duration="{duration}"/>
   </file>
 </testExecutions>

tests/SelfTest/Baselines/tap.sw.approved.txt

@@ -478,6 +478,14 @@ ok {test-number} - Nttp_Fixture<V>::value > 0 for: 6 > 0
 not ok {test-number} - m_a == 2 for: 1 == 2
 # A TEST_CASE_METHOD based test run that succeeds
 ok {test-number} - m_a == 1 for: 1 == 1
+# A TEST_CASE_PERSISTENT_FIXTURE based test run that fails
+ok {test-number} - m_a++ == 0 for: 0 == 0
+# A TEST_CASE_PERSISTENT_FIXTURE based test run that fails
+not ok {test-number} - m_a == 0 for: 1 == 0
+# A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds
+ok {test-number} - m_a++ == 0 for: 0 == 0
+# A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds
+ok {test-number} - m_a == 1 for: 1 == 1
 # A Template product test case - Foo<float>
 ok {test-number} - x.size() == 0 for: 0 == 0
 # A Template product test case - Foo<int>
@@ -495,17 +503,17 @@ ok {test-number} - x.size() > 0 for: 42 > 0
 # A Template product test case with array signature - std::array<int, 9>
 ok {test-number} - x.size() > 0 for: 9 > 0
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - d == 1.23_a for: 1.23 == Approx( 1.23 )
+ok {test-number} - d == 1.23_a for: 1.22999999999999998 == Approx( 1.22999999999999998 )
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - d != 1.22_a for: 1.23 != Approx( 1.22 )
+ok {test-number} - d != 1.22_a for: 1.22999999999999998 != Approx( 1.21999999999999997 )
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - -d == -1.23_a for: -1.23 == Approx( -1.23 )
+ok {test-number} - -d == -1.23_a for: -1.22999999999999998 == Approx( -1.22999999999999998 )
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - d == 1.2_a .epsilon(.1) for: 1.23 == Approx( 1.2 )
+ok {test-number} - d == 1.2_a .epsilon(.1) for: 1.22999999999999998 == Approx( 1.19999999999999996 )
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - d != 1.2_a .epsilon(.001) for: 1.23 != Approx( 1.2 )
+ok {test-number} - d != 1.2_a .epsilon(.001) for: 1.22999999999999998 != Approx( 1.19999999999999996 )
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - d == 1_a .epsilon(.3) for: 1.23 == Approx( 1.0 )
+ok {test-number} - d == 1_a .epsilon(.3) for: 1.22999999999999998 == Approx( 1.0 )
 # A couple of nested sections followed by a failure
 ok {test-number} - with 1 message: 'that's not flying - that's failing in style'
 # A couple of nested sections followed by a failure
@@ -523,9 +531,9 @@ ok {test-number} - 104.0 == Approx(100.0).margin(4) for: 104.0 == Approx( 100.0
 # Absolute margin
 ok {test-number} - 104.0 != Approx(100.0).margin(3) for: 104.0 != Approx( 100.0 )
 # Absolute margin
-ok {test-number} - 100.3 != Approx(100.0) for: 100.3 != Approx( 100.0 )
+ok {test-number} - 100.3 != Approx(100.0) for: 100.29999999999999716 != Approx( 100.0 )
 # Absolute margin
-ok {test-number} - 100.3 == Approx(100.0).margin(0.5) for: 100.3 == Approx( 100.0 )
+ok {test-number} - 100.3 == Approx(100.0).margin(0.5) for: 100.29999999999999716 == Approx( 100.0 )
 # An expression with side-effects should only be evaluated once
 ok {test-number} - i++ == 7 for: 7 == 7
 # An expression with side-effects should only be evaluated once
@@ -561,15 +569,15 @@ ok {test-number} - 245.0f == Approx(245.25f).margin(0.25f) for: 245.0f == Approx
 # Approx with exactly-representable margin
 ok {test-number} - 245.5f == Approx(245.25f).margin(0.25f) for: 245.5f == Approx( 245.25 )
 # Approximate PI
-ok {test-number} - divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) for: 3.1428571429 == Approx( 3.141 )
+ok {test-number} - divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) for: 3.14285714285714279 == Approx( 3.14100000000000001 )
 # Approximate PI
-ok {test-number} - divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) for: 3.1428571429 != Approx( 3.141 )
+ok {test-number} - divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) for: 3.14285714285714279 != Approx( 3.14100000000000001 )
 # Approximate comparisons with different epsilons
-ok {test-number} - d != Approx( 1.231 ) for: 1.23 != Approx( 1.231 )
+ok {test-number} - d != Approx( 1.231 ) for: 1.22999999999999998 != Approx( 1.23100000000000009 )
 # Approximate comparisons with different epsilons
-ok {test-number} - d == Approx( 1.231 ).epsilon( 0.1 ) for: 1.23 == Approx( 1.231 )
+ok {test-number} - d == Approx( 1.231 ).epsilon( 0.1 ) for: 1.22999999999999998 == Approx( 1.23100000000000009 )
 # Approximate comparisons with floats
-ok {test-number} - 1.23f == Approx( 1.23f ) for: 1.23f == Approx( 1.2300000191 )
+ok {test-number} - 1.23f == Approx( 1.23f ) for: 1.230000019f == Approx( 1.23000001907348633 )
 # Approximate comparisons with floats
 ok {test-number} - 0.0f == Approx( 0.0f ) for: 0.0f == Approx( 0.0 )
 # Approximate comparisons with ints
@@ -583,9 +591,9 @@ ok {test-number} - 0 == Approx( dZero) for: 0 == Approx( 0.0 )
 # Approximate comparisons with mixed numeric types
 ok {test-number} - 0 == Approx( dSmall ).margin( 0.001 ) for: 0 == Approx( 0.00001 )
 # Approximate comparisons with mixed numeric types
-ok {test-number} - 1.234f == Approx( dMedium ) for: 1.234f == Approx( 1.234 )
+ok {test-number} - 1.234f == Approx( dMedium ) for: 1.233999968f == Approx( 1.23399999999999999 )
 # Approximate comparisons with mixed numeric types
-ok {test-number} - dMedium == Approx( 1.234f ) for: 1.234 == Approx( 1.2339999676 )
+ok {test-number} - dMedium == Approx( 1.234f ) for: 1.23399999999999999 == Approx( 1.23399996757507324 )
 # Arbitrary predicate matcher
 ok {test-number} - 1, Predicate<int>( alwaysTrue, "always true" ) for: 1 matches predicate: "always true"
 # Arbitrary predicate matcher
@@ -716,6 +724,18 @@ ok {test-number} - ::Catch::Detail::stringify( '\0' ) == "0" for: "0" == "0"
 ok {test-number} - ::Catch::Detail::stringify( static_cast<char>(2) ) == "2" for: "2" == "2"
 # Character pretty printing
 ok {test-number} - ::Catch::Detail::stringify( static_cast<char>(5) ) == "5" for: "5" == "5"
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - name.empty() for: true
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - result for: {?}
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - result.type() == Catch::Clara::Detail::ResultType::Ok for: 0 == 0
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - parsed.type() == Catch::Clara::ParseResultType::NoMatch for: 1 == 1
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - parsed.remainingTokens().count() == 2 for: 2 == 2
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - name.empty() for: true
 # Clara::Arg supports single-arg parse the way Opt does
 ok {test-number} - name.empty() for: true
 # Clara::Arg supports single-arg parse the way Opt does
@@ -967,7 +987,7 @@ not ok {test-number} - unexpected exception with message: 'custom exception - no
 # Custom std-exceptions can be custom translated
 not ok {test-number} - unexpected exception with message: 'custom std exception'
 # Default scale is invisible to comparison
-ok {test-number} - 101.000001 != Approx(100).epsilon(0.01) for: 101.000001 != Approx( 100.0 )
+ok {test-number} - 101.000001 != Approx(100).epsilon(0.01) for: 101.00000099999999748 != Approx( 100.0 )
 # Default scale is invisible to comparison
 ok {test-number} - std::pow(10, -5) != Approx(std::pow(10, -7)) for: 0.00001 != Approx( 0.0000001 )
 # Directly creating an EnumInfo
@@ -999,7 +1019,7 @@ ok {test-number} - stringify( Bikeshed::Colours::Red ) == "Red" for: "Red" == "R
 # Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( Bikeshed::Colours::Blue ) == "Blue" for: "Blue" == "Blue"
 # Epsilon only applies to Approx's value
-ok {test-number} - 101.01 != Approx(100).epsilon(0.01) for: 101.01 != Approx( 100.0 )
+ok {test-number} - 101.01 != Approx(100).epsilon(0.01) for: 101.01000000000000512 != Approx( 100.0 )
 # Equality checks that should fail
 not ok {test-number} - data.int_seven == 6 for: 7 == 6
 # Equality checks that should fail
@@ -1007,15 +1027,15 @@ not ok {test-number} - data.int_seven == 8 for: 7 == 8
 # Equality checks that should fail
 not ok {test-number} - data.int_seven == 0 for: 7 == 0
 # Equality checks that should fail
-not ok {test-number} - data.float_nine_point_one == Approx( 9.11f ) for: 9.1f == Approx( 9.1099996567 )
+not ok {test-number} - data.float_nine_point_one == Approx( 9.11f ) for: 9.100000381f == Approx( 9.10999965667724609 )
 # Equality checks that should fail
-not ok {test-number} - data.float_nine_point_one == Approx( 9.0f ) for: 9.1f == Approx( 9.0 )
+not ok {test-number} - data.float_nine_point_one == Approx( 9.0f ) for: 9.100000381f == Approx( 9.0 )
 # Equality checks that should fail
-not ok {test-number} - data.float_nine_point_one == Approx( 1 ) for: 9.1f == Approx( 1.0 )
+not ok {test-number} - data.float_nine_point_one == Approx( 1 ) for: 9.100000381f == Approx( 1.0 )
 # Equality checks that should fail
-not ok {test-number} - data.float_nine_point_one == Approx( 0 ) for: 9.1f == Approx( 0.0 )
+not ok {test-number} - data.float_nine_point_one == Approx( 0 ) for: 9.100000381f == Approx( 0.0 )
 # Equality checks that should fail
-not ok {test-number} - data.double_pi == Approx( 3.1415 ) for: 3.1415926535 == Approx( 3.1415 )
+not ok {test-number} - data.double_pi == Approx( 3.1415 ) for: 3.14159265350000005 == Approx( 3.14150000000000018 )
 # Equality checks that should fail
 not ok {test-number} - data.str_hello == "goodbye" for: "hello" == "goodbye"
 # Equality checks that should fail
@@ -1025,13 +1045,13 @@ not ok {test-number} - data.str_hello == "hello1" for: "hello" == "hello1"
 # Equality checks that should fail
 not ok {test-number} - data.str_hello.size() == 6 for: 5 == 6
 # Equality checks that should fail
-not ok {test-number} - x == Approx( 1.301 ) for: 1.3 == Approx( 1.301 )
+not ok {test-number} - x == Approx( 1.301 ) for: 1.30000000000000027 == Approx( 1.30099999999999993 )
 # Equality checks that should succeed
 ok {test-number} - data.int_seven == 7 for: 7 == 7
 # Equality checks that should succeed
-ok {test-number} - data.float_nine_point_one == Approx( 9.1f ) for: 9.1f == Approx( 9.1000003815 )
+ok {test-number} - data.float_nine_point_one == Approx( 9.1f ) for: 9.100000381f == Approx( 9.10000038146972656 )
 # Equality checks that should succeed
-ok {test-number} - data.double_pi == Approx( 3.1415926535 ) for: 3.1415926535 == Approx( 3.1415926535 )
+ok {test-number} - data.double_pi == Approx( 3.1415926535 ) for: 3.14159265350000005 == Approx( 3.14159265350000005 )
 # Equality checks that should succeed
 ok {test-number} - data.str_hello == "hello" for: "hello" == "hello"
 # Equality checks that should succeed
@@ -1039,7 +1059,7 @@ ok {test-number} - "hello" == data.str_hello for: "hello" == "hello"
 # Equality checks that should succeed
 ok {test-number} - data.str_hello.size() == 5 for: 5 == 5
 # Equality checks that should succeed
-ok {test-number} - x == Approx( 1.3 ) for: 1.3 == Approx( 1.3 )
+ok {test-number} - x == Approx( 1.3 ) for: 1.30000000000000027 == Approx( 1.30000000000000004 )
 # Equals
 ok {test-number} - testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) for: "this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring"
 # Equals
@@ -1125,23 +1145,23 @@ ok {test-number} - Factorial(10) == 3628800 for: 3628800 (0x<hex digits>) == 362
 # Filter generator throws exception for empty generator
 ok {test-number} - filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
 # Floating point matchers: double
-ok {test-number} - 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.1 are within 10% of each other
+ok {test-number} - 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.09999999999999964 are within 10% of each other
 # Floating point matchers: double
-ok {test-number} - 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.2 are within 10% of each other
+ok {test-number} - 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.19999999999999929 are within 10% of each other
 # Floating point matchers: double
-ok {test-number} - 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0 are within 99% of each other
+ok {test-number} - 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0.0 are within 99% of each other
 # Floating point matchers: double
-ok {test-number} - -0., WithinRel( 0. ) for: -0.0 and 0 are within 2.22045e-12% of each other
+ok {test-number} - -0., WithinRel( 0. ) for: -0.0 and 0.0 are within 2.22045e-12% of each other
 # Floating point matchers: double
-ok {test-number} - v1, WithinRel( v2 ) for: 0.0 and 2.22507e-308 are within 2.22045e-12% of each other
+ok {test-number} - v1, WithinRel( v2 ) for: 0.0 and 0.0 are within 2.22045e-12% of each other
 # Floating point matchers: double
 ok {test-number} - 1., WithinAbs( 1., 0 ) for: 1.0 is within 0.0 of 1.0
 # Floating point matchers: double
 ok {test-number} - 0., WithinAbs( 1., 1 ) for: 0.0 is within 1.0 of 1.0
 # Floating point matchers: double
-ok {test-number} - 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0
+ok {test-number} - 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.98999999999999999 of 1.0
 # Floating point matchers: double
-ok {test-number} - 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0
+ok {test-number} - 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.98999999999999999 of 1.0
 # Floating point matchers: double
 ok {test-number} - 11., !WithinAbs( 10., 0.5 ) for: 11.0 not is within 0.5 of 10.0
 # Floating point matchers: double
@@ -1149,11 +1169,11 @@ ok {test-number} - 10., !WithinAbs( 11., 0.5 ) for: 10.0 not is within 0.5 of 11
 # Floating point matchers: double
 ok {test-number} - -10., WithinAbs( -10., 0.5 ) for: -10.0 is within 0.5 of -10.0
 # Floating point matchers: double
-ok {test-number} - -10., WithinAbs( -9.6, 0.5 ) for: -10.0 is within 0.5 of -9.6
+ok {test-number} - -10., WithinAbs( -9.6, 0.5 ) for: -10.0 is within 0.5 of -9.59999999999999964
 # Floating point matchers: double
 ok {test-number} - 1., WithinULP( 1., 0 ) for: 1.0 is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00])
 # Floating point matchers: double
-ok {test-number} - nextafter( 1., 2. ), WithinULP( 1., 1 ) for: 1.0 is within 1 ULPs of 1.0000000000000000e+00 ([9.9999999999999989e-01, 1.0000000000000002e+00])
+ok {test-number} - nextafter( 1., 2. ), WithinULP( 1., 1 ) for: 1.00000000000000022 is within 1 ULPs of 1.0000000000000000e+00 ([9.9999999999999989e-01, 1.0000000000000002e+00])
 # Floating point matchers: double
 ok {test-number} - 0., WithinULP( nextafter( 0., 1. ), 1 ) for: 0.0 is within 1 ULPs of 4.9406564584124654e-324 ([0.0000000000000000e+00, 9.8813129168249309e-324])
 # Floating point matchers: double
@@ -1169,7 +1189,7 @@ ok {test-number} - 1., WithinAbs( 1., 0.5 ) || WithinULP( 2., 1 ) for: 1.0 ( is
 # Floating point matchers: double
 ok {test-number} - 1., WithinAbs( 2., 0.5 ) || WithinULP( 1., 0 ) for: 1.0 ( is within 0.5 of 2.0 or is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00]) )
 # Floating point matchers: double
-ok {test-number} - 0.0001, WithinAbs( 0., 0.001 ) || WithinRel( 0., 0.1 ) for: 0.0001 ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+ok {test-number} - 0.0001, WithinAbs( 0., 0.001 ) || WithinRel( 0., 0.1 ) for: 0.0001 ( is within 0.001 of 0.0 or and 0.0 are within 10% of each other )
 # Floating point matchers: double
 ok {test-number} - WithinAbs( 1., 0. )
 # Floating point matchers: double
@@ -1185,23 +1205,23 @@ ok {test-number} - WithinRel( 1., 1. ), std::domain_error
 # Floating point matchers: double
 ok {test-number} - 1., !IsNaN() for: 1.0 not is NaN
 # Floating point matchers: float
-ok {test-number} - 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.1 are within 10% of each other
+ok {test-number} - 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.10000038146972656 are within 10% of each other
 # Floating point matchers: float
-ok {test-number} - 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.2 are within 10% of each other
+ok {test-number} - 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.19999980926513672 are within 10% of each other
 # Floating point matchers: float
-ok {test-number} - 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0 are within 99% of each other
+ok {test-number} - 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0.0 are within 99% of each other
 # Floating point matchers: float
-ok {test-number} - -0.f, WithinRel( 0.f ) for: -0.0f and 0 are within 0.00119209% of each other
+ok {test-number} - -0.f, WithinRel( 0.f ) for: -0.0f and 0.0 are within 0.00119209% of each other
 # Floating point matchers: float
-ok {test-number} - v1, WithinRel( v2 ) for: 0.0f and 1.17549e-38 are within 0.00119209% of each other
+ok {test-number} - v1, WithinRel( v2 ) for: 0.0f and 0.0 are within 0.00119209% of each other
 # Floating point matchers: float
 ok {test-number} - 1.f, WithinAbs( 1.f, 0 ) for: 1.0f is within 0.0 of 1.0
 # Floating point matchers: float
 ok {test-number} - 0.f, WithinAbs( 1.f, 1 ) for: 0.0f is within 1.0 of 1.0
 # Floating point matchers: float
-ok {test-number} - 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0
+ok {test-number} - 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.99000000953674316 of 1.0
 # Floating point matchers: float
-ok {test-number} - 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0
+ok {test-number} - 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.99000000953674316 of 1.0
 # Floating point matchers: float
 ok {test-number} - 0.f, WithinAbs( -0.f, 0 ) for: 0.0f is within 0.0 of -0.0
 # Floating point matchers: float
@@ -1211,13 +1231,13 @@ ok {test-number} - 10.f, !WithinAbs( 11.f, 0.5f ) for: 10.0f not is within 0.5 o
 # Floating point matchers: float
 ok {test-number} - -10.f, WithinAbs( -10.f, 0.5f ) for: -10.0f is within 0.5 of -10.0
 # Floating point matchers: float
-ok {test-number} - -10.f, WithinAbs( -9.6f, 0.5f ) for: -10.0f is within 0.5 of -9.6000003815
+ok {test-number} - -10.f, WithinAbs( -9.6f, 0.5f ) for: -10.0f is within 0.5 of -9.60000038146972656
 # Floating point matchers: float
 ok {test-number} - 1.f, WithinULP( 1.f, 0 ) for: 1.0f is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00])
 # Floating point matchers: float
 ok {test-number} - -1.f, WithinULP( -1.f, 0 ) for: -1.0f is within 0 ULPs of -1.00000000e+00f ([-1.00000000e+00, -1.00000000e+00])
 # Floating point matchers: float
-ok {test-number} - nextafter( 1.f, 2.f ), WithinULP( 1.f, 1 ) for: 1.0f is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00])
+ok {test-number} - nextafter( 1.f, 2.f ), WithinULP( 1.f, 1 ) for: 1.000000119f is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00])
 # Floating point matchers: float
 ok {test-number} - 0.f, WithinULP( nextafter( 0.f, 1.f ), 1 ) for: 0.0f is within 1 ULPs of 1.40129846e-45f ([0.00000000e+00, 2.80259693e-45])
 # Floating point matchers: float
@@ -1233,7 +1253,7 @@ ok {test-number} - 1.f, WithinAbs( 1.f, 0.5 ) || WithinULP( 1.f, 1 ) for: 1.0f (
 # Floating point matchers: float
 ok {test-number} - 1.f, WithinAbs( 2.f, 0.5 ) || WithinULP( 1.f, 0 ) for: 1.0f ( is within 0.5 of 2.0 or is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00]) )
 # Floating point matchers: float
-ok {test-number} - 0.0001f, WithinAbs( 0.f, 0.001f ) || WithinRel( 0.f, 0.1f ) for: 0.0001f ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+ok {test-number} - 0.0001f, WithinAbs( 0.f, 0.001f ) || WithinRel( 0.f, 0.1f ) for: 0.0001f ( is within 0.00100000004749745 of 0.0 or and 0.0 are within 10% of each other )
 # Floating point matchers: float
 ok {test-number} - WithinAbs( 1.f, 0.f )
 # Floating point matchers: float
@@ -1593,83 +1613,83 @@ ok {test-number} - gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) wit
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.9 == Approx( -0.9 ) with 1 message: 'Current expected value is -0.9'
+ok {test-number} - gen.get() == Approx(expected) for: -0.90000000000000002 == Approx( -0.90000000000000002 ) with 1 message: 'Current expected value is -0.9'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.9'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.8 == Approx( -0.8 ) with 1 message: 'Current expected value is -0.8'
+ok {test-number} - gen.get() == Approx(expected) for: -0.80000000000000004 == Approx( -0.80000000000000004 ) with 1 message: 'Current expected value is -0.8'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.8'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+ok {test-number} - gen.get() == Approx(expected) for: -0.70000000000000007 == Approx( -0.70000000000000007 ) with 1 message: 'Current expected value is -0.7'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.7'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.6 == Approx( -0.6 ) with 1 message: 'Current expected value is -0.6'
+ok {test-number} - gen.get() == Approx(expected) for: -0.60000000000000009 == Approx( -0.60000000000000009 ) with 1 message: 'Current expected value is -0.6'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.6'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.5 == Approx( -0.5 ) with 1 message: 'Current expected value is -0.5'
+ok {test-number} - gen.get() == Approx(expected) for: -0.50000000000000011 == Approx( -0.50000000000000011 ) with 1 message: 'Current expected value is -0.5'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.5'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+ok {test-number} - gen.get() == Approx(expected) for: -0.40000000000000013 == Approx( -0.40000000000000013 ) with 1 message: 'Current expected value is -0.4'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.4'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.3 == Approx( -0.3 ) with 1 message: 'Current expected value is -0.3'
+ok {test-number} - gen.get() == Approx(expected) for: -0.30000000000000016 == Approx( -0.30000000000000016 ) with 1 message: 'Current expected value is -0.3'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.3'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.2 == Approx( -0.2 ) with 1 message: 'Current expected value is -0.2'
+ok {test-number} - gen.get() == Approx(expected) for: -0.20000000000000015 == Approx( -0.20000000000000015 ) with 1 message: 'Current expected value is -0.2'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.2'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+ok {test-number} - gen.get() == Approx(expected) for: -0.10000000000000014 == Approx( -0.10000000000000014 ) with 1 message: 'Current expected value is -0.1'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.0 == Approx( -0.0 ) with 1 message: 'Current expected value is -1.38778e-16'
+ok {test-number} - gen.get() == Approx(expected) for: -0.00000000000000014 == Approx( -0.00000000000000014 ) with 1 message: 'Current expected value is -1.38778e-16'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1.38778e-16'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.1 == Approx( 0.1 ) with 1 message: 'Current expected value is 0.1'
+ok {test-number} - gen.get() == Approx(expected) for: 0.09999999999999987 == Approx( 0.09999999999999987 ) with 1 message: 'Current expected value is 0.1'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+ok {test-number} - gen.get() == Approx(expected) for: 0.19999999999999987 == Approx( 0.19999999999999987 ) with 1 message: 'Current expected value is 0.2'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.2'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.3 == Approx( 0.3 ) with 1 message: 'Current expected value is 0.3'
+ok {test-number} - gen.get() == Approx(expected) for: 0.29999999999999988 == Approx( 0.29999999999999988 ) with 1 message: 'Current expected value is 0.3'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.3'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.4 == Approx( 0.4 ) with 1 message: 'Current expected value is 0.4'
+ok {test-number} - gen.get() == Approx(expected) for: 0.39999999999999991 == Approx( 0.39999999999999991 ) with 1 message: 'Current expected value is 0.4'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.4'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5'
+ok {test-number} - gen.get() == Approx(expected) for: 0.49999999999999989 == Approx( 0.49999999999999989 ) with 1 message: 'Current expected value is 0.5'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.5'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.6 == Approx( 0.6 ) with 1 message: 'Current expected value is 0.6'
+ok {test-number} - gen.get() == Approx(expected) for: 0.59999999999999987 == Approx( 0.59999999999999987 ) with 1 message: 'Current expected value is 0.6'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.6'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.7 == Approx( 0.7 ) with 1 message: 'Current expected value is 0.7'
+ok {test-number} - gen.get() == Approx(expected) for: 0.69999999999999984 == Approx( 0.69999999999999984 ) with 1 message: 'Current expected value is 0.7'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.7'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.8 == Approx( 0.8 ) with 1 message: 'Current expected value is 0.8'
+ok {test-number} - gen.get() == Approx(expected) for: 0.79999999999999982 == Approx( 0.79999999999999982 ) with 1 message: 'Current expected value is 0.8'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.8'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.9 == Approx( 0.9 ) with 1 message: 'Current expected value is 0.9'
+ok {test-number} - gen.get() == Approx(expected) for: 0.8999999999999998 == Approx( 0.8999999999999998 ) with 1 message: 'Current expected value is 0.9'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.9'
 # Generators internals
-ok {test-number} - gen.get() == Approx( rangeEnd ) for: 1.0 == Approx( 1.0 )
+ok {test-number} - gen.get() == Approx( rangeEnd ) for: 0.99999999999999978 == Approx( 1.0 )
 # Generators internals
 ok {test-number} - !(gen.next()) for: !false
 # Generators internals
@@ -1677,19 +1697,19 @@ ok {test-number} - gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) wit
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+ok {test-number} - gen.get() == Approx(expected) for: -0.69999999999999996 == Approx( -0.69999999999999996 ) with 1 message: 'Current expected value is -0.7'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.7'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+ok {test-number} - gen.get() == Approx(expected) for: -0.39999999999999997 == Approx( -0.39999999999999997 ) with 1 message: 'Current expected value is -0.4'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.4'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+ok {test-number} - gen.get() == Approx(expected) for: -0.09999999999999998 == Approx( -0.09999999999999998 ) with 1 message: 'Current expected value is -0.1'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+ok {test-number} - gen.get() == Approx(expected) for: 0.20000000000000001 == Approx( 0.20000000000000001 ) with 1 message: 'Current expected value is 0.2'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.2'
 # Generators internals
@@ -1703,19 +1723,19 @@ ok {test-number} - gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) wit
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+ok {test-number} - gen.get() == Approx(expected) for: -0.69999999999999996 == Approx( -0.69999999999999996 ) with 1 message: 'Current expected value is -0.7'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.7'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+ok {test-number} - gen.get() == Approx(expected) for: -0.39999999999999997 == Approx( -0.39999999999999997 ) with 1 message: 'Current expected value is -0.4'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.4'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+ok {test-number} - gen.get() == Approx(expected) for: -0.09999999999999998 == Approx( -0.09999999999999998 ) with 1 message: 'Current expected value is -0.1'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+ok {test-number} - gen.get() == Approx(expected) for: 0.20000000000000001 == Approx( 0.20000000000000001 ) with 1 message: 'Current expected value is 0.2'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.2'
 # Generators internals
@@ -1777,13 +1797,13 @@ ok {test-number} - gen.get() == -7 for: -7 == -7
 # Generators internals
 ok {test-number} - !(gen.next()) for: !false
 # Greater-than inequalities with different epsilons
-ok {test-number} - d >= Approx( 1.22 ) for: 1.23 >= Approx( 1.22 )
+ok {test-number} - d >= Approx( 1.22 ) for: 1.22999999999999998 >= Approx( 1.21999999999999997 )
 # Greater-than inequalities with different epsilons
-ok {test-number} - d >= Approx( 1.23 ) for: 1.23 >= Approx( 1.23 )
+ok {test-number} - d >= Approx( 1.23 ) for: 1.22999999999999998 >= Approx( 1.22999999999999998 )
 # Greater-than inequalities with different epsilons
-ok {test-number} - !(d >= Approx( 1.24 )) for: !(1.23 >= Approx( 1.24 ))
+ok {test-number} - !(d >= Approx( 1.24 )) for: !(1.22999999999999998 >= Approx( 1.23999999999999999 ))
 # Greater-than inequalities with different epsilons
-ok {test-number} - d >= Approx( 1.24 ).epsilon(0.1) for: 1.23 >= Approx( 1.24 )
+ok {test-number} - d >= Approx( 1.24 ).epsilon(0.1) for: 1.22999999999999998 >= Approx( 1.23999999999999999 )
 # Hashers with different seed produce different hash with same test case
 ok {test-number} - h1( dummy ) != h2( dummy ) for: 3422778688 (0x<hex digits>) != 130711275 (0x<hex digits>)
 # Hashers with same seed produce same hash
@@ -1837,9 +1857,9 @@ not ok {test-number} - unexpected exception with message: 'Exception translation
 # Inequality checks that should fail
 not ok {test-number} - data.int_seven != 7 for: 7 != 7
 # Inequality checks that should fail
-not ok {test-number} - data.float_nine_point_one != Approx( 9.1f ) for: 9.1f != Approx( 9.1000003815 )
+not ok {test-number} - data.float_nine_point_one != Approx( 9.1f ) for: 9.100000381f != Approx( 9.10000038146972656 )
 # Inequality checks that should fail
-not ok {test-number} - data.double_pi != Approx( 3.1415926535 ) for: 3.1415926535 != Approx( 3.1415926535 )
+not ok {test-number} - data.double_pi != Approx( 3.1415926535 ) for: 3.14159265350000005 != Approx( 3.14159265350000005 )
 # Inequality checks that should fail
 not ok {test-number} - data.str_hello != "hello" for: "hello" != "hello"
 # Inequality checks that should fail
@@ -1849,15 +1869,15 @@ ok {test-number} - data.int_seven != 6 for: 7 != 6
 # Inequality checks that should succeed
 ok {test-number} - data.int_seven != 8 for: 7 != 8
 # Inequality checks that should succeed
-ok {test-number} - data.float_nine_point_one != Approx( 9.11f ) for: 9.1f != Approx( 9.1099996567 )
+ok {test-number} - data.float_nine_point_one != Approx( 9.11f ) for: 9.100000381f != Approx( 9.10999965667724609 )
 # Inequality checks that should succeed
-ok {test-number} - data.float_nine_point_one != Approx( 9.0f ) for: 9.1f != Approx( 9.0 )
+ok {test-number} - data.float_nine_point_one != Approx( 9.0f ) for: 9.100000381f != Approx( 9.0 )
 # Inequality checks that should succeed
-ok {test-number} - data.float_nine_point_one != Approx( 1 ) for: 9.1f != Approx( 1.0 )
+ok {test-number} - data.float_nine_point_one != Approx( 1 ) for: 9.100000381f != Approx( 1.0 )
 # Inequality checks that should succeed
-ok {test-number} - data.float_nine_point_one != Approx( 0 ) for: 9.1f != Approx( 0.0 )
+ok {test-number} - data.float_nine_point_one != Approx( 0 ) for: 9.100000381f != Approx( 0.0 )
 # Inequality checks that should succeed
-ok {test-number} - data.double_pi != Approx( 3.1415 ) for: 3.1415926535 != Approx( 3.1415 )
+ok {test-number} - data.double_pi != Approx( 3.1415 ) for: 3.14159265350000005 != Approx( 3.14150000000000018 )
 # Inequality checks that should succeed
 ok {test-number} - data.str_hello != "goodbye" for: "hello" != "goodbye"
 # Inequality checks that should succeed
@@ -1905,13 +1925,13 @@ ok {test-number} - sstream.str() == "\"\\\\/\\t\\r\\n\"" for: ""\\/\t\r\n"" == "
 # Lambdas in assertions
 ok {test-number} - []() { return true; }() for: true
 # Less-than inequalities with different epsilons
-ok {test-number} - d <= Approx( 1.24 ) for: 1.23 <= Approx( 1.24 )
+ok {test-number} - d <= Approx( 1.24 ) for: 1.22999999999999998 <= Approx( 1.23999999999999999 )
 # Less-than inequalities with different epsilons
-ok {test-number} - d <= Approx( 1.23 ) for: 1.23 <= Approx( 1.23 )
+ok {test-number} - d <= Approx( 1.23 ) for: 1.22999999999999998 <= Approx( 1.22999999999999998 )
 # Less-than inequalities with different epsilons
-ok {test-number} - !(d <= Approx( 1.22 )) for: !(1.23 <= Approx( 1.22 ))
+ok {test-number} - !(d <= Approx( 1.22 )) for: !(1.22999999999999998 <= Approx( 1.21999999999999997 ))
 # Less-than inequalities with different epsilons
-ok {test-number} - d <= Approx( 1.22 ).epsilon(0.1) for: 1.23 <= Approx( 1.22 )
+ok {test-number} - d <= Approx( 1.22 ).epsilon(0.1) for: 1.22999999999999998 <= Approx( 1.21999999999999997 )
 # ManuallyRegistered
 ok {test-number} - with 1 message: 'was called'
 # Matchers can be (AllOf) composed with the && operator
@@ -2041,11 +2061,11 @@ not ok {test-number} - data.int_seven >= 8 for: 7 >= 8
 # Ordering comparison checks that should fail
 not ok {test-number} - data.int_seven <= 6 for: 7 <= 6
 # Ordering comparison checks that should fail
-not ok {test-number} - data.float_nine_point_one < 9 for: 9.1f < 9
+not ok {test-number} - data.float_nine_point_one < 9 for: 9.100000381f < 9
 # Ordering comparison checks that should fail
-not ok {test-number} - data.float_nine_point_one > 10 for: 9.1f > 10
+not ok {test-number} - data.float_nine_point_one > 10 for: 9.100000381f > 10
 # Ordering comparison checks that should fail
-not ok {test-number} - data.float_nine_point_one > 9.2 for: 9.1f > 9.2
+not ok {test-number} - data.float_nine_point_one > 9.2 for: 9.100000381f > 9.19999999999999929
 # Ordering comparison checks that should fail
 not ok {test-number} - data.str_hello > "hello" for: "hello" > "hello"
 # Ordering comparison checks that should fail
@@ -2079,11 +2099,11 @@ ok {test-number} - data.int_seven <= 7 for: 7 <= 7
 # Ordering comparison checks that should succeed
 ok {test-number} - data.int_seven <= 8 for: 7 <= 8
 # Ordering comparison checks that should succeed
-ok {test-number} - data.float_nine_point_one > 9 for: 9.1f > 9
+ok {test-number} - data.float_nine_point_one > 9 for: 9.100000381f > 9
 # Ordering comparison checks that should succeed
-ok {test-number} - data.float_nine_point_one < 10 for: 9.1f < 10
+ok {test-number} - data.float_nine_point_one < 10 for: 9.100000381f < 10
 # Ordering comparison checks that should succeed
-ok {test-number} - data.float_nine_point_one < 9.2 for: 9.1f < 9.2
+ok {test-number} - data.float_nine_point_one < 9.2 for: 9.100000381f < 9.19999999999999929
 # Ordering comparison checks that should succeed
 ok {test-number} - data.str_hello <= "hello" for: "hello" <= "hello"
 # Ordering comparison checks that should succeed
@@ -2419,7 +2439,7 @@ ok {test-number} - config.benchmarkResamples == 20000 for: 20000 (0x<hex digits>
 # Process can be configured on command line
 ok {test-number} - cli.parse({ "test", "--benchmark-confidence-interval=0.99" }) for: {?}
 # Process can be configured on command line
-ok {test-number} - config.benchmarkConfidenceInterval == Catch::Approx(0.99) for: 0.99 == Approx( 0.99 )
+ok {test-number} - config.benchmarkConfidenceInterval == Catch::Approx(0.99) for: 0.98999999999999999 == Approx( 0.98999999999999999 )
 # Process can be configured on command line
 ok {test-number} - cli.parse({ "test", "--benchmark-no-analysis" }) for: {?}
 # Process can be configured on command line
@@ -2600,21 +2620,21 @@ A string sent directly to stdout
 A string sent directly to stderr
 A string sent to stderr via clog
 # Some simple comparisons between doubles
-ok {test-number} - d == Approx( 1.23 ) for: 1.23 == Approx( 1.23 )
+ok {test-number} - d == Approx( 1.23 ) for: 1.22999999999999998 == Approx( 1.22999999999999998 )
 # Some simple comparisons between doubles
-ok {test-number} - d != Approx( 1.22 ) for: 1.23 != Approx( 1.22 )
+ok {test-number} - d != Approx( 1.22 ) for: 1.22999999999999998 != Approx( 1.21999999999999997 )
 # Some simple comparisons between doubles
-ok {test-number} - d != Approx( 1.24 ) for: 1.23 != Approx( 1.24 )
+ok {test-number} - d != Approx( 1.24 ) for: 1.22999999999999998 != Approx( 1.23999999999999999 )
 # Some simple comparisons between doubles
-ok {test-number} - d == 1.23_a for: 1.23 == Approx( 1.23 )
+ok {test-number} - d == 1.23_a for: 1.22999999999999998 == Approx( 1.22999999999999998 )
 # Some simple comparisons between doubles
-ok {test-number} - d != 1.22_a for: 1.23 != Approx( 1.22 )
+ok {test-number} - d != 1.22_a for: 1.22999999999999998 != Approx( 1.21999999999999997 )
 # Some simple comparisons between doubles
-ok {test-number} - Approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23
+ok {test-number} - Approx( d ) == 1.23 for: Approx( 1.22999999999999998 ) == 1.22999999999999998
 # Some simple comparisons between doubles
-ok {test-number} - Approx( d ) != 1.22 for: Approx( 1.23 ) != 1.22
+ok {test-number} - Approx( d ) != 1.22 for: Approx( 1.22999999999999998 ) != 1.21999999999999997
 # Some simple comparisons between doubles
-ok {test-number} - Approx( d ) != 1.24 for: Approx( 1.23 ) != 1.24
+ok {test-number} - Approx( d ) != 1.24 for: Approx( 1.22999999999999998 ) != 1.23999999999999999
 Message from section one
 Message from section two
 # StartsWith string matcher
@@ -3326,7 +3346,7 @@ ok {test-number} - vector_a, RangeEquals( array_a_plus_1, close_enough ) for: {
 # Type conversions of RangeEquals and similar
 ok {test-number} - vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
 # Unexpected exceptions can be translated
-not ok {test-number} - unexpected exception with message: '3.14'
+not ok {test-number} - unexpected exception with message: '3.14000000000000012'
 # Upcasting special member functions
 ok {test-number} - bptr->i == 3 for: 3 == 3
 # Upcasting special member functions
@@ -3618,21 +3638,21 @@ ok {test-number} - unrelated::ADL_size{}, SizeIs(12) for: {?} has size == 12
 # Usage of the SizeIs range matcher
 ok {test-number} - has_size{}, SizeIs(13) for: {?} has size == 13
 # Use a custom approx
-ok {test-number} - d == approx( 1.23 ) for: 1.23 == Approx( 1.23 )
+ok {test-number} - d == approx( 1.23 ) for: 1.22999999999999998 == Approx( 1.22999999999999998 )
 # Use a custom approx
-ok {test-number} - d == approx( 1.22 ) for: 1.23 == Approx( 1.22 )
+ok {test-number} - d == approx( 1.22 ) for: 1.22999999999999998 == Approx( 1.21999999999999997 )
 # Use a custom approx
-ok {test-number} - d == approx( 1.24 ) for: 1.23 == Approx( 1.24 )
+ok {test-number} - d == approx( 1.24 ) for: 1.22999999999999998 == Approx( 1.23999999999999999 )
 # Use a custom approx
-ok {test-number} - d != approx( 1.25 ) for: 1.23 != Approx( 1.25 )
+ok {test-number} - d != approx( 1.25 ) for: 1.22999999999999998 != Approx( 1.25 )
 # Use a custom approx
-ok {test-number} - approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23
+ok {test-number} - approx( d ) == 1.23 for: Approx( 1.22999999999999998 ) == 1.22999999999999998
 # Use a custom approx
-ok {test-number} - approx( d ) == 1.22 for: Approx( 1.23 ) == 1.22
+ok {test-number} - approx( d ) == 1.22 for: Approx( 1.22999999999999998 ) == 1.21999999999999997
 # Use a custom approx
-ok {test-number} - approx( d ) == 1.24 for: Approx( 1.23 ) == 1.24
+ok {test-number} - approx( d ) == 1.24 for: Approx( 1.22999999999999998 ) == 1.23999999999999999
 # Use a custom approx
-ok {test-number} - approx( d ) != 1.25 for: Approx( 1.23 ) != 1.25
+ok {test-number} - approx( d ) != 1.25 for: Approx( 1.22999999999999998 ) != 1.25
 # Variadic macros
 ok {test-number} - with 1 message: 'no assertions'
 # Vector Approx matcher
@@ -3958,11 +3978,11 @@ ok {test-number} -  # SKIP 'skipping because answer = 43'
 # empty tags are not allowed
 ok {test-number} - Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
 # erfc_inv
-ok {test-number} - erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.0920368762 == Approx( -0.0920368762 )
+ok {test-number} - erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.09203687623843014 == Approx( -0.09203687623843015 )
 # erfc_inv
-ok {test-number} - erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.0598029112 == Approx( -0.0598029112 )
+ok {test-number} - erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.05980291115763361 == Approx( -0.05980291115763361 )
 # erfc_inv
-ok {test-number} - erfc_inv(0.050000) == Approx(1.38590382434967796) for: 1.3859038243 == Approx( 1.3859038243 )
+ok {test-number} - erfc_inv(0.050000) == Approx(1.38590382434967796) for: 1.38590382434967774 == Approx( 1.38590382434967796 )
 # estimate_clock_resolution
 ok {test-number} - res.mean.count() == rate for: 2000.0 == 2000 (0x<hex digits>)
 # estimate_clock_resolution
@@ -4107,22 +4127,12 @@ ok {test-number} -  # SKIP
 ok {test-number} - s == "7" for: "7" == "7"
 # non-copyable objects
 ok {test-number} - ti == typeid(int) for: {?} == {?}
-# normal_cdf
-ok {test-number} - normal_cdf(0.000000) == Approx(0.50000000000000000) for: 0.5 == Approx( 0.5 )
-# normal_cdf
-ok {test-number} - normal_cdf(1.000000) == Approx(0.84134474606854293) for: 0.8413447461 == Approx( 0.8413447461 )
-# normal_cdf
-ok {test-number} - normal_cdf(-1.000000) == Approx(0.15865525393145705) for: 0.1586552539 == Approx( 0.1586552539 )
-# normal_cdf
-ok {test-number} - normal_cdf(2.809729) == Approx(0.99752083845315409) for: 0.9975208385 == Approx( 0.9975208385 )
-# normal_cdf
-ok {test-number} - normal_cdf(-1.352570) == Approx(0.08809652095066035) for: 0.088096521 == Approx( 0.088096521 )
 # normal_quantile
-ok {test-number} - normal_quantile(0.551780) == Approx(0.13015979861484198) for: 0.1301597986 == Approx( 0.1301597986 )
+ok {test-number} - normal_quantile(0.551780) == Approx(0.13015979861484198) for: 0.13015979861484195 == Approx( 0.13015979861484198 )
 # normal_quantile
-ok {test-number} - normal_quantile(0.533700) == Approx(0.08457408802851875) for: 0.084574088 == Approx( 0.084574088 )
+ok {test-number} - normal_quantile(0.533700) == Approx(0.08457408802851875) for: 0.08457408802851875 == Approx( 0.08457408802851875 )
 # normal_quantile
-ok {test-number} - normal_quantile(0.025000) == Approx(-1.95996398454005449) for: -1.9599639845 == Approx( -1.9599639845 )
+ok {test-number} - normal_quantile(0.025000) == Approx(-1.95996398454005449) for: -1.95996398454005405 == Approx( -1.95996398454005449 )
 # not allowed
 ok {test-number} -
 # not prints unscoped info from previous failures
@@ -4406,15 +4416,15 @@ ok {test-number} - "{ }" == ::Catch::Detail::stringify(type{}) for: "{ }" == "{
 # tuple<>
 ok {test-number} - "{ }" == ::Catch::Detail::stringify(value) for: "{ }" == "{ }"
 # tuple<float,int>
-ok {test-number} - "1.2f" == ::Catch::Detail::stringify(float(1.2)) for: "1.2f" == "1.2f"
+ok {test-number} - "1.5f" == ::Catch::Detail::stringify(float(1.5)) for: "1.5f" == "1.5f"
 # tuple<float,int>
-ok {test-number} - "{ 1.2f, 0 }" == ::Catch::Detail::stringify(type{1.2f,0}) for: "{ 1.2f, 0 }" == "{ 1.2f, 0 }"
+ok {test-number} - "{ 1.5f, 0 }" == ::Catch::Detail::stringify(type{1.5f,0}) for: "{ 1.5f, 0 }" == "{ 1.5f, 0 }"
 # tuple<int>
 ok {test-number} - "{ 0 }" == ::Catch::Detail::stringify(type{0}) for: "{ 0 }" == "{ 0 }"
 # tuple<string,string>
 ok {test-number} - "{ \"hello\", \"world\" }" == ::Catch::Detail::stringify(type{"hello","world"}) for: "{ "hello", "world" }" == "{ "hello", "world" }"
 # tuple<tuple<int>,tuple<>,float>
-ok {test-number} - "{ { 42 }, { }, 1.2f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.2f }" == "{ { 42 }, { }, 1.2f }"
+ok {test-number} - "{ { 42 }, { }, 1.5f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.5f }" == "{ { 42 }, { }, 1.5f }"
 # uniform samples
 ok {test-number} - e.point == 23 for: 23.0 == 23
 # uniform samples
@@ -4422,7 +4432,7 @@ ok {test-number} - e.upper_bound == 23 for: 23.0 == 23
 # uniform samples
 ok {test-number} - e.lower_bound == 23 for: 23.0 == 23
 # uniform samples
-ok {test-number} - e.confidence_interval == 0.95 for: 0.95 == 0.95
+ok {test-number} - e.confidence_interval == 0.95 for: 0.94999999999999996 == 0.94999999999999996
 # uniform_integer_distribution can return the bounds
 ok {test-number} - dist.a() == -10 for: -10 == -10
 # uniform_integer_distribution can return the bounds
@@ -4549,5 +4559,5 @@ ok {test-number} - q3 == 23. for: 23.0 == 23.0
 ok {test-number} -
 # xmlentitycheck
 ok {test-number} -
-1..2272
+1..2277
 

tests/SelfTest/Baselines/tap.sw.multi.approved.txt

@@ -476,6 +476,14 @@ ok {test-number} - Nttp_Fixture<V>::value > 0 for: 6 > 0
 not ok {test-number} - m_a == 2 for: 1 == 2
 # A TEST_CASE_METHOD based test run that succeeds
 ok {test-number} - m_a == 1 for: 1 == 1
+# A TEST_CASE_PERSISTENT_FIXTURE based test run that fails
+ok {test-number} - m_a++ == 0 for: 0 == 0
+# A TEST_CASE_PERSISTENT_FIXTURE based test run that fails
+not ok {test-number} - m_a == 0 for: 1 == 0
+# A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds
+ok {test-number} - m_a++ == 0 for: 0 == 0
+# A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds
+ok {test-number} - m_a == 1 for: 1 == 1
 # A Template product test case - Foo<float>
 ok {test-number} - x.size() == 0 for: 0 == 0
 # A Template product test case - Foo<int>
@@ -493,17 +501,17 @@ ok {test-number} - x.size() > 0 for: 42 > 0
 # A Template product test case with array signature - std::array<int, 9>
 ok {test-number} - x.size() > 0 for: 9 > 0
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - d == 1.23_a for: 1.23 == Approx( 1.23 )
+ok {test-number} - d == 1.23_a for: 1.22999999999999998 == Approx( 1.22999999999999998 )
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - d != 1.22_a for: 1.23 != Approx( 1.22 )
+ok {test-number} - d != 1.22_a for: 1.22999999999999998 != Approx( 1.21999999999999997 )
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - -d == -1.23_a for: -1.23 == Approx( -1.23 )
+ok {test-number} - -d == -1.23_a for: -1.22999999999999998 == Approx( -1.22999999999999998 )
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - d == 1.2_a .epsilon(.1) for: 1.23 == Approx( 1.2 )
+ok {test-number} - d == 1.2_a .epsilon(.1) for: 1.22999999999999998 == Approx( 1.19999999999999996 )
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - d != 1.2_a .epsilon(.001) for: 1.23 != Approx( 1.2 )
+ok {test-number} - d != 1.2_a .epsilon(.001) for: 1.22999999999999998 != Approx( 1.19999999999999996 )
 # A comparison that uses literals instead of the normal constructor
-ok {test-number} - d == 1_a .epsilon(.3) for: 1.23 == Approx( 1.0 )
+ok {test-number} - d == 1_a .epsilon(.3) for: 1.22999999999999998 == Approx( 1.0 )
 # A couple of nested sections followed by a failure
 ok {test-number} - with 1 message: 'that's not flying - that's failing in style'
 # A couple of nested sections followed by a failure
@@ -521,9 +529,9 @@ ok {test-number} - 104.0 == Approx(100.0).margin(4) for: 104.0 == Approx( 100.0
 # Absolute margin
 ok {test-number} - 104.0 != Approx(100.0).margin(3) for: 104.0 != Approx( 100.0 )
 # Absolute margin
-ok {test-number} - 100.3 != Approx(100.0) for: 100.3 != Approx( 100.0 )
+ok {test-number} - 100.3 != Approx(100.0) for: 100.29999999999999716 != Approx( 100.0 )
 # Absolute margin
-ok {test-number} - 100.3 == Approx(100.0).margin(0.5) for: 100.3 == Approx( 100.0 )
+ok {test-number} - 100.3 == Approx(100.0).margin(0.5) for: 100.29999999999999716 == Approx( 100.0 )
 # An expression with side-effects should only be evaluated once
 ok {test-number} - i++ == 7 for: 7 == 7
 # An expression with side-effects should only be evaluated once
@@ -559,15 +567,15 @@ ok {test-number} - 245.0f == Approx(245.25f).margin(0.25f) for: 245.0f == Approx
 # Approx with exactly-representable margin
 ok {test-number} - 245.5f == Approx(245.25f).margin(0.25f) for: 245.5f == Approx( 245.25 )
 # Approximate PI
-ok {test-number} - divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) for: 3.1428571429 == Approx( 3.141 )
+ok {test-number} - divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) for: 3.14285714285714279 == Approx( 3.14100000000000001 )
 # Approximate PI
-ok {test-number} - divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) for: 3.1428571429 != Approx( 3.141 )
+ok {test-number} - divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) for: 3.14285714285714279 != Approx( 3.14100000000000001 )
 # Approximate comparisons with different epsilons
-ok {test-number} - d != Approx( 1.231 ) for: 1.23 != Approx( 1.231 )
+ok {test-number} - d != Approx( 1.231 ) for: 1.22999999999999998 != Approx( 1.23100000000000009 )
 # Approximate comparisons with different epsilons
-ok {test-number} - d == Approx( 1.231 ).epsilon( 0.1 ) for: 1.23 == Approx( 1.231 )
+ok {test-number} - d == Approx( 1.231 ).epsilon( 0.1 ) for: 1.22999999999999998 == Approx( 1.23100000000000009 )
 # Approximate comparisons with floats
-ok {test-number} - 1.23f == Approx( 1.23f ) for: 1.23f == Approx( 1.2300000191 )
+ok {test-number} - 1.23f == Approx( 1.23f ) for: 1.230000019f == Approx( 1.23000001907348633 )
 # Approximate comparisons with floats
 ok {test-number} - 0.0f == Approx( 0.0f ) for: 0.0f == Approx( 0.0 )
 # Approximate comparisons with ints
@@ -581,9 +589,9 @@ ok {test-number} - 0 == Approx( dZero) for: 0 == Approx( 0.0 )
 # Approximate comparisons with mixed numeric types
 ok {test-number} - 0 == Approx( dSmall ).margin( 0.001 ) for: 0 == Approx( 0.00001 )
 # Approximate comparisons with mixed numeric types
-ok {test-number} - 1.234f == Approx( dMedium ) for: 1.234f == Approx( 1.234 )
+ok {test-number} - 1.234f == Approx( dMedium ) for: 1.233999968f == Approx( 1.23399999999999999 )
 # Approximate comparisons with mixed numeric types
-ok {test-number} - dMedium == Approx( 1.234f ) for: 1.234 == Approx( 1.2339999676 )
+ok {test-number} - dMedium == Approx( 1.234f ) for: 1.23399999999999999 == Approx( 1.23399996757507324 )
 # Arbitrary predicate matcher
 ok {test-number} - 1, Predicate<int>( alwaysTrue, "always true" ) for: 1 matches predicate: "always true"
 # Arbitrary predicate matcher
@@ -714,6 +722,18 @@ ok {test-number} - ::Catch::Detail::stringify( '\0' ) == "0" for: "0" == "0"
 ok {test-number} - ::Catch::Detail::stringify( static_cast<char>(2) ) == "2" for: "2" == "2"
 # Character pretty printing
 ok {test-number} - ::Catch::Detail::stringify( static_cast<char>(5) ) == "5" for: "5" == "5"
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - name.empty() for: true
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - result for: {?}
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - result.type() == Catch::Clara::Detail::ResultType::Ok for: 0 == 0
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - parsed.type() == Catch::Clara::ParseResultType::NoMatch for: 1 == 1
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - parsed.remainingTokens().count() == 2 for: 2 == 2
+# Clara::Arg does not crash on incomplete input
+ok {test-number} - name.empty() for: true
 # Clara::Arg supports single-arg parse the way Opt does
 ok {test-number} - name.empty() for: true
 # Clara::Arg supports single-arg parse the way Opt does
@@ -965,7 +985,7 @@ not ok {test-number} - unexpected exception with message: 'custom exception - no
 # Custom std-exceptions can be custom translated
 not ok {test-number} - unexpected exception with message: 'custom std exception'
 # Default scale is invisible to comparison
-ok {test-number} - 101.000001 != Approx(100).epsilon(0.01) for: 101.000001 != Approx( 100.0 )
+ok {test-number} - 101.000001 != Approx(100).epsilon(0.01) for: 101.00000099999999748 != Approx( 100.0 )
 # Default scale is invisible to comparison
 ok {test-number} - std::pow(10, -5) != Approx(std::pow(10, -7)) for: 0.00001 != Approx( 0.0000001 )
 # Directly creating an EnumInfo
@@ -997,7 +1017,7 @@ ok {test-number} - stringify( Bikeshed::Colours::Red ) == "Red" for: "Red" == "R
 # Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( Bikeshed::Colours::Blue ) == "Blue" for: "Blue" == "Blue"
 # Epsilon only applies to Approx's value
-ok {test-number} - 101.01 != Approx(100).epsilon(0.01) for: 101.01 != Approx( 100.0 )
+ok {test-number} - 101.01 != Approx(100).epsilon(0.01) for: 101.01000000000000512 != Approx( 100.0 )
 # Equality checks that should fail
 not ok {test-number} - data.int_seven == 6 for: 7 == 6
 # Equality checks that should fail
@@ -1005,15 +1025,15 @@ not ok {test-number} - data.int_seven == 8 for: 7 == 8
 # Equality checks that should fail
 not ok {test-number} - data.int_seven == 0 for: 7 == 0
 # Equality checks that should fail
-not ok {test-number} - data.float_nine_point_one == Approx( 9.11f ) for: 9.1f == Approx( 9.1099996567 )
+not ok {test-number} - data.float_nine_point_one == Approx( 9.11f ) for: 9.100000381f == Approx( 9.10999965667724609 )
 # Equality checks that should fail
-not ok {test-number} - data.float_nine_point_one == Approx( 9.0f ) for: 9.1f == Approx( 9.0 )
+not ok {test-number} - data.float_nine_point_one == Approx( 9.0f ) for: 9.100000381f == Approx( 9.0 )
 # Equality checks that should fail
-not ok {test-number} - data.float_nine_point_one == Approx( 1 ) for: 9.1f == Approx( 1.0 )
+not ok {test-number} - data.float_nine_point_one == Approx( 1 ) for: 9.100000381f == Approx( 1.0 )
 # Equality checks that should fail
-not ok {test-number} - data.float_nine_point_one == Approx( 0 ) for: 9.1f == Approx( 0.0 )
+not ok {test-number} - data.float_nine_point_one == Approx( 0 ) for: 9.100000381f == Approx( 0.0 )
 # Equality checks that should fail
-not ok {test-number} - data.double_pi == Approx( 3.1415 ) for: 3.1415926535 == Approx( 3.1415 )
+not ok {test-number} - data.double_pi == Approx( 3.1415 ) for: 3.14159265350000005 == Approx( 3.14150000000000018 )
 # Equality checks that should fail
 not ok {test-number} - data.str_hello == "goodbye" for: "hello" == "goodbye"
 # Equality checks that should fail
@@ -1023,13 +1043,13 @@ not ok {test-number} - data.str_hello == "hello1" for: "hello" == "hello1"
 # Equality checks that should fail
 not ok {test-number} - data.str_hello.size() == 6 for: 5 == 6
 # Equality checks that should fail
-not ok {test-number} - x == Approx( 1.301 ) for: 1.3 == Approx( 1.301 )
+not ok {test-number} - x == Approx( 1.301 ) for: 1.30000000000000027 == Approx( 1.30099999999999993 )
 # Equality checks that should succeed
 ok {test-number} - data.int_seven == 7 for: 7 == 7
 # Equality checks that should succeed
-ok {test-number} - data.float_nine_point_one == Approx( 9.1f ) for: 9.1f == Approx( 9.1000003815 )
+ok {test-number} - data.float_nine_point_one == Approx( 9.1f ) for: 9.100000381f == Approx( 9.10000038146972656 )
 # Equality checks that should succeed
-ok {test-number} - data.double_pi == Approx( 3.1415926535 ) for: 3.1415926535 == Approx( 3.1415926535 )
+ok {test-number} - data.double_pi == Approx( 3.1415926535 ) for: 3.14159265350000005 == Approx( 3.14159265350000005 )
 # Equality checks that should succeed
 ok {test-number} - data.str_hello == "hello" for: "hello" == "hello"
 # Equality checks that should succeed
@@ -1037,7 +1057,7 @@ ok {test-number} - "hello" == data.str_hello for: "hello" == "hello"
 # Equality checks that should succeed
 ok {test-number} - data.str_hello.size() == 5 for: 5 == 5
 # Equality checks that should succeed
-ok {test-number} - x == Approx( 1.3 ) for: 1.3 == Approx( 1.3 )
+ok {test-number} - x == Approx( 1.3 ) for: 1.30000000000000027 == Approx( 1.30000000000000004 )
 # Equals
 ok {test-number} - testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) for: "this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring"
 # Equals
@@ -1123,23 +1143,23 @@ ok {test-number} - Factorial(10) == 3628800 for: 3628800 (0x<hex digits>) == 362
 # Filter generator throws exception for empty generator
 ok {test-number} - filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
 # Floating point matchers: double
-ok {test-number} - 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.1 are within 10% of each other
+ok {test-number} - 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.09999999999999964 are within 10% of each other
 # Floating point matchers: double
-ok {test-number} - 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.2 are within 10% of each other
+ok {test-number} - 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.19999999999999929 are within 10% of each other
 # Floating point matchers: double
-ok {test-number} - 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0 are within 99% of each other
+ok {test-number} - 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0.0 are within 99% of each other
 # Floating point matchers: double
-ok {test-number} - -0., WithinRel( 0. ) for: -0.0 and 0 are within 2.22045e-12% of each other
+ok {test-number} - -0., WithinRel( 0. ) for: -0.0 and 0.0 are within 2.22045e-12% of each other
 # Floating point matchers: double
-ok {test-number} - v1, WithinRel( v2 ) for: 0.0 and 2.22507e-308 are within 2.22045e-12% of each other
+ok {test-number} - v1, WithinRel( v2 ) for: 0.0 and 0.0 are within 2.22045e-12% of each other
 # Floating point matchers: double
 ok {test-number} - 1., WithinAbs( 1., 0 ) for: 1.0 is within 0.0 of 1.0
 # Floating point matchers: double
 ok {test-number} - 0., WithinAbs( 1., 1 ) for: 0.0 is within 1.0 of 1.0
 # Floating point matchers: double
-ok {test-number} - 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0
+ok {test-number} - 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.98999999999999999 of 1.0
 # Floating point matchers: double
-ok {test-number} - 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0
+ok {test-number} - 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.98999999999999999 of 1.0
 # Floating point matchers: double
 ok {test-number} - 11., !WithinAbs( 10., 0.5 ) for: 11.0 not is within 0.5 of 10.0
 # Floating point matchers: double
@@ -1147,11 +1167,11 @@ ok {test-number} - 10., !WithinAbs( 11., 0.5 ) for: 10.0 not is within 0.5 of 11
 # Floating point matchers: double
 ok {test-number} - -10., WithinAbs( -10., 0.5 ) for: -10.0 is within 0.5 of -10.0
 # Floating point matchers: double
-ok {test-number} - -10., WithinAbs( -9.6, 0.5 ) for: -10.0 is within 0.5 of -9.6
+ok {test-number} - -10., WithinAbs( -9.6, 0.5 ) for: -10.0 is within 0.5 of -9.59999999999999964
 # Floating point matchers: double
 ok {test-number} - 1., WithinULP( 1., 0 ) for: 1.0 is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00])
 # Floating point matchers: double
-ok {test-number} - nextafter( 1., 2. ), WithinULP( 1., 1 ) for: 1.0 is within 1 ULPs of 1.0000000000000000e+00 ([9.9999999999999989e-01, 1.0000000000000002e+00])
+ok {test-number} - nextafter( 1., 2. ), WithinULP( 1., 1 ) for: 1.00000000000000022 is within 1 ULPs of 1.0000000000000000e+00 ([9.9999999999999989e-01, 1.0000000000000002e+00])
 # Floating point matchers: double
 ok {test-number} - 0., WithinULP( nextafter( 0., 1. ), 1 ) for: 0.0 is within 1 ULPs of 4.9406564584124654e-324 ([0.0000000000000000e+00, 9.8813129168249309e-324])
 # Floating point matchers: double
@@ -1167,7 +1187,7 @@ ok {test-number} - 1., WithinAbs( 1., 0.5 ) || WithinULP( 2., 1 ) for: 1.0 ( is
 # Floating point matchers: double
 ok {test-number} - 1., WithinAbs( 2., 0.5 ) || WithinULP( 1., 0 ) for: 1.0 ( is within 0.5 of 2.0 or is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00]) )
 # Floating point matchers: double
-ok {test-number} - 0.0001, WithinAbs( 0., 0.001 ) || WithinRel( 0., 0.1 ) for: 0.0001 ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+ok {test-number} - 0.0001, WithinAbs( 0., 0.001 ) || WithinRel( 0., 0.1 ) for: 0.0001 ( is within 0.001 of 0.0 or and 0.0 are within 10% of each other )
 # Floating point matchers: double
 ok {test-number} - WithinAbs( 1., 0. )
 # Floating point matchers: double
@@ -1183,23 +1203,23 @@ ok {test-number} - WithinRel( 1., 1. ), std::domain_error
 # Floating point matchers: double
 ok {test-number} - 1., !IsNaN() for: 1.0 not is NaN
 # Floating point matchers: float
-ok {test-number} - 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.1 are within 10% of each other
+ok {test-number} - 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.10000038146972656 are within 10% of each other
 # Floating point matchers: float
-ok {test-number} - 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.2 are within 10% of each other
+ok {test-number} - 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.19999980926513672 are within 10% of each other
 # Floating point matchers: float
-ok {test-number} - 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0 are within 99% of each other
+ok {test-number} - 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0.0 are within 99% of each other
 # Floating point matchers: float
-ok {test-number} - -0.f, WithinRel( 0.f ) for: -0.0f and 0 are within 0.00119209% of each other
+ok {test-number} - -0.f, WithinRel( 0.f ) for: -0.0f and 0.0 are within 0.00119209% of each other
 # Floating point matchers: float
-ok {test-number} - v1, WithinRel( v2 ) for: 0.0f and 1.17549e-38 are within 0.00119209% of each other
+ok {test-number} - v1, WithinRel( v2 ) for: 0.0f and 0.0 are within 0.00119209% of each other
 # Floating point matchers: float
 ok {test-number} - 1.f, WithinAbs( 1.f, 0 ) for: 1.0f is within 0.0 of 1.0
 # Floating point matchers: float
 ok {test-number} - 0.f, WithinAbs( 1.f, 1 ) for: 0.0f is within 1.0 of 1.0
 # Floating point matchers: float
-ok {test-number} - 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0
+ok {test-number} - 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.99000000953674316 of 1.0
 # Floating point matchers: float
-ok {test-number} - 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0
+ok {test-number} - 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.99000000953674316 of 1.0
 # Floating point matchers: float
 ok {test-number} - 0.f, WithinAbs( -0.f, 0 ) for: 0.0f is within 0.0 of -0.0
 # Floating point matchers: float
@@ -1209,13 +1229,13 @@ ok {test-number} - 10.f, !WithinAbs( 11.f, 0.5f ) for: 10.0f not is within 0.5 o
 # Floating point matchers: float
 ok {test-number} - -10.f, WithinAbs( -10.f, 0.5f ) for: -10.0f is within 0.5 of -10.0
 # Floating point matchers: float
-ok {test-number} - -10.f, WithinAbs( -9.6f, 0.5f ) for: -10.0f is within 0.5 of -9.6000003815
+ok {test-number} - -10.f, WithinAbs( -9.6f, 0.5f ) for: -10.0f is within 0.5 of -9.60000038146972656
 # Floating point matchers: float
 ok {test-number} - 1.f, WithinULP( 1.f, 0 ) for: 1.0f is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00])
 # Floating point matchers: float
 ok {test-number} - -1.f, WithinULP( -1.f, 0 ) for: -1.0f is within 0 ULPs of -1.00000000e+00f ([-1.00000000e+00, -1.00000000e+00])
 # Floating point matchers: float
-ok {test-number} - nextafter( 1.f, 2.f ), WithinULP( 1.f, 1 ) for: 1.0f is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00])
+ok {test-number} - nextafter( 1.f, 2.f ), WithinULP( 1.f, 1 ) for: 1.000000119f is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00])
 # Floating point matchers: float
 ok {test-number} - 0.f, WithinULP( nextafter( 0.f, 1.f ), 1 ) for: 0.0f is within 1 ULPs of 1.40129846e-45f ([0.00000000e+00, 2.80259693e-45])
 # Floating point matchers: float
@@ -1231,7 +1251,7 @@ ok {test-number} - 1.f, WithinAbs( 1.f, 0.5 ) || WithinULP( 1.f, 1 ) for: 1.0f (
 # Floating point matchers: float
 ok {test-number} - 1.f, WithinAbs( 2.f, 0.5 ) || WithinULP( 1.f, 0 ) for: 1.0f ( is within 0.5 of 2.0 or is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00]) )
 # Floating point matchers: float
-ok {test-number} - 0.0001f, WithinAbs( 0.f, 0.001f ) || WithinRel( 0.f, 0.1f ) for: 0.0001f ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+ok {test-number} - 0.0001f, WithinAbs( 0.f, 0.001f ) || WithinRel( 0.f, 0.1f ) for: 0.0001f ( is within 0.00100000004749745 of 0.0 or and 0.0 are within 10% of each other )
 # Floating point matchers: float
 ok {test-number} - WithinAbs( 1.f, 0.f )
 # Floating point matchers: float
@@ -1591,83 +1611,83 @@ ok {test-number} - gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) wit
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.9 == Approx( -0.9 ) with 1 message: 'Current expected value is -0.9'
+ok {test-number} - gen.get() == Approx(expected) for: -0.90000000000000002 == Approx( -0.90000000000000002 ) with 1 message: 'Current expected value is -0.9'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.9'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.8 == Approx( -0.8 ) with 1 message: 'Current expected value is -0.8'
+ok {test-number} - gen.get() == Approx(expected) for: -0.80000000000000004 == Approx( -0.80000000000000004 ) with 1 message: 'Current expected value is -0.8'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.8'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+ok {test-number} - gen.get() == Approx(expected) for: -0.70000000000000007 == Approx( -0.70000000000000007 ) with 1 message: 'Current expected value is -0.7'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.7'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.6 == Approx( -0.6 ) with 1 message: 'Current expected value is -0.6'
+ok {test-number} - gen.get() == Approx(expected) for: -0.60000000000000009 == Approx( -0.60000000000000009 ) with 1 message: 'Current expected value is -0.6'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.6'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.5 == Approx( -0.5 ) with 1 message: 'Current expected value is -0.5'
+ok {test-number} - gen.get() == Approx(expected) for: -0.50000000000000011 == Approx( -0.50000000000000011 ) with 1 message: 'Current expected value is -0.5'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.5'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+ok {test-number} - gen.get() == Approx(expected) for: -0.40000000000000013 == Approx( -0.40000000000000013 ) with 1 message: 'Current expected value is -0.4'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.4'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.3 == Approx( -0.3 ) with 1 message: 'Current expected value is -0.3'
+ok {test-number} - gen.get() == Approx(expected) for: -0.30000000000000016 == Approx( -0.30000000000000016 ) with 1 message: 'Current expected value is -0.3'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.3'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.2 == Approx( -0.2 ) with 1 message: 'Current expected value is -0.2'
+ok {test-number} - gen.get() == Approx(expected) for: -0.20000000000000015 == Approx( -0.20000000000000015 ) with 1 message: 'Current expected value is -0.2'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.2'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+ok {test-number} - gen.get() == Approx(expected) for: -0.10000000000000014 == Approx( -0.10000000000000014 ) with 1 message: 'Current expected value is -0.1'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.0 == Approx( -0.0 ) with 1 message: 'Current expected value is -1.38778e-16'
+ok {test-number} - gen.get() == Approx(expected) for: -0.00000000000000014 == Approx( -0.00000000000000014 ) with 1 message: 'Current expected value is -1.38778e-16'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1.38778e-16'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.1 == Approx( 0.1 ) with 1 message: 'Current expected value is 0.1'
+ok {test-number} - gen.get() == Approx(expected) for: 0.09999999999999987 == Approx( 0.09999999999999987 ) with 1 message: 'Current expected value is 0.1'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+ok {test-number} - gen.get() == Approx(expected) for: 0.19999999999999987 == Approx( 0.19999999999999987 ) with 1 message: 'Current expected value is 0.2'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.2'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.3 == Approx( 0.3 ) with 1 message: 'Current expected value is 0.3'
+ok {test-number} - gen.get() == Approx(expected) for: 0.29999999999999988 == Approx( 0.29999999999999988 ) with 1 message: 'Current expected value is 0.3'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.3'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.4 == Approx( 0.4 ) with 1 message: 'Current expected value is 0.4'
+ok {test-number} - gen.get() == Approx(expected) for: 0.39999999999999991 == Approx( 0.39999999999999991 ) with 1 message: 'Current expected value is 0.4'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.4'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5'
+ok {test-number} - gen.get() == Approx(expected) for: 0.49999999999999989 == Approx( 0.49999999999999989 ) with 1 message: 'Current expected value is 0.5'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.5'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.6 == Approx( 0.6 ) with 1 message: 'Current expected value is 0.6'
+ok {test-number} - gen.get() == Approx(expected) for: 0.59999999999999987 == Approx( 0.59999999999999987 ) with 1 message: 'Current expected value is 0.6'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.6'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.7 == Approx( 0.7 ) with 1 message: 'Current expected value is 0.7'
+ok {test-number} - gen.get() == Approx(expected) for: 0.69999999999999984 == Approx( 0.69999999999999984 ) with 1 message: 'Current expected value is 0.7'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.7'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.8 == Approx( 0.8 ) with 1 message: 'Current expected value is 0.8'
+ok {test-number} - gen.get() == Approx(expected) for: 0.79999999999999982 == Approx( 0.79999999999999982 ) with 1 message: 'Current expected value is 0.8'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.8'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.9 == Approx( 0.9 ) with 1 message: 'Current expected value is 0.9'
+ok {test-number} - gen.get() == Approx(expected) for: 0.8999999999999998 == Approx( 0.8999999999999998 ) with 1 message: 'Current expected value is 0.9'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.9'
 # Generators internals
-ok {test-number} - gen.get() == Approx( rangeEnd ) for: 1.0 == Approx( 1.0 )
+ok {test-number} - gen.get() == Approx( rangeEnd ) for: 0.99999999999999978 == Approx( 1.0 )
 # Generators internals
 ok {test-number} - !(gen.next()) for: !false
 # Generators internals
@@ -1675,19 +1695,19 @@ ok {test-number} - gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) wit
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+ok {test-number} - gen.get() == Approx(expected) for: -0.69999999999999996 == Approx( -0.69999999999999996 ) with 1 message: 'Current expected value is -0.7'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.7'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+ok {test-number} - gen.get() == Approx(expected) for: -0.39999999999999997 == Approx( -0.39999999999999997 ) with 1 message: 'Current expected value is -0.4'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.4'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+ok {test-number} - gen.get() == Approx(expected) for: -0.09999999999999998 == Approx( -0.09999999999999998 ) with 1 message: 'Current expected value is -0.1'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+ok {test-number} - gen.get() == Approx(expected) for: 0.20000000000000001 == Approx( 0.20000000000000001 ) with 1 message: 'Current expected value is 0.2'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.2'
 # Generators internals
@@ -1701,19 +1721,19 @@ ok {test-number} - gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) wit
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+ok {test-number} - gen.get() == Approx(expected) for: -0.69999999999999996 == Approx( -0.69999999999999996 ) with 1 message: 'Current expected value is -0.7'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.7'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+ok {test-number} - gen.get() == Approx(expected) for: -0.39999999999999997 == Approx( -0.39999999999999997 ) with 1 message: 'Current expected value is -0.4'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.4'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+ok {test-number} - gen.get() == Approx(expected) for: -0.09999999999999998 == Approx( -0.09999999999999998 ) with 1 message: 'Current expected value is -0.1'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.1'
 # Generators internals
-ok {test-number} - gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+ok {test-number} - gen.get() == Approx(expected) for: 0.20000000000000001 == Approx( 0.20000000000000001 ) with 1 message: 'Current expected value is 0.2'
 # Generators internals
 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.2'
 # Generators internals
@@ -1775,13 +1795,13 @@ ok {test-number} - gen.get() == -7 for: -7 == -7
 # Generators internals
 ok {test-number} - !(gen.next()) for: !false
 # Greater-than inequalities with different epsilons
-ok {test-number} - d >= Approx( 1.22 ) for: 1.23 >= Approx( 1.22 )
+ok {test-number} - d >= Approx( 1.22 ) for: 1.22999999999999998 >= Approx( 1.21999999999999997 )
 # Greater-than inequalities with different epsilons
-ok {test-number} - d >= Approx( 1.23 ) for: 1.23 >= Approx( 1.23 )
+ok {test-number} - d >= Approx( 1.23 ) for: 1.22999999999999998 >= Approx( 1.22999999999999998 )
 # Greater-than inequalities with different epsilons
-ok {test-number} - !(d >= Approx( 1.24 )) for: !(1.23 >= Approx( 1.24 ))
+ok {test-number} - !(d >= Approx( 1.24 )) for: !(1.22999999999999998 >= Approx( 1.23999999999999999 ))
 # Greater-than inequalities with different epsilons
-ok {test-number} - d >= Approx( 1.24 ).epsilon(0.1) for: 1.23 >= Approx( 1.24 )
+ok {test-number} - d >= Approx( 1.24 ).epsilon(0.1) for: 1.22999999999999998 >= Approx( 1.23999999999999999 )
 # Hashers with different seed produce different hash with same test case
 ok {test-number} - h1( dummy ) != h2( dummy ) for: 3422778688 (0x<hex digits>) != 130711275 (0x<hex digits>)
 # Hashers with same seed produce same hash
@@ -1835,9 +1855,9 @@ not ok {test-number} - unexpected exception with message: 'Exception translation
 # Inequality checks that should fail
 not ok {test-number} - data.int_seven != 7 for: 7 != 7
 # Inequality checks that should fail
-not ok {test-number} - data.float_nine_point_one != Approx( 9.1f ) for: 9.1f != Approx( 9.1000003815 )
+not ok {test-number} - data.float_nine_point_one != Approx( 9.1f ) for: 9.100000381f != Approx( 9.10000038146972656 )
 # Inequality checks that should fail
-not ok {test-number} - data.double_pi != Approx( 3.1415926535 ) for: 3.1415926535 != Approx( 3.1415926535 )
+not ok {test-number} - data.double_pi != Approx( 3.1415926535 ) for: 3.14159265350000005 != Approx( 3.14159265350000005 )
 # Inequality checks that should fail
 not ok {test-number} - data.str_hello != "hello" for: "hello" != "hello"
 # Inequality checks that should fail
@@ -1847,15 +1867,15 @@ ok {test-number} - data.int_seven != 6 for: 7 != 6
 # Inequality checks that should succeed
 ok {test-number} - data.int_seven != 8 for: 7 != 8
 # Inequality checks that should succeed
-ok {test-number} - data.float_nine_point_one != Approx( 9.11f ) for: 9.1f != Approx( 9.1099996567 )
+ok {test-number} - data.float_nine_point_one != Approx( 9.11f ) for: 9.100000381f != Approx( 9.10999965667724609 )
 # Inequality checks that should succeed
-ok {test-number} - data.float_nine_point_one != Approx( 9.0f ) for: 9.1f != Approx( 9.0 )
+ok {test-number} - data.float_nine_point_one != Approx( 9.0f ) for: 9.100000381f != Approx( 9.0 )
 # Inequality checks that should succeed
-ok {test-number} - data.float_nine_point_one != Approx( 1 ) for: 9.1f != Approx( 1.0 )
+ok {test-number} - data.float_nine_point_one != Approx( 1 ) for: 9.100000381f != Approx( 1.0 )
 # Inequality checks that should succeed
-ok {test-number} - data.float_nine_point_one != Approx( 0 ) for: 9.1f != Approx( 0.0 )
+ok {test-number} - data.float_nine_point_one != Approx( 0 ) for: 9.100000381f != Approx( 0.0 )
 # Inequality checks that should succeed
-ok {test-number} - data.double_pi != Approx( 3.1415 ) for: 3.1415926535 != Approx( 3.1415 )
+ok {test-number} - data.double_pi != Approx( 3.1415 ) for: 3.14159265350000005 != Approx( 3.14150000000000018 )
 # Inequality checks that should succeed
 ok {test-number} - data.str_hello != "goodbye" for: "hello" != "goodbye"
 # Inequality checks that should succeed
@@ -1903,13 +1923,13 @@ ok {test-number} - sstream.str() == "\"\\\\/\\t\\r\\n\"" for: ""\\/\t\r\n"" == "
 # Lambdas in assertions
 ok {test-number} - []() { return true; }() for: true
 # Less-than inequalities with different epsilons
-ok {test-number} - d <= Approx( 1.24 ) for: 1.23 <= Approx( 1.24 )
+ok {test-number} - d <= Approx( 1.24 ) for: 1.22999999999999998 <= Approx( 1.23999999999999999 )
 # Less-than inequalities with different epsilons
-ok {test-number} - d <= Approx( 1.23 ) for: 1.23 <= Approx( 1.23 )
+ok {test-number} - d <= Approx( 1.23 ) for: 1.22999999999999998 <= Approx( 1.22999999999999998 )
 # Less-than inequalities with different epsilons
-ok {test-number} - !(d <= Approx( 1.22 )) for: !(1.23 <= Approx( 1.22 ))
+ok {test-number} - !(d <= Approx( 1.22 )) for: !(1.22999999999999998 <= Approx( 1.21999999999999997 ))
 # Less-than inequalities with different epsilons
-ok {test-number} - d <= Approx( 1.22 ).epsilon(0.1) for: 1.23 <= Approx( 1.22 )
+ok {test-number} - d <= Approx( 1.22 ).epsilon(0.1) for: 1.22999999999999998 <= Approx( 1.21999999999999997 )
 # ManuallyRegistered
 ok {test-number} - with 1 message: 'was called'
 # Matchers can be (AllOf) composed with the && operator
@@ -2039,11 +2059,11 @@ not ok {test-number} - data.int_seven >= 8 for: 7 >= 8
 # Ordering comparison checks that should fail
 not ok {test-number} - data.int_seven <= 6 for: 7 <= 6
 # Ordering comparison checks that should fail
-not ok {test-number} - data.float_nine_point_one < 9 for: 9.1f < 9
+not ok {test-number} - data.float_nine_point_one < 9 for: 9.100000381f < 9
 # Ordering comparison checks that should fail
-not ok {test-number} - data.float_nine_point_one > 10 for: 9.1f > 10
+not ok {test-number} - data.float_nine_point_one > 10 for: 9.100000381f > 10
 # Ordering comparison checks that should fail
-not ok {test-number} - data.float_nine_point_one > 9.2 for: 9.1f > 9.2
+not ok {test-number} - data.float_nine_point_one > 9.2 for: 9.100000381f > 9.19999999999999929
 # Ordering comparison checks that should fail
 not ok {test-number} - data.str_hello > "hello" for: "hello" > "hello"
 # Ordering comparison checks that should fail
@@ -2077,11 +2097,11 @@ ok {test-number} - data.int_seven <= 7 for: 7 <= 7
 # Ordering comparison checks that should succeed
 ok {test-number} - data.int_seven <= 8 for: 7 <= 8
 # Ordering comparison checks that should succeed
-ok {test-number} - data.float_nine_point_one > 9 for: 9.1f > 9
+ok {test-number} - data.float_nine_point_one > 9 for: 9.100000381f > 9
 # Ordering comparison checks that should succeed
-ok {test-number} - data.float_nine_point_one < 10 for: 9.1f < 10
+ok {test-number} - data.float_nine_point_one < 10 for: 9.100000381f < 10
 # Ordering comparison checks that should succeed
-ok {test-number} - data.float_nine_point_one < 9.2 for: 9.1f < 9.2
+ok {test-number} - data.float_nine_point_one < 9.2 for: 9.100000381f < 9.19999999999999929
 # Ordering comparison checks that should succeed
 ok {test-number} - data.str_hello <= "hello" for: "hello" <= "hello"
 # Ordering comparison checks that should succeed
@@ -2417,7 +2437,7 @@ ok {test-number} - config.benchmarkResamples == 20000 for: 20000 (0x<hex digits>
 # Process can be configured on command line
 ok {test-number} - cli.parse({ "test", "--benchmark-confidence-interval=0.99" }) for: {?}
 # Process can be configured on command line
-ok {test-number} - config.benchmarkConfidenceInterval == Catch::Approx(0.99) for: 0.99 == Approx( 0.99 )
+ok {test-number} - config.benchmarkConfidenceInterval == Catch::Approx(0.99) for: 0.98999999999999999 == Approx( 0.98999999999999999 )
 # Process can be configured on command line
 ok {test-number} - cli.parse({ "test", "--benchmark-no-analysis" }) for: {?}
 # Process can be configured on command line
@@ -2595,21 +2615,21 @@ ok {test-number} - v.capacity() >= 10 for: 10 >= 10
 # Scenario: Vector resizing affects size and capacity
 ok {test-number} - v.size() == 0 for: 0 == 0
 # Some simple comparisons between doubles
-ok {test-number} - d == Approx( 1.23 ) for: 1.23 == Approx( 1.23 )
+ok {test-number} - d == Approx( 1.23 ) for: 1.22999999999999998 == Approx( 1.22999999999999998 )
 # Some simple comparisons between doubles
-ok {test-number} - d != Approx( 1.22 ) for: 1.23 != Approx( 1.22 )
+ok {test-number} - d != Approx( 1.22 ) for: 1.22999999999999998 != Approx( 1.21999999999999997 )
 # Some simple comparisons between doubles
-ok {test-number} - d != Approx( 1.24 ) for: 1.23 != Approx( 1.24 )
+ok {test-number} - d != Approx( 1.24 ) for: 1.22999999999999998 != Approx( 1.23999999999999999 )
 # Some simple comparisons between doubles
-ok {test-number} - d == 1.23_a for: 1.23 == Approx( 1.23 )
+ok {test-number} - d == 1.23_a for: 1.22999999999999998 == Approx( 1.22999999999999998 )
 # Some simple comparisons between doubles
-ok {test-number} - d != 1.22_a for: 1.23 != Approx( 1.22 )
+ok {test-number} - d != 1.22_a for: 1.22999999999999998 != Approx( 1.21999999999999997 )
 # Some simple comparisons between doubles
-ok {test-number} - Approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23
+ok {test-number} - Approx( d ) == 1.23 for: Approx( 1.22999999999999998 ) == 1.22999999999999998
 # Some simple comparisons between doubles
-ok {test-number} - Approx( d ) != 1.22 for: Approx( 1.23 ) != 1.22
+ok {test-number} - Approx( d ) != 1.22 for: Approx( 1.22999999999999998 ) != 1.21999999999999997
 # Some simple comparisons between doubles
-ok {test-number} - Approx( d ) != 1.24 for: Approx( 1.23 ) != 1.24
+ok {test-number} - Approx( d ) != 1.24 for: Approx( 1.22999999999999998 ) != 1.23999999999999999
 # StartsWith string matcher
 not ok {test-number} - testStringForMatching(), StartsWith( "This String" ) for: "this string contains 'abc' as a substring" starts with: "This String"
 # StartsWith string matcher
@@ -3319,7 +3339,7 @@ ok {test-number} - vector_a, RangeEquals( array_a_plus_1, close_enough ) for: {
 # Type conversions of RangeEquals and similar
 ok {test-number} - vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
 # Unexpected exceptions can be translated
-not ok {test-number} - unexpected exception with message: '3.14'
+not ok {test-number} - unexpected exception with message: '3.14000000000000012'
 # Upcasting special member functions
 ok {test-number} - bptr->i == 3 for: 3 == 3
 # Upcasting special member functions
@@ -3611,21 +3631,21 @@ ok {test-number} - unrelated::ADL_size{}, SizeIs(12) for: {?} has size == 12
 # Usage of the SizeIs range matcher
 ok {test-number} - has_size{}, SizeIs(13) for: {?} has size == 13
 # Use a custom approx
-ok {test-number} - d == approx( 1.23 ) for: 1.23 == Approx( 1.23 )
+ok {test-number} - d == approx( 1.23 ) for: 1.22999999999999998 == Approx( 1.22999999999999998 )
 # Use a custom approx
-ok {test-number} - d == approx( 1.22 ) for: 1.23 == Approx( 1.22 )
+ok {test-number} - d == approx( 1.22 ) for: 1.22999999999999998 == Approx( 1.21999999999999997 )
 # Use a custom approx
-ok {test-number} - d == approx( 1.24 ) for: 1.23 == Approx( 1.24 )
+ok {test-number} - d == approx( 1.24 ) for: 1.22999999999999998 == Approx( 1.23999999999999999 )
 # Use a custom approx
-ok {test-number} - d != approx( 1.25 ) for: 1.23 != Approx( 1.25 )
+ok {test-number} - d != approx( 1.25 ) for: 1.22999999999999998 != Approx( 1.25 )
 # Use a custom approx
-ok {test-number} - approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23
+ok {test-number} - approx( d ) == 1.23 for: Approx( 1.22999999999999998 ) == 1.22999999999999998
 # Use a custom approx
-ok {test-number} - approx( d ) == 1.22 for: Approx( 1.23 ) == 1.22
+ok {test-number} - approx( d ) == 1.22 for: Approx( 1.22999999999999998 ) == 1.21999999999999997
 # Use a custom approx
-ok {test-number} - approx( d ) == 1.24 for: Approx( 1.23 ) == 1.24
+ok {test-number} - approx( d ) == 1.24 for: Approx( 1.22999999999999998 ) == 1.23999999999999999
 # Use a custom approx
-ok {test-number} - approx( d ) != 1.25 for: Approx( 1.23 ) != 1.25
+ok {test-number} - approx( d ) != 1.25 for: Approx( 1.22999999999999998 ) != 1.25
 # Variadic macros
 ok {test-number} - with 1 message: 'no assertions'
 # Vector Approx matcher
@@ -3951,11 +3971,11 @@ ok {test-number} -  # SKIP 'skipping because answer = 43'
 # empty tags are not allowed
 ok {test-number} - Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
 # erfc_inv
-ok {test-number} - erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.0920368762 == Approx( -0.0920368762 )
+ok {test-number} - erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.09203687623843014 == Approx( -0.09203687623843015 )
 # erfc_inv
-ok {test-number} - erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.0598029112 == Approx( -0.0598029112 )
+ok {test-number} - erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.05980291115763361 == Approx( -0.05980291115763361 )
 # erfc_inv
-ok {test-number} - erfc_inv(0.050000) == Approx(1.38590382434967796) for: 1.3859038243 == Approx( 1.3859038243 )
+ok {test-number} - erfc_inv(0.050000) == Approx(1.38590382434967796) for: 1.38590382434967774 == Approx( 1.38590382434967796 )
 # estimate_clock_resolution
 ok {test-number} - res.mean.count() == rate for: 2000.0 == 2000 (0x<hex digits>)
 # estimate_clock_resolution
@@ -4096,22 +4116,12 @@ ok {test-number} -  # SKIP
 ok {test-number} - s == "7" for: "7" == "7"
 # non-copyable objects
 ok {test-number} - ti == typeid(int) for: {?} == {?}
-# normal_cdf
-ok {test-number} - normal_cdf(0.000000) == Approx(0.50000000000000000) for: 0.5 == Approx( 0.5 )
-# normal_cdf
-ok {test-number} - normal_cdf(1.000000) == Approx(0.84134474606854293) for: 0.8413447461 == Approx( 0.8413447461 )
-# normal_cdf
-ok {test-number} - normal_cdf(-1.000000) == Approx(0.15865525393145705) for: 0.1586552539 == Approx( 0.1586552539 )
-# normal_cdf
-ok {test-number} - normal_cdf(2.809729) == Approx(0.99752083845315409) for: 0.9975208385 == Approx( 0.9975208385 )
-# normal_cdf
-ok {test-number} - normal_cdf(-1.352570) == Approx(0.08809652095066035) for: 0.088096521 == Approx( 0.088096521 )
 # normal_quantile
-ok {test-number} - normal_quantile(0.551780) == Approx(0.13015979861484198) for: 0.1301597986 == Approx( 0.1301597986 )
+ok {test-number} - normal_quantile(0.551780) == Approx(0.13015979861484198) for: 0.13015979861484195 == Approx( 0.13015979861484198 )
 # normal_quantile
-ok {test-number} - normal_quantile(0.533700) == Approx(0.08457408802851875) for: 0.084574088 == Approx( 0.084574088 )
+ok {test-number} - normal_quantile(0.533700) == Approx(0.08457408802851875) for: 0.08457408802851875 == Approx( 0.08457408802851875 )
 # normal_quantile
-ok {test-number} - normal_quantile(0.025000) == Approx(-1.95996398454005449) for: -1.9599639845 == Approx( -1.9599639845 )
+ok {test-number} - normal_quantile(0.025000) == Approx(-1.95996398454005449) for: -1.95996398454005405 == Approx( -1.95996398454005449 )
 # not allowed
 ok {test-number} -
 # not prints unscoped info from previous failures
@@ -4395,15 +4405,15 @@ ok {test-number} - "{ }" == ::Catch::Detail::stringify(type{}) for: "{ }" == "{
 # tuple<>
 ok {test-number} - "{ }" == ::Catch::Detail::stringify(value) for: "{ }" == "{ }"
 # tuple<float,int>
-ok {test-number} - "1.2f" == ::Catch::Detail::stringify(float(1.2)) for: "1.2f" == "1.2f"
+ok {test-number} - "1.5f" == ::Catch::Detail::stringify(float(1.5)) for: "1.5f" == "1.5f"
 # tuple<float,int>
-ok {test-number} - "{ 1.2f, 0 }" == ::Catch::Detail::stringify(type{1.2f,0}) for: "{ 1.2f, 0 }" == "{ 1.2f, 0 }"
+ok {test-number} - "{ 1.5f, 0 }" == ::Catch::Detail::stringify(type{1.5f,0}) for: "{ 1.5f, 0 }" == "{ 1.5f, 0 }"
 # tuple<int>
 ok {test-number} - "{ 0 }" == ::Catch::Detail::stringify(type{0}) for: "{ 0 }" == "{ 0 }"
 # tuple<string,string>
 ok {test-number} - "{ \"hello\", \"world\" }" == ::Catch::Detail::stringify(type{"hello","world"}) for: "{ "hello", "world" }" == "{ "hello", "world" }"
 # tuple<tuple<int>,tuple<>,float>
-ok {test-number} - "{ { 42 }, { }, 1.2f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.2f }" == "{ { 42 }, { }, 1.2f }"
+ok {test-number} - "{ { 42 }, { }, 1.5f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.5f }" == "{ { 42 }, { }, 1.5f }"
 # uniform samples
 ok {test-number} - e.point == 23 for: 23.0 == 23
 # uniform samples
@@ -4411,7 +4421,7 @@ ok {test-number} - e.upper_bound == 23 for: 23.0 == 23
 # uniform samples
 ok {test-number} - e.lower_bound == 23 for: 23.0 == 23
 # uniform samples
-ok {test-number} - e.confidence_interval == 0.95 for: 0.95 == 0.95
+ok {test-number} - e.confidence_interval == 0.95 for: 0.94999999999999996 == 0.94999999999999996
 # uniform_integer_distribution can return the bounds
 ok {test-number} - dist.a() == -10 for: -10 == -10
 # uniform_integer_distribution can return the bounds
@@ -4538,5 +4548,5 @@ ok {test-number} - q3 == 23. for: 23.0 == 23.0
 ok {test-number} -
 # xmlentitycheck
 ok {test-number} -
-1..2272
+1..2277
 

tests/SelfTest/Baselines/teamcity.sw.approved.txt

@@ -166,6 +166,11 @@
 ##teamcity[testFinished name='A TEST_CASE_METHOD based test run that fails' duration="{duration}"]
 ##teamcity[testStarted name='A TEST_CASE_METHOD based test run that succeeds']
 ##teamcity[testFinished name='A TEST_CASE_METHOD based test run that succeeds' duration="{duration}"]
+##teamcity[testStarted name='A TEST_CASE_PERSISTENT_FIXTURE based test run that fails']
+##teamcity[testFailed name='A TEST_CASE_PERSISTENT_FIXTURE based test run that fails' message='-------------------------------------------------------------------------------|nSecond partial run|n-------------------------------------------------------------------------------|nClass.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n  REQUIRE( m_a == 0 )|nwith expansion:|n  1 == 0|n']
+##teamcity[testFinished name='A TEST_CASE_PERSISTENT_FIXTURE based test run that fails' duration="{duration}"]
+##teamcity[testStarted name='A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds']
+##teamcity[testFinished name='A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds' duration="{duration}"]
 ##teamcity[testStarted name='A Template product test case - Foo<float>']
 ##teamcity[testFinished name='A Template product test case - Foo<float>' duration="{duration}"]
 ##teamcity[testStarted name='A Template product test case - Foo<int>']
@@ -240,6 +245,8 @@
 ##teamcity[testFinished name='CaseInsensitiveLess is case insensitive' duration="{duration}"]
 ##teamcity[testStarted name='Character pretty printing']
 ##teamcity[testFinished name='Character pretty printing' duration="{duration}"]
+##teamcity[testStarted name='Clara::Arg does not crash on incomplete input']
+##teamcity[testFinished name='Clara::Arg does not crash on incomplete input' duration="{duration}"]
 ##teamcity[testStarted name='Clara::Arg supports single-arg parse the way Opt does']
 ##teamcity[testFinished name='Clara::Arg supports single-arg parse the way Opt does' duration="{duration}"]
 ##teamcity[testStarted name='Clara::Opt supports accept-many lambdas']
@@ -318,16 +325,16 @@
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven == 6 )|nwith expansion:|n  7 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven == 8 )|nwith expansion:|n  7 == 8|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven == 0 )|nwith expansion:|n  7 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 9.11f ) )|nwith expansion:|n  9.1f == Approx( 9.1099996567 )|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 9.0f ) )|nwith expansion:|n  9.1f == Approx( 9.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 1 ) )|nwith expansion:|n  9.1f == Approx( 1.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 0 ) )|nwith expansion:|n  9.1f == Approx( 0.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.double_pi == Approx( 3.1415 ) )|nwith expansion:|n  3.1415926535 == Approx( 3.1415 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 9.11f ) )|nwith expansion:|n  9.100000381f|n==|nApprox( 9.10999965667724609 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 9.0f ) )|nwith expansion:|n  9.100000381f == Approx( 9.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 1 ) )|nwith expansion:|n  9.100000381f == Approx( 1.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 0 ) )|nwith expansion:|n  9.100000381f == Approx( 0.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.double_pi == Approx( 3.1415 ) )|nwith expansion:|n  3.14159265350000005|n==|nApprox( 3.14150000000000018 )|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello == "goodbye" )|nwith expansion:|n  "hello" == "goodbye"|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello == "hell" )|nwith expansion:|n  "hello" == "hell"|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello == "hello1" )|nwith expansion:|n  "hello" == "hello1"|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello.size() == 6 )|nwith expansion:|n  5 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( x == Approx( 1.301 ) )|nwith expansion:|n  1.3 == Approx( 1.301 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( x == Approx( 1.301 ) )|nwith expansion:|n  1.30000000000000027|n==|nApprox( 1.30099999999999993 )|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testFinished name='Equality checks that should fail' duration="{duration}"]
 ##teamcity[testStarted name='Equality checks that should succeed']
 ##teamcity[testFinished name='Equality checks that should succeed' duration="{duration}"]
@@ -415,8 +422,8 @@
 ##teamcity[testFinished name='Incomplete AssertionHandler' duration="{duration}"]
 ##teamcity[testStarted name='Inequality checks that should fail']
 ##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven != 7 )|nwith expansion:|n  7 != 7|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one != Approx( 9.1f ) )|nwith expansion:|n  9.1f != Approx( 9.1000003815 )|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.double_pi != Approx( 3.1415926535 ) )|nwith expansion:|n  3.1415926535 != Approx( 3.1415926535 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one != Approx( 9.1f ) )|nwith expansion:|n  9.100000381f|n!=|nApprox( 9.10000038146972656 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.double_pi != Approx( 3.1415926535 ) )|nwith expansion:|n  3.14159265350000005|n!=|nApprox( 3.14159265350000005 )|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello != "hello" )|nwith expansion:|n  "hello" != "hello"|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello.size() != 5 )|nwith expansion:|n  5 != 5|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testFinished name='Inequality checks that should fail' duration="{duration}"]
@@ -479,9 +486,9 @@
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven < -1 )|nwith expansion:|n  7 < -1|n']
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven >= 8 )|nwith expansion:|n  7 >= 8|n']
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven <= 6 )|nwith expansion:|n  7 <= 6|n']
-##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one < 9 )|nwith expansion:|n  9.1f < 9|n']
-##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one > 10 )|nwith expansion:|n  9.1f > 10|n']
-##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one > 9.2 )|nwith expansion:|n  9.1f > 9.2|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one < 9 )|nwith expansion:|n  9.100000381f < 9|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one > 10 )|nwith expansion:|n  9.100000381f > 10|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one > 9.2 )|nwith expansion:|n  9.100000381f > 9.19999999999999929|n']
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello > "hello" )|nwith expansion:|n  "hello" > "hello"|n']
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello < "hello" )|nwith expansion:|n  "hello" < "hello"|n']
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello > "hellp" )|nwith expansion:|n  "hello" > "hellp"|n']
@@ -673,7 +680,7 @@
 ##teamcity[testStarted name='Type conversions of RangeEquals and similar']
 ##teamcity[testFinished name='Type conversions of RangeEquals and similar' duration="{duration}"]
 ##teamcity[testStarted name='Unexpected exceptions can be translated']
-##teamcity[testFailed name='Unexpected exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n  "3.14"']
+##teamcity[testFailed name='Unexpected exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n  "3.14000000000000012"']
 ##teamcity[testFinished name='Unexpected exceptions can be translated' duration="{duration}"]
 ##teamcity[testStarted name='Upcasting special member functions']
 ##teamcity[testFinished name='Upcasting special member functions' duration="{duration}"]
@@ -861,8 +868,6 @@ loose text artifact
 ##teamcity[testFinished name='non streamable - with conv. op' duration="{duration}"]
 ##teamcity[testStarted name='non-copyable objects']
 ##teamcity[testFinished name='non-copyable objects' duration="{duration}"]
-##teamcity[testStarted name='normal_cdf']
-##teamcity[testFinished name='normal_cdf' duration="{duration}"]
 ##teamcity[testStarted name='normal_quantile']
 ##teamcity[testFinished name='normal_quantile' duration="{duration}"]
 ##teamcity[testStarted name='not allowed']

tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt

@@ -166,6 +166,11 @@
 ##teamcity[testFinished name='A TEST_CASE_METHOD based test run that fails' duration="{duration}"]
 ##teamcity[testStarted name='A TEST_CASE_METHOD based test run that succeeds']
 ##teamcity[testFinished name='A TEST_CASE_METHOD based test run that succeeds' duration="{duration}"]
+##teamcity[testStarted name='A TEST_CASE_PERSISTENT_FIXTURE based test run that fails']
+##teamcity[testFailed name='A TEST_CASE_PERSISTENT_FIXTURE based test run that fails' message='-------------------------------------------------------------------------------|nSecond partial run|n-------------------------------------------------------------------------------|nClass.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n  REQUIRE( m_a == 0 )|nwith expansion:|n  1 == 0|n']
+##teamcity[testFinished name='A TEST_CASE_PERSISTENT_FIXTURE based test run that fails' duration="{duration}"]
+##teamcity[testStarted name='A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds']
+##teamcity[testFinished name='A TEST_CASE_PERSISTENT_FIXTURE based test run that succeeds' duration="{duration}"]
 ##teamcity[testStarted name='A Template product test case - Foo<float>']
 ##teamcity[testFinished name='A Template product test case - Foo<float>' duration="{duration}"]
 ##teamcity[testStarted name='A Template product test case - Foo<int>']
@@ -240,6 +245,8 @@
 ##teamcity[testFinished name='CaseInsensitiveLess is case insensitive' duration="{duration}"]
 ##teamcity[testStarted name='Character pretty printing']
 ##teamcity[testFinished name='Character pretty printing' duration="{duration}"]
+##teamcity[testStarted name='Clara::Arg does not crash on incomplete input']
+##teamcity[testFinished name='Clara::Arg does not crash on incomplete input' duration="{duration}"]
 ##teamcity[testStarted name='Clara::Arg supports single-arg parse the way Opt does']
 ##teamcity[testFinished name='Clara::Arg supports single-arg parse the way Opt does' duration="{duration}"]
 ##teamcity[testStarted name='Clara::Opt supports accept-many lambdas']
@@ -318,16 +325,16 @@
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven == 6 )|nwith expansion:|n  7 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven == 8 )|nwith expansion:|n  7 == 8|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven == 0 )|nwith expansion:|n  7 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 9.11f ) )|nwith expansion:|n  9.1f == Approx( 9.1099996567 )|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 9.0f ) )|nwith expansion:|n  9.1f == Approx( 9.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 1 ) )|nwith expansion:|n  9.1f == Approx( 1.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 0 ) )|nwith expansion:|n  9.1f == Approx( 0.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.double_pi == Approx( 3.1415 ) )|nwith expansion:|n  3.1415926535 == Approx( 3.1415 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 9.11f ) )|nwith expansion:|n  9.100000381f|n==|nApprox( 9.10999965667724609 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 9.0f ) )|nwith expansion:|n  9.100000381f == Approx( 9.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 1 ) )|nwith expansion:|n  9.100000381f == Approx( 1.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 0 ) )|nwith expansion:|n  9.100000381f == Approx( 0.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.double_pi == Approx( 3.1415 ) )|nwith expansion:|n  3.14159265350000005|n==|nApprox( 3.14150000000000018 )|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello == "goodbye" )|nwith expansion:|n  "hello" == "goodbye"|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello == "hell" )|nwith expansion:|n  "hello" == "hell"|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello == "hello1" )|nwith expansion:|n  "hello" == "hello1"|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello.size() == 6 )|nwith expansion:|n  5 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( x == Approx( 1.301 ) )|nwith expansion:|n  1.3 == Approx( 1.301 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( x == Approx( 1.301 ) )|nwith expansion:|n  1.30000000000000027|n==|nApprox( 1.30099999999999993 )|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testFinished name='Equality checks that should fail' duration="{duration}"]
 ##teamcity[testStarted name='Equality checks that should succeed']
 ##teamcity[testFinished name='Equality checks that should succeed' duration="{duration}"]
@@ -415,8 +422,8 @@
 ##teamcity[testFinished name='Incomplete AssertionHandler' duration="{duration}"]
 ##teamcity[testStarted name='Inequality checks that should fail']
 ##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven != 7 )|nwith expansion:|n  7 != 7|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one != Approx( 9.1f ) )|nwith expansion:|n  9.1f != Approx( 9.1000003815 )|n- failure ignore as test marked as |'ok to fail|'|n']
-##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.double_pi != Approx( 3.1415926535 ) )|nwith expansion:|n  3.1415926535 != Approx( 3.1415926535 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one != Approx( 9.1f ) )|nwith expansion:|n  9.100000381f|n!=|nApprox( 9.10000038146972656 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.double_pi != Approx( 3.1415926535 ) )|nwith expansion:|n  3.14159265350000005|n!=|nApprox( 3.14159265350000005 )|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello != "hello" )|nwith expansion:|n  "hello" != "hello"|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello.size() != 5 )|nwith expansion:|n  5 != 5|n- failure ignore as test marked as |'ok to fail|'|n']
 ##teamcity[testFinished name='Inequality checks that should fail' duration="{duration}"]
@@ -479,9 +486,9 @@
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven < -1 )|nwith expansion:|n  7 < -1|n']
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven >= 8 )|nwith expansion:|n  7 >= 8|n']
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven <= 6 )|nwith expansion:|n  7 <= 6|n']
-##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one < 9 )|nwith expansion:|n  9.1f < 9|n']
-##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one > 10 )|nwith expansion:|n  9.1f > 10|n']
-##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one > 9.2 )|nwith expansion:|n  9.1f > 9.2|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one < 9 )|nwith expansion:|n  9.100000381f < 9|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one > 10 )|nwith expansion:|n  9.100000381f > 10|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one > 9.2 )|nwith expansion:|n  9.100000381f > 9.19999999999999929|n']
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello > "hello" )|nwith expansion:|n  "hello" > "hello"|n']
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello < "hello" )|nwith expansion:|n  "hello" < "hello"|n']
 ##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello > "hellp" )|nwith expansion:|n  "hello" > "hellp"|n']
@@ -673,7 +680,7 @@
 ##teamcity[testStarted name='Type conversions of RangeEquals and similar']
 ##teamcity[testFinished name='Type conversions of RangeEquals and similar' duration="{duration}"]
 ##teamcity[testStarted name='Unexpected exceptions can be translated']
-##teamcity[testFailed name='Unexpected exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n  "3.14"']
+##teamcity[testFailed name='Unexpected exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n  "3.14000000000000012"']
 ##teamcity[testFinished name='Unexpected exceptions can be translated' duration="{duration}"]
 ##teamcity[testStarted name='Upcasting special member functions']
 ##teamcity[testFinished name='Upcasting special member functions' duration="{duration}"]
@@ -860,8 +867,6 @@
 ##teamcity[testFinished name='non streamable - with conv. op' duration="{duration}"]
 ##teamcity[testStarted name='non-copyable objects']
 ##teamcity[testFinished name='non-copyable objects' duration="{duration}"]
-##teamcity[testStarted name='normal_cdf']
-##teamcity[testFinished name='normal_cdf' duration="{duration}"]
 ##teamcity[testStarted name='normal_quantile']
 ##teamcity[testFinished name='normal_quantile' duration="{duration}"]
 ##teamcity[testStarted name='not allowed']

tests/SelfTest/IntrospectiveTests/Clara.tests.cpp

@@ -51,6 +51,21 @@ TEST_CASE("Clara::Arg supports single-arg parse the way Opt does", "[clara][arg]
     REQUIRE(name == "foo");
 }
 
+TEST_CASE("Clara::Arg does not crash on incomplete input", "[clara][arg][compilation]") {
+    std::string name;
+    auto p = Catch::Clara::Arg(name, "-");
+
+    CHECK(name.empty());
+
+    auto result = p.parse( Catch::Clara::Args{ "UnitTest", "-" } );
+    CHECK( result );
+    CHECK( result.type() == Catch::Clara::Detail::ResultType::Ok );
+    const auto& parsed = result.value();
+    CHECK( parsed.type() == Catch::Clara::ParseResultType::NoMatch );
+    CHECK( parsed.remainingTokens().count() == 2 );
+    CHECK( name.empty() );
+}
+
 TEST_CASE("Clara::Opt supports accept-many lambdas", "[clara][opt]") {
     using namespace Catch::Clara;
     std::vector<std::string> res;