Update CI image to macOS 14

Ignore C++98 related compiler warnings
Catch2 has long since required a standard newer than C++98 so we can safely ignore any warnings related to such old standards.
2025-09-12 00:15:39 +02:00 · 2024-03-12 12:47:55 -06:00 · 2024-03-12 11:27:06 -06:00
131 changed files with 2677 additions and 6555 deletions
--- a/.conan/test_package/CMakeLists.txt
+++ b/.conan/test_package/CMakeLists.txt
@@ -4,5 +4,4 @@ project(PackageTest CXX)
 find_package(Catch2 CONFIG REQUIRED)

 add_executable(test_package test_package.cpp)
-target_link_libraries(test_package Catch2::Catch2WithMain)
-target_compile_features(test_package PRIVATE cxx_std_14)
+target_link_libraries(test_package Catch2::Catch2WithMain)
--- a/.conan/test_package/conanfile.py
+++ b/.conan/test_package/conanfile.py
@@ -3,14 +3,12 @@
 from conan import ConanFile
 from conan.tools.cmake import CMake, cmake_layout
 from conan.tools.build import can_run
-from conan.tools.files import save, load
 import os


 class TestPackageConan(ConanFile):
    settings = "os", "compiler", "build_type", "arch"
-    generators = "CMakeToolchain", "CMakeDeps", "VirtualRunEnv"
-    test_type = "explicit"
+    generators = "CMakeToolchain", "CMakeDeps"

    def requirements(self):
        self.requires(self.tested_reference_str)
@@ -18,12 +16,6 @@ class TestPackageConan(ConanFile):
    def layout(self):
        cmake_layout(self)

-    def generate(self):
-        save(self, os.path.join(self.build_folder, "package_folder"),
-             self.dependencies[self.tested_reference_str].package_folder)
-        save(self, os.path.join(self.build_folder, "license"),
-             self.dependencies[self.tested_reference_str].license)
-
    def build(self):
        cmake = CMake(self)
        cmake.configure()
@@ -34,7 +26,8 @@ class TestPackageConan(ConanFile):
            cmd = os.path.join(self.cpp.build.bindir, "test_package")
            self.run(cmd, env="conanrun")

-            package_folder = load(self, os.path.join(self.build_folder, "package_folder"))
-            license = load(self, os.path.join(self.build_folder, "license"))
-            assert os.path.isfile(os.path.join(package_folder, "licenses", "LICENSE.txt"))
-            assert license == 'BSL-1.0'
+        # If we are on conan 2 we can check the license info is populated
+        if hasattr(self, 'dependencies'):
+            catch2 = self.dependencies["catch2"]
+            assert os.path.exists(f'{catch2.package_folder}/licenses/LICENSE.txt')
+            assert catch2.license == 'BSL-1.0'
--- a/.github/workflows/linux-simple-builds.yml
+++ b/.github/workflows/linux-simple-builds.yml
@@ -9,8 +9,6 @@ jobs:
    strategy:
      matrix:
        cxx:
-          - g++-5
-          - g++-6
          - g++-7
          - g++-8
          - g++-9
@@ -23,10 +21,6 @@ jobs:
        build_type: [Debug, Release]
        std: [14]
        include:
-          - cxx: g++-5
-            other_pkgs: g++-5
-          - cxx: g++-6
-            other_pkgs: g++-6
          - cxx: g++-7
            other_pkgs: g++-7
          - cxx: g++-8
--- a/.github/workflows/mac-builds-m1.yml
+++ b/.github/workflows/mac-builds-m1.yml
@@ -1,44 +0,0 @@
-name: M1 Mac builds
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: macos-14
-    strategy:
-      matrix:
-        cxx:
-          - clang++
-        build_type: [Debug, Release]
-        std: [14, 17]
-        include:
-          - build_type: Debug
-            examples: ON
-            extra_tests: ON
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Configure build
-      working-directory: ${{runner.workspace}}
-      env:
-        CXX: ${{matrix.cxx}}
-        CXXFLAGS: ${{matrix.cxxflags}}
-      run: |
-        cmake -Bbuild -H$GITHUB_WORKSPACE \
-              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
-              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
-              -DCMAKE_CXX_STANDARD_REQUIRED=ON \
-              -DCATCH_DEVELOPMENT_BUILD=ON \
-              -DCATCH_BUILD_EXAMPLES=${{matrix.examples}} \
-              -DCATCH_BUILD_EXTRA_TESTS=${{matrix.examples}}
-
-    - name: Build tests + lib
-      working-directory: ${{runner.workspace}}/build
-      run: make -j `sysctl -n hw.ncpu`
-
-    - name: Run tests
-      env:
-          CTEST_OUTPUT_ON_FAILURE: 1
-      working-directory: ${{runner.workspace}}/build
-      run: ctest -C ${{matrix.build_type}} -j `sysctl -n hw.ncpu`
--- a/.github/workflows/mac-builds.yml
+++ b/.github/workflows/mac-builds.yml
@@ -4,10 +4,11 @@ on: [push, pull_request]

 jobs:
  build:
-    runs-on: macos-12
+    runs-on: macos-14
    strategy:
      matrix:
        cxx:
+          - g++-11
          - clang++
        build_type: [Debug, Release]
        std: [14, 17]
@@ -24,6 +25,8 @@ 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}} \
--- a/.github/workflows/package-manager-builds.yaml
+++ b/.github/workflows/package-manager-builds.yaml
@@ -9,12 +9,12 @@ jobs:
    strategy:
      matrix:
        conan_version:
-          - '1.63'
-          - '2.1'
+          - '1.62'
+          - '2.0'

        include:
          # Conan 1 has default profiles installed
-          - conan_version: '1.63'
+          - conan_version: '1.62'
            profile_generate: 'false'

    steps:
--- a/.gitignore
+++ b/.gitignore
@@ -25,9 +25,8 @@ Build
 cmake-build-*
 benchmark-dir
 .conan/test_package/build
-**/CMakeUserPresets.json
+.conan/test_package/CMakeUserPresets.json
 bazel-*
-MODULE.bazel.lock
 build-fuzzers
 debug-build
 .vscode
@@ -37,4 +36,3 @@ msvc-sln*
 docs/doxygen
 *.cache
 compile_commands.json
-**/*.unapproved.txt
--- a/CMake/CatchMiscFunctions.cmake
+++ b/CMake/CatchMiscFunctions.cmake
@@ -68,7 +68,6 @@ function(add_warnings_to_targets targets)
          "-Wmissing-noreturn"
          "-Wmissing-prototypes"
          "-Wmissing-variable-declarations"
-          "-Wnon-virtual-dtor"
          "-Wnull-dereference"
          "-Wold-style-cast"
          "-Woverloaded-virtual"
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,7 +33,7 @@ if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 endif()

 project(Catch2
-  VERSION 3.7.1 # CML version placeholder, don't delete
+  VERSION 3.5.3 # 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,6 +76,8 @@ 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)
@@ -198,4 +200,4 @@ if (NOT_SUBPROJECT)

    include( CPack )

-endif()
+endif(NOT_SUBPROJECT)
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -1,3 +1,3 @@
 module(name = "catch2")

-bazel_dep(name = "bazel_skylib", version = "1.7.1")
+bazel_dep(name = "bazel_skylib", version = "1.5.0")
--- a/WORKSPACE.bazel
+++ b/WORKSPACE.bazel
@@ -4,10 +4,10 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

 http_archive(
    name = "bazel_skylib",
-    sha256 = "bc283cdfcd526a52c3201279cda4bc298652efa898b10b4db0837dc51652756f",
+    sha256 = "cd55a062e763b9349921f0f5db8c3933288dc8ba4f76dd9416aac68acee3cb94",
    urls = [
-        "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",
+        "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",
    ],
 )

--- a/conanfile.py
+++ b/conanfile.py
@@ -1,11 +1,9 @@
 #!/usr/bin/env python
-from conan import ConanFile
+from conan import ConanFile, tools, __version__ as conan_version
 from conan.tools.cmake import CMake, CMakeToolchain, CMakeDeps, cmake_layout
-from conan.tools.files import copy, rmdir
-from conan.tools.build import check_min_cppstd
-from conan.tools.scm import Version
-from conan.errors import ConanInvalidConfiguration
+from conan.tools import files, scm
 import os
+import shutil
 import re

 required_conan_version = ">=1.53.0"
@@ -18,32 +16,11 @@ class CatchConan(ConanFile):
    homepage = url
    license = "BSL-1.0"
    version = "latest"
+
+    exports = "LICENSE.txt"
+    exports_sources = ("src/*", "CMakeLists.txt", "CMake/*", "extras/*")
+
    settings = "os", "compiler", "build_type", "arch"
-    extension_properties = {"compatibility_cppstd": False}
-
-    options = {
-        "shared": [True, False],
-        "fPIC": [True, False],
-    }
-    default_options = {
-        "shared": False,
-        "fPIC": True,
-    }
-
-    @property
-    def _min_cppstd(self):
-        return "14"
-
-    @property
-    def _compilers_minimum_version(self):
-        return {
-            "gcc": "7",
-            "Visual Studio": "15",
-            "msvc": "191",
-            "clang": "5",
-            "apple-clang": "10",
-        }
-

    def set_version(self):
        pattern = re.compile(r"\w*VERSION (\d+\.\d+\.\d+) # CML version placeholder, don't delete")
@@ -55,57 +32,39 @@ class CatchConan(ConanFile):

        self.output.info(f'Using version: {self.version}')

-    def export(self):
-        copy(self, "LICENSE.txt", src=self.recipe_folder, dst=self.export_folder)
-
-    def export_sources(self):
-        copy(self, "CMakeLists.txt", src=self.recipe_folder, dst=self.export_sources_folder)
-        copy(self, "src/*", src=self.recipe_folder, dst=self.export_sources_folder)
-        copy(self, "extras/*", src=self.recipe_folder, dst=self.export_sources_folder)
-        copy(self, "CMake/*", src=self.recipe_folder, dst=self.export_sources_folder)
-
-    def config_options(self):
-        if self.settings.os == "Windows":
-            del self.options.fPIC
-
-    def configure(self):
-        if self.options.shared:
-            self.options.rm_safe("fPIC")
-
    def layout(self):
        cmake_layout(self)

-    def validate(self):
-        if self.settings.compiler.get_safe("cppstd"):
-            check_min_cppstd(self, self._min_cppstd)
-        # INFO: Conan 1.x does not specify cppstd by default, so we need to check the compiler version instead.
-        minimum_version = self._compilers_minimum_version.get(str(self.settings.compiler), False)
-        if minimum_version and Version(self.settings.compiler.version) < minimum_version:
-            raise ConanInvalidConfiguration(f"{self.ref} requires C++{self._min_cppstd}, which your compiler doesn't support")
-
    def generate(self):
        tc = CMakeToolchain(self)
-        tc.cache_variables["BUILD_TESTING"] = False
-        tc.cache_variables["CATCH_INSTALL_DOCS"] = False
-        tc.cache_variables["CATCH_INSTALL_EXTRAS"] = True
        tc.generate()

        deps = CMakeDeps(self)
        deps.generate()

-    def build(self):
+    def _configure_cmake(self):
        cmake = CMake(self)
-        cmake.configure()
+
+        # These are option variables. The toolchain in conan 2 doesn't appear to
+        # set these correctly so you have to do it in the configure variables.
+        cmake.configure(variables= {
+            "BUILD_TESTING": "OFF",
+            "CATCH_INSTALL_DOCS": "OFF",
+            "CATCH_INSTALL_EXTRAS": "ON",
+            }
+        )
+        return cmake
+
+    def build(self):
+        cmake = self._configure_cmake()
        cmake.build()

    def package(self):
-        copy(self, "LICENSE.txt", src=str(self.recipe_folder), dst=os.path.join(self.package_folder, "licenses"))
-        cmake = CMake(self)
+        cmake = self._configure_cmake()
        cmake.install()
-        rmdir(self, os.path.join(self.package_folder, "share"))
-        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
-        copy(self, "*.cmake", src=os.path.join(self.export_sources_folder, "extras"),
-                              dst=os.path.join(self.package_folder, "lib", "cmake", "Catch2"))
+
+        os.mkdir(f'{self.package_folder}/licenses/')
+        shutil.copy2(f'{self.recipe_folder}/LICENSE.txt', f'{self.package_folder}/licenses/')

    def package_info(self):
        lib_suffix = "d" if self.settings.build_type == "Debug" else ""
@@ -116,7 +75,6 @@ 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")
@@ -126,4 +84,4 @@ class CatchConan(ConanFile):
        self.cpp_info.components["catch2main"].set_property("cmake_target_name", "Catch2::Catch2WithMain")
        self.cpp_info.components["catch2main"].set_property("pkg_config_name", "catch2-with-main")
        self.cpp_info.components["catch2main"].libs = ["Catch2Main" + lib_suffix]
-        self.cpp_info.components["catch2main"].requires = ["catch2base"]
+        self.cpp_info.components["catch2main"].requires = ["catch2base"]
--- a/docs/assertions.md
+++ b/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(), ContainsSubstring( "afraid" ) && ContainsSubstring( "can't do that" ) );
+REQUIRE_THROWS_WITH( openThePodBayDoors(), Contains( "afraid" ) && Contains( "can't do that" ) );
 REQUIRE_THROWS_WITH( dismantleHal(), "My mind is going" );
 ```

--- a/docs/cmake-integration.md
+++ b/docs/cmake-integration.md
@@ -8,7 +8,6 @@
 [`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.
--- a/docs/command-line.md
+++ b/docs/command-line.md
@@ -145,7 +145,7 @@ only tests that match the positive filters are included.

 You can also match test names with special characters by escaping them
 with a backslash (`"\"`), e.g. a test named `"Do A, then B"` is matched
-by `"Do A\, then B"` test spec. Backslash also escapes itself.
+by "Do A\, then B" test spec. Backslash also escapes itself.


 ### Examples
@@ -194,8 +194,7 @@ verbose and human-friendly output.

 Reporters are also individually configurable. To pass configuration options
 to the reporter, you append `::key=value` to the reporter specification
-as many times as you want, e.g. `--reporter xml::out=someFile.xml` or
-`--reporter custom::colour-mode=ansi::Xoption=2`.
+as many times as you want, e.g. `--reporter xml::out=someFile.xml`.

 The keys must either be prefixed by "X", in which case they are not parsed
 by Catch2 and are only passed down to the reporter, or one of options
--- a/docs/contributing.md
+++ b/docs/contributing.md
@@ -107,7 +107,8 @@ cmake -B debug-build -S . -DCMAKE_BUILD_TYPE=Debug --preset all-tests
 cmake --build debug-build

 # 4. Run the tests using CTest
-ctest -j 4 --output-on-failure -C Debug --test-dir debug-build
+cd debug-build
+ctest -j 4 --output-on-failure -C Debug
 ```
 <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 -->
--- a/docs/deprecations.md
+++ b/docs/deprecations.md
@@ -35,19 +35,6 @@ 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)
--- a/docs/list-of-examples.md
+++ b/docs/list-of-examples.md
@@ -8,7 +8,6 @@
 - 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)
--- a/docs/logging.md
+++ b/docs/logging.md
@@ -114,10 +114,6 @@ Similar to `INFO`, but messages are not limited to their own scope: They are rem

 The message is always reported but does not fail the test.

-**SUCCEED(** _message expression_ **)**
-
-The message is reported and the test case succeeds.
-
 **FAIL(** _message expression_ **)**

 The message is reported and the test case fails.
--- a/docs/matchers.md
+++ b/docs/matchers.md
@@ -210,36 +210,15 @@ The other miscellaneous matcher utility is exception matching.

 #### Matching exceptions

-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.
+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)`.

 > `REQUIRE_THROWS_MATCHES` macro lives in `catch2/matchers/catch_matchers.hpp`

-For one-off checks you can use the `Predicate` matcher above, e.g.

-```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`):
+Catch2 currently provides two matchers for exceptions.
+These are:
 * `Message(std::string message)`.
 * `MessageMatches(Matcher matcher)`.

@@ -257,7 +236,10 @@ REQUIRE_THROWS_MATCHES(throwsDerivedException(),  DerivedException,  Message("De
 REQUIRE_THROWS_MATCHES(throwsDerivedException(),  DerivedException,  MessageMatches(StartsWith("DerivedException")));
 ```

-> the exception message matchers live in `catch2/matchers/catch_matchers_exception.hpp`
+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`


 ### Generic range Matchers
--- a/docs/other-macros.md
+++ b/docs/other-macros.md
@@ -93,6 +93,30 @@ 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
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -2,10 +2,6 @@

 # Release notes
 **Contents**<br>
-[3.7.1](#371)<br>
-[3.7.0](#370)<br>
-[3.6.0](#360)<br>
-[3.5.4](#354)<br>
 [3.5.3](#353)<br>
 [3.5.2](#352)<br>
 [3.5.1](#351)<br>
@@ -65,94 +61,6 @@
 [Even Older versions](#even-older-versions)<br>


-## 3.7.1
-
-### Improvements
-* Applied the JUnit reporter's optimization from last release to the SonarQube reporter
-* Suppressed `-Wuseless-cast` in `CHECK_THROWS_MATCHES` (#2904)
-* Standardize exit codes for various failures
-  * Running no tests is now guaranteed to exit with 2 (without the `--allow-running-no-tests` flag)
-  * All tests skipped is now always 4 (...)
-  * Assertion failures are now always 42
-  * and so on
-
-### Fixes
-* Fixed out-of-bounds access when the arg parser encounters single `-` as an argument (#2905)
-
-### Miscellaneous
-* Added `catch_config_prefix_messages.hpp` to meson build (#2903)
-* `catch_discover_tests` now supports skipped tests (#2873)
-  * You can get the old behaviour by calling `catch_discover_tests` with `SKIP_IS_FAILURE` option.
-
-
-## 3.7.0
-
-### Improvements
-* 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
-* Fixed potential compilation error when asked to generate random integers whose type did not match `std::(u)int*_t`.
-  * This manifested itself when generating random `size_t`s on MacOS
-* Added missing outlined destructor causing `Wdelete-incomplete` when compiling against libstdc++ in C++23 mode (#2852)
-* Fixed regression where decomposing assertion with const instance of `std::foo_ordering` would not compile
-
-### Improvements
-* Reintroduced support for GCC 5 and 6 (#2836)
-  * As with VS2017, if they start causing trouble again, they will be dropped again.
-* Added workaround for targetting newest MacOS (Sonoma) using GCC (#2837, #2839)
-* `CATCH_CONFIG_DEFAULT_REPORTER` can now be an arbitrary reporter spec
-  * Previously it could only be a plain reporter name, so it was impossible to compile in custom arguments to the reporter.
-* Improved performance of generating 64bit random integers by 20+%
-
-### Miscellaneous
-* Significantly improved Conan in-tree recipe (#2831)
-* `DL_PATHS` in `catch_discover_tests` now supports multiple arguments (#2852, #2736)
-* Fixed preprocessor logic for checking whether we expect reproducible floating point results in tests.
-* Improved the floating point tests structure to avoid `Wunused` when the reproducibility tests are disabled (#2845)
-
-
 ## 3.5.3

 ### Fixes
--- a/docs/test-cases-and-sections.md
+++ b/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 and `[\]]` is not a valid tag.
+supported however 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
--- a/docs/test-fixtures.md
+++ b/docs/test-fixtures.md
@@ -1,30 +1,9 @@
 <a id="top"></a>
 # 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>
+## Defining test fixtures

-## 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:
+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:

 ```c++
 class UniqueTestsFixture {
@@ -51,116 +30,8 @@ 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
@@ -222,7 +93,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 parameterised test fixtures
+## Signature-based parametrised test fixtures

 > [Introduced](https://github.com/catchorg/Catch2/issues/1609) in Catch2 2.8.0.

--- a/examples/111-Fix-PersistentFixture.cpp
+++ b/examples/111-Fix-PersistentFixture.cpp
@@ -1,74 +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
-
-// 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 ); }
-}
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -28,7 +28,6 @@ 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
@@ -44,7 +43,8 @@ set( TARGETS_IDIOMATIC_EXAMPLES ${BASENAMES_IDIOMATIC_EXAMPLES} )


 foreach( name ${TARGETS_IDIOMATIC_EXAMPLES} )
-    add_executable( ${name} ${name}.cpp )
+    add_executable( ${name}
+      ${EXAMPLES_DIR}/${name}.cpp )
 endforeach()

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

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

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

@@ -155,9 +144,9 @@ function(catch_discover_tests TARGET)

  cmake_parse_arguments(
    ""
-    "SKIP_IS_FAILURE"
+    ""
    "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX;DISCOVERY_MODE"
-    "TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS;DL_FRAMEWORK_PATHS"
+    "TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS"
    ${ARGN}
  )

@@ -167,11 +156,10 @@ function(catch_discover_tests TARGET)
  if(NOT _TEST_LIST)
    set(_TEST_LIST ${TARGET}_TESTS)
  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")
+  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()
  endif()
  if(NOT _DISCOVERY_MODE)
    if(NOT CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE)
@@ -196,9 +184,6 @@ function(catch_discover_tests TARGET)
    TARGET ${TARGET}
    PROPERTY CROSSCOMPILING_EMULATOR
  )
-  if (NOT _SKIP_IS_FAILURE)
-    set(_PROPERTIES ${_PROPERTIES} SKIP_RETURN_CODE 4)
-  endif()

  if(_DISCOVERY_MODE STREQUAL "POST_BUILD")
    add_custom_command(
@@ -220,7 +205,6 @@ 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
@@ -266,7 +250,6 @@ 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"
--- a/extras/CatchAddTests.cmake
+++ b/extras/CatchAddTests.cmake
@@ -21,8 +21,8 @@ function(catch_discover_tests_impl)
  cmake_parse_arguments(
    ""
    ""
-    "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_DL_FRAMEWORK_PATHS"
+    "TEST_EXECUTABLE;TEST_WORKING_DIR;TEST_DL_PATHS;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"
    ${ARGN}
  )

@@ -36,8 +36,6 @@ 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)
@@ -58,19 +56,10 @@ function(catch_discover_tests_impl)
  endif()

  if(dl_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)
+    cmake_path(CONVERT "${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
@@ -128,14 +117,7 @@ function(catch_discover_tests_impl)
  if(dl_paths)
    foreach(path ${dl_paths})
      cmake_path(NATIVE_PATH path 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}")
+      list(APPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
    endforeach()
  endif()

@@ -205,7 +187,6 @@ 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()
--- a/extras/ParseAndAddCatchTests.cmake
+++ b/extras/ParseAndAddCatchTests.cmake
@@ -187,7 +187,7 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
            if(result)
                set(HiddenTagFound ON)
                break()
-            endif()
+            endif(result)
        endforeach(label)
        if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_LESS "3.9")
            ParseAndAddCatchTests_PrintDebugMessage("Skipping test \"${CTestName}\" as it has [!hide], [.] or [.foo] label")
--- a/extras/catch_amalgamated.cpp
+++ b/extras/catch_amalgamated.cpp
--- a/extras/catch_amalgamated.hpp
+++ b/extras/catch_amalgamated.hpp
--- a/meson.build
+++ b/meson.build
@@ -8,7 +8,7 @@
 project(
  'catch2',
  'cpp',
-  version: '3.7.1', # CML version placeholder, don't delete
+  version: '3.5.3', # CML version placeholder, don't delete
  license: 'BSL-1.0',
  meson_version: '>=0.54.1',
 )
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -48,7 +48,6 @@ 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
@@ -68,13 +67,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
@@ -195,6 +194,7 @@ 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
@@ -362,10 +362,29 @@ set_target_properties(Catch2 PROPERTIES
                                VERSION ${PROJECT_VERSION}
                              SOVERSION ${PROJECT_VERSION})

-# require C++14
+# depend on bunch of C++11 and C++14 features to have C++14 enabled by default
 target_compile_features(Catch2
  PUBLIC
-    cxx_std_14
+    cxx_alignas
+    cxx_alignof
+    cxx_attributes
+    cxx_auto_type
+    cxx_constexpr
+    cxx_defaulted_functions
+    cxx_deleted_functions
+    cxx_final
+    cxx_lambdas
+    cxx_noexcept
+    cxx_override
+    cxx_range_for
+    cxx_rvalue_references
+    cxx_static_assert
+    cxx_strong_enums
+    cxx_trailing_return_types
+    cxx_unicode_literals
+    cxx_user_literals
+    cxx_variable_templates
+    cxx_variadic_macros
 )

 configure_file(
@@ -456,7 +475,26 @@ if (CATCH_BUILD_EXAMPLES OR CATCH_BUILD_EXTRA_TESTS)
    )
    target_compile_features(Catch2_buildall_interface
      INTERFACE
-        cxx_std_14
+        cxx_alignas
+        cxx_alignof
+        cxx_attributes
+        cxx_auto_type
+        cxx_constexpr
+        cxx_defaulted_functions
+        cxx_deleted_functions
+        cxx_final
+        cxx_lambdas
+        cxx_noexcept
+        cxx_override
+        cxx_range_for
+        cxx_rvalue_references
+        cxx_static_assert
+        cxx_strong_enums
+        cxx_trailing_return_types
+        cxx_unicode_literals
+        cxx_user_literals
+        cxx_variable_templates
+        cxx_variadic_macros
    )
 endif()

--- a/src/catch2/benchmark/catch_benchmark.hpp
+++ b/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) {
+            ExecutionPlan prepare(const IConfig &cfg, Environment env) const {
                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(), CATCH_MOVE(fun), std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
            }

            template <typename Clock = default_clock>
--- a/src/catch2/benchmark/catch_outlier_classification.hpp
+++ b/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

-            constexpr int total() const {
+            int total() const {
                return low_severe + low_mild + high_mild + high_severe;
            }
        };
--- a/src/catch2/benchmark/detail/catch_benchmark_function.cpp
+++ b/src/catch2/benchmark/detail/catch_benchmark_function.cpp
@@ -11,13 +11,7 @@
 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
--- a/src/catch2/benchmark/detail/catch_benchmark_function.hpp
+++ b/src/catch2/benchmark/detail/catch_benchmark_function.hpp
@@ -35,17 +35,22 @@ 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&&) = default;
-                    callable& operator=(callable&&) = default;
+                    callable(callable const&) = default;
+                    callable& operator=(callable const&) = 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)>());
                    }
@@ -59,8 +64,14 @@ namespace Catch {
                    Fun fun;
                };

+                struct do_nothing { void operator()() const {} };
+
+                template <typename T>
+                BenchmarkFunction(model<T>* c) : f(c) {}
+
            public:
-                BenchmarkFunction();
+                BenchmarkFunction()
+                    : f(new model<do_nothing>{ {} }) {}

                template <typename Fun,
                    std::enable_if_t<!is_related<Fun, BenchmarkFunction>::value, int> = 0>
@@ -70,12 +81,20 @@ 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:
--- a/src/catch2/benchmark/detail/catch_estimate_clock.hpp
+++ b/src/catch2/benchmark/detail/catch_estimate_clock.hpp
@@ -27,17 +27,15 @@ namespace Catch {
        namespace Detail {
            template <typename Clock>
            std::vector<double> resolution(int k) {
-                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<TimePoint<Clock>> times;
+                times.reserve(static_cast<size_t>(k + 1));
+                for ( int i = 0; i < k + 1; ++i ) {
+                    times.push_back( Clock::now() );
                }

                std::vector<double> deltas;
                deltas.reserve(static_cast<size_t>(k));
-                for ( size_t idx = 1; idx < points; ++idx ) {
+                for ( size_t idx = 1; idx < times.size(); ++idx ) {
                    deltas.push_back( static_cast<double>(
                        ( times[idx] - times[idx - 1] ).count() ) );
                }
--- a/src/catch2/benchmark/detail/catch_measure.hpp
+++ b/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(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
+                auto&& r = Detail::complete_invoke(fun, CATCH_FORWARD(args)...);
                auto end = Clock::now();
                auto delta = end - start;
                return { delta, CATCH_FORWARD(r), 1 };
--- a/src/catch2/benchmark/detail/catch_stats.cpp
+++ b/src/catch2/benchmark/detail/catch_stats.cpp
@@ -12,7 +12,6 @@
 #include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_floating_point_helpers.hpp>
 #include <catch2/internal/catch_random_number_generator.hpp>
-#include <catch2/internal/catch_uniform_integer_distribution.hpp>

 #include <algorithm>
 #include <cassert>
@@ -39,7 +38,7 @@ namespace Catch {
                          double const* last,
                          Estimator& estimator ) {
                    auto n = static_cast<size_t>( last - first );
-                    Catch::uniform_integer_distribution<size_t> dist( 0, n - 1 );
+                    std::uniform_int_distribution<size_t> dist( 0, n - 1 );

                    sample out;
                    out.reserve( resamples );
--- a/src/catch2/catch_all.hpp
+++ b/src/catch2/catch_all.hpp
@@ -26,7 +26,6 @@
 #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>
@@ -48,6 +47,7 @@
 #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>
--- a/src/catch2/catch_assertion_result.cpp
+++ b/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) {}

--- a/src/catch2/catch_config.cpp
+++ b/src/catch2/catch_config.cpp
@@ -107,16 +107,14 @@ namespace Catch {

        // Insert the default reporter if user hasn't asked for a specific one
        if ( m_data.reporterSpecifications.empty() ) {
+            m_data.reporterSpecifications.push_back( {
 #if defined( CATCH_CONFIG_DEFAULT_REPORTER )
-            const auto default_spec = CATCH_CONFIG_DEFAULT_REPORTER;
+                CATCH_CONFIG_DEFAULT_REPORTER,
 #else
-            const auto default_spec = "console";
+                "console",
 #endif
-            auto parsed = parseReporterSpec(default_spec);
-            CATCH_ENFORCE( parsed,
-                           "Cannot parse the provided default reporter spec: '"
-                               << default_spec << '\'' );
-            m_data.reporterSpecifications.push_back( std::move( *parsed ) );
+                {}, {}, {}
+            } );
        }

        if ( enableBazelEnvSupport() ) {
--- a/src/catch2/catch_message.cpp
+++ b/src/catch2/catch_message.cpp
@@ -91,7 +91,6 @@ namespace Catch {
                    m_messages.back().message += " := ";
                    start = pos;
                }
-                break;
            default:; // noop
            }
        }
--- a/src/catch2/catch_message.hpp
+++ b/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() ); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

 ///////////////////////////////////////////////////////////////////////////////
--- a/src/catch2/catch_session.cpp
+++ b/src/catch2/catch_session.cpp
@@ -34,13 +34,7 @@
 namespace Catch {

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

+    TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const {
+        return *m_info;
+    }
+
 } // end namespace Catch
--- a/src/catch2/catch_test_case_info.hpp
+++ b/src/catch2/catch_test_case_info.hpp
@@ -109,24 +109,14 @@ namespace Catch {
        TestCaseInfo* m_info;
        ITestInvoker* m_invoker;
    public:
-        constexpr TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
+        TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
            m_info(info), m_invoker(invoker) {}

-        void prepareTestCase() const {
-            m_invoker->prepareTestCase();
-        }
-
-        void tearDownTestCase() const {
-            m_invoker->tearDownTestCase();
-        }
-
        void invoke() const {
            m_invoker->invoke();
        }

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

    Detail::unique_ptr<TestCaseInfo>
--- a/src/catch2/catch_test_macros.hpp
+++ b/src/catch2/catch_test_macros.hpp
@@ -43,7 +43,6 @@
  #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__ )
@@ -98,7 +97,6 @@
  #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( ... )
@@ -144,7 +142,6 @@
  #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__ )
@@ -198,7 +195,6 @@
  #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( ... )
--- a/src/catch2/catch_timer.cpp
+++ b/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::steady_clock::now().time_since_epoch()).count();
+            return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
        }
    } // end unnamed namespace

--- a/src/catch2/catch_tostring.cpp
+++ b/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 = std::numeric_limits<float>::max_digits10;
+int StringMaker<float>::precision = 5;

 std::string StringMaker<float>::convert(float value) {
    return Detail::fpToString(value, precision) + 'f';
 }

-int StringMaker<double>::precision = std::numeric_limits<double>::max_digits10;
+int StringMaker<double>::precision = 10;

 std::string StringMaker<double>::convert(double value) {
    return Detail::fpToString(value, precision);
--- a/src/catch2/catch_translate_exception.hpp
+++ b/src/catch2/catch_translate_exception.hpp
@@ -25,7 +25,7 @@ namespace Catch {
        class ExceptionTranslator : public IExceptionTranslator {
        public:

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

--- a/src/catch2/catch_version.cpp
+++ b/src/catch2/catch_version.cpp
@@ -36,7 +36,7 @@ namespace Catch {
    }

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

--- a/src/catch2/catch_version_macros.hpp
+++ b/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 7
-#define CATCH_VERSION_PATCH 1
+#define CATCH_VERSION_MINOR 5
+#define CATCH_VERSION_PATCH 3

 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED
--- a/src/catch2/interfaces/catch_interfaces_capture.hpp
+++ b/src/catch2/interfaces/catch_interfaces_capture.hpp
@@ -9,6 +9,7 @@
 #define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED

 #include <string>
+#include <chrono>

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

    class ITestInvoker {
    public:
-        virtual void prepareTestCase();
-        virtual void tearDownTestCase();
        virtual void invoke() const = 0;
        virtual ~ITestInvoker(); // = default
    };
--- a/src/catch2/internal/catch_assertion_handler.cpp
+++ b/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, std::string&& message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, CATCH_MOVE(message), m_reaction );
+    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef message) {
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
    }

    auto AssertionHandler::allowThrows() const -> bool {
--- a/src/catch2/internal/catch_assertion_handler.hpp
+++ b/src/catch2/internal/catch_assertion_handler.hpp
@@ -42,12 +42,12 @@ namespace Catch {


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

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

        void handleExceptionThrownAsExpected();
        void handleUnexpectedExceptionNotThrown();
--- a/src/catch2/internal/catch_case_sensitive.hpp
+++ b/src/catch2/internal/catch_case_sensitive.hpp
--- a/src/catch2/internal/catch_clara.cpp
+++ b/src/catch2/internal/catch_clara.cpp
@@ -76,7 +76,7 @@ namespace Catch {
                                { TokenType::Argument,
                                  next.substr( delimiterPos + 1, next.size() ) } );
                        } else {
-                            if ( next.size() > 1 && next[1] != '-' && next.size() > 2 ) {
+                            if ( next[1] != '-' && next.size() > 2 ) {
                                // Combined short args, e.g. "-ab" for "-a -b"
                                for ( size_t i = 1; i < next.size(); ++i ) {
                                    m_tokenBuffer.push_back(
--- a/src/catch2/internal/catch_context.cpp
+++ b/src/catch2/internal/catch_context.cpp
@@ -27,6 +27,12 @@ namespace Catch {
        return *Context::currentContext;
    }

+    void Context::setResultCapture( IResultCapture* resultCapture ) {
+        m_resultCapture = resultCapture;
+    }
+
+    void Context::setConfig( IConfig const* config ) { m_config = config; }
+
    SimplePcg32& sharedRng() {
        static SimplePcg32 s_rng;
        return s_rng;
--- a/src/catch2/internal/catch_context.hpp
+++ b/src/catch2/internal/catch_context.hpp
@@ -26,15 +26,10 @@ namespace Catch {
        friend void cleanUpContext();

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

    Context& getCurrentMutableContext();
--- a/src/catch2/internal/catch_decomposer.hpp
+++ b/src/catch2/internal/catch_decomposer.hpp
@@ -110,11 +110,9 @@
 #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>)
@@ -127,12 +125,6 @@

 namespace Catch {

-    namespace Detail {
-        // This was added in C++20, but we require only C++14 for now.
-        template <typename T>
-        using RemoveCVRef_t = std::remove_cv_t<std::remove_reference_t<T>>;
-    }
-
    // Note: There is nothing that stops us from extending this,
    //       e.g. to `std::is_scalar`, but the more encompassing
    //       traits are usually also more expensive. For now we
@@ -157,9 +149,6 @@ namespace Catch {
        bool m_isBinaryExpression;
        bool m_result;

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

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

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

    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
@@ -283,17 +276,17 @@ namespace Catch {
 #define CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( id, op )           \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
-        -> std::enable_if_t<                                                   \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
                                Detail::negation<capture_by_value<             \
-                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
+                                    std::remove_reference_t<RhsT>>>>::value,   \
            BinaryExpr<LhsT, RhsT const&>> {                                   \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
                                capture_by_value<RhsT>>::value,                \
            BinaryExpr<LhsT, RhsT>> {                                          \
@@ -302,7 +295,7 @@ namespace Catch {
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_eq_0_comparable<LhsT>,                              \
@@ -316,7 +309,7 @@ namespace Catch {
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_eq_0_comparable<RhsT>,                              \
@@ -337,17 +330,17 @@ namespace Catch {
 #define CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( id, op )         \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
-        -> std::enable_if_t<                                                   \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
                                Detail::negation<capture_by_value<             \
-                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
+                                    std::remove_reference_t<RhsT>>>>::value,   \
            BinaryExpr<LhsT, RhsT const&>> {                                   \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
                                capture_by_value<RhsT>>::value,                \
            BinaryExpr<LhsT, RhsT>> {                                          \
@@ -356,7 +349,7 @@ namespace Catch {
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_##id##_0_comparable<LhsT>,                          \
@@ -368,7 +361,7 @@ namespace Catch {
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_##id##_0_comparable<RhsT>,                          \
@@ -389,16 +382,16 @@ namespace Catch {
 #define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR( op )                        \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
-        -> std::enable_if_t<                                                   \
-            !capture_by_value<Detail::RemoveCVRef_t<RhsT>>::value,             \
+        ->std::enable_if_t<                                                    \
+            !capture_by_value<std::remove_reference_t<RhsT>>::value,           \
            BinaryExpr<LhsT, RhsT const&>> {                                   \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<capture_by_value<RhsT>::value,                     \
-                            BinaryExpr<LhsT, RhsT>> {                          \
+        ->std::enable_if_t<capture_by_value<RhsT>::value,                      \
+                           BinaryExpr<LhsT, RhsT>> {                           \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }
@@ -430,7 +423,8 @@ namespace Catch {

    struct Decomposer {
        template <typename T,
-                  std::enable_if_t<!capture_by_value<Detail::RemoveCVRef_t<T>>::value,
+                  std::enable_if_t<
+                      !capture_by_value<std::remove_reference_t<T>>::value,
                      int> = 0>
        constexpr friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs<T const&> {
            return ExprLhs<const T&>{ lhs };
--- a/src/catch2/internal/catch_is_permutation.hpp
+++ b/src/catch2/internal/catch_is_permutation.hpp
@@ -18,7 +18,6 @@ namespace Catch {
                  typename Sentinel,
                  typename T,
                  typename Comparator>
-        constexpr
        ForwardIter find_sentinel( ForwardIter start,
                                   Sentinel sentinel,
                                   T const& value,
@@ -34,7 +33,6 @@ namespace Catch {
                  typename Sentinel,
                  typename T,
                  typename Comparator>
-        constexpr
        std::ptrdiff_t count_sentinel( ForwardIter start,
                                       Sentinel sentinel,
                                       T const& value,
@@ -48,7 +46,6 @@ namespace Catch {
        }

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

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

@@ -71,11 +68,11 @@ namespace Catch {
                  typename ForwardIter2,
                  typename Sentinel2,
                  typename Comparator>
-        constexpr bool check_element_counts( ForwardIter1 first_1,
-                                             const Sentinel1 end_1,
-                                             ForwardIter2 first_2,
-                                             const Sentinel2 end_2,
-                                             Comparator cmp ) {
+        bool check_element_counts( ForwardIter1 first_1,
+                                   const Sentinel1 end_1,
+                                   ForwardIter2 first_2,
+                                   const Sentinel2 end_2,
+                                   Comparator cmp ) {
            auto cursor = first_1;
            while ( cursor != end_1 ) {
                if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
@@ -105,11 +102,11 @@ namespace Catch {
                  typename ForwardIter2,
                  typename Sentinel2,
                  typename Comparator>
-        constexpr bool is_permutation( ForwardIter1 first_1,
-                                       const Sentinel1 end_1,
-                                       ForwardIter2 first_2,
-                                       const Sentinel2 end_2,
-                                       Comparator cmp ) {
+        bool is_permutation( ForwardIter1 first_1,
+                             const Sentinel1 end_1,
+                             ForwardIter2 first_2,
+                             const Sentinel2 end_2,
+                             Comparator cmp ) {
            // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
            // TODO: Comparator has to be "both sides", e.g. a == b => b == a
            // This skips shared prefix of the two ranges
--- a/src/catch2/internal/catch_lazy_expr.hpp
+++ b/src/catch2/internal/catch_lazy_expr.hpp
@@ -22,13 +22,13 @@ namespace Catch {
        ITransientExpression const* m_transientExpression = nullptr;
        bool m_isNegated;
    public:
-        constexpr LazyExpression( bool isNegated ):
+        LazyExpression( bool isNegated ):
            m_isNegated(isNegated)
        {}
-        constexpr LazyExpression(LazyExpression const& other) = default;
+        LazyExpression(LazyExpression const& other) = default;
        LazyExpression& operator = ( LazyExpression const& ) = delete;

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

--- a/src/catch2/internal/catch_output_redirect.cpp
+++ b/src/catch2/internal/catch_output_redirect.cpp
@@ -5,335 +5,142 @@
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
-#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_enforce.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_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
 #endif

+
 namespace Catch {

-    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( std::ostream& originalStream, std::ostream& redirectionStream )
+    :   m_originalStream( originalStream ),
+        m_redirectionStream( redirectionStream ),
+        m_prevBuf( m_originalStream.rdbuf() )
+    {
+        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
+    }

-        /**
-         * 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 RedirectedStreamNew {
-            std::ostream& m_originalStream;
-            std::ostream& m_redirectionStream;
-            std::streambuf* m_prevBuf;
+    RedirectedStream::~RedirectedStream() {
+        m_originalStream.rdbuf( m_prevBuf );
+    }

-        public:
-            RedirectedStreamNew( std::ostream& originalStream,
-                                 std::ostream& redirectionStream ):
-                m_originalStream( originalStream ),
-                m_redirectionStream( redirectionStream ),
-                m_prevBuf( m_originalStream.rdbuf() ) {}
+    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
+    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }

-            void startRedirect() {
-                m_originalStream.rdbuf( m_redirectionStream.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 stopRedirect() { m_originalStream.rdbuf( m_prevBuf ); }
-        };
+            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.");
+        }
+    }

-        /**
-         * 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;
-            RedirectedStreamNew m_cout, m_cerr, m_clog;
+#endif

-        public:
-            StreamRedirect():
-                m_cout( Catch::cout(), m_redirectedOut.get() ),
-                m_cerr( Catch::cerr(), m_redirectedErr.get() ),
-                m_clog( Catch::clog(), m_redirectedErr.get() ) {}
+    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
+    }

-            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( "" );
-            }
-        };

-#if defined( CATCH_CONFIG_NEW_CAPTURE )
+    FILE* TempFile::getFile() {
+        return m_file;
+    }

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

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

-            ~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
-            }
+    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);

-            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();
-            }
+        dup2(m_originalStdout, 1);
+        dup2(m_originalStderr, 2);

-            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 );
-            }
-        };
+        m_stdoutDest += m_stdoutFile.getContents();
+        m_stderrDest += m_stderrFile.getContents();
+    }

 #endif // CATCH_CONFIG_NEW_CAPTURE

-    } // 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
-        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>();
-#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
--- a/src/catch2/internal/catch_output_redirect.hpp
+++ b/src/catch2/internal/catch_output_redirect.hpp
@@ -8,69 +8,110 @@
 #ifndef CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
 #define CATCH_OUTPUT_REDIRECT_HPP_INCLUDED

-#include <catch2/internal/catch_unique_ptr.hpp>
+#include <catch2/internal/catch_platform.hpp>
+#include <catch2/internal/catch_reusable_string_stream.hpp>
+#include <catch2/internal/catch_compiler_capabilities.hpp>

-#include <cassert>
+#include <cstdio>
+#include <iosfwd>
 #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:
-        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,
-        };
+        OutputRedirect(OutputRedirect const&) = delete;
+        OutputRedirect& operator=(OutputRedirect const&) = delete;
+        OutputRedirect(OutputRedirect&&) = delete;
+        OutputRedirect& operator=(OutputRedirect&&) = delete;

-        virtual ~OutputRedirect(); // = default;

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

-    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 );
+#endif

 } // end namespace Catch

--- a/src/catch2/internal/catch_platform.hpp
+++ b/src/catch2/internal/catch_platform.hpp
@@ -11,9 +11,6 @@
 // See e.g.:
 // https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
 #ifdef __APPLE__
-#  ifndef __has_extension
-#    define __has_extension(x) 0
-#  endif
 #  include <TargetConditionals.h>
 #  if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
      (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
--- a/src/catch2/internal/catch_random_integer_helpers.hpp
+++ b/src/catch2/internal/catch_random_integer_helpers.hpp
@@ -14,34 +14,6 @@
 #include <cstdint>
 #include <type_traits>

-// Note: We use the usual enable-disable-autodetect dance here even though
-//       we do not support these in CMake configuration options (yet?).
-//       It is highly unlikely that we will need to make these actually
-//       user-configurable, but this will make it simpler if weend up needing
-//       it, and it provides an escape hatch to the users who need it.
-#if defined( __SIZEOF_INT128__ )
-#    define CATCH_CONFIG_INTERNAL_UINT128
-// 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
-
-#if defined( CATCH_CONFIG_INTERNAL_UINT128 ) && \
-    !defined( CATCH_CONFIG_NO_UINT128 ) &&      \
-    !defined( CATCH_CONFIG_UINT128 )
-#define CATCH_CONFIG_UINT128
-#endif
-
-#if defined( CATCH_CONFIG_INTERNAL_MSVC_UMUL128 ) && \
-    !defined( CATCH_CONFIG_NO_MSVC_UMUL128 ) &&      \
-    !defined( CATCH_CONFIG_MSVC_UMUL128 )
-#    define CATCH_CONFIG_MSVC_UMUL128
-#    include <intrin.h>
-#endif
-
-
 namespace Catch {
    namespace Detail {

@@ -69,57 +41,64 @@ namespace Catch {
        struct ExtendedMultResult {
            T upper;
            T lower;
-            constexpr bool operator==( ExtendedMultResult const& rhs ) const {
+            bool operator==( ExtendedMultResult const& rhs ) const {
                return upper == rhs.upper && lower == rhs.lower;
            }
        };

-        /**
-         * Returns 128 bit result of lhs * rhs using portable C++ code
-         *
-         * This implementation is almost twice as fast as naive long multiplication,
-         * and unlike intrinsic-based approach, it supports constexpr evaluation.
-         */
+        // Returns 128 bit result of multiplying lhs and rhs
        constexpr ExtendedMultResult<std::uint64_t>
-        extendedMultPortable(std::uint64_t lhs, std::uint64_t rhs) {
+        extendedMult( std::uint64_t lhs, std::uint64_t rhs ) {
+            // We use the simple long multiplication approach for
+            // correctness, we can use platform specific builtins
+            // for performance later.
+
+            // Split the lhs and rhs into two 32bit "digits", so that we can
+            // do 64 bit arithmetic to handle carry bits.
+            //            32b    32b    32b    32b
+            //     lhs                  L1     L2
+            //   * rhs                  R1     R2
+            //            ------------------------
+            //                       |  R2 * L2  |
+            //                 |  R2 * L1  |
+            //                 |  R1 * L2  |
+            //           |  R1 * L1  |
+            //           -------------------------
+            //           |  a  |  b  |  c  |  d  |
+
 #define CarryBits( x ) ( x >> 32 )
 #define Digits( x ) ( x & 0xFF'FF'FF'FF )
-            std::uint64_t lhs_low = Digits( lhs );
-            std::uint64_t rhs_low = Digits( rhs );
-            std::uint64_t low_low = ( lhs_low * rhs_low );
-            std::uint64_t high_high = CarryBits( lhs ) * CarryBits( rhs );

-            // We add in carry bits from low-low already
-            std::uint64_t high_low =
-                ( CarryBits( lhs ) * rhs_low ) + CarryBits( low_low );
-            // Note that we can add only low bits from high_low, to avoid
-            // overflow with large inputs
-            std::uint64_t low_high =
-                ( lhs_low * CarryBits( rhs ) ) + Digits( high_low );
+            auto r2l2 = Digits( rhs ) * Digits( lhs );
+            auto r2l1 = Digits( rhs ) * CarryBits( lhs );
+            auto r1l2 = CarryBits( rhs ) * Digits( lhs );
+            auto r1l1 = CarryBits( rhs ) * CarryBits( lhs );
+
+            // Sum to columns first
+            auto d = Digits( r2l2 );
+            auto c = CarryBits( r2l2 ) + Digits( r2l1 ) + Digits( r1l2 );
+            auto b = CarryBits( r2l1 ) + CarryBits( r1l2 ) + Digits( r1l1 );
+            auto a = CarryBits( r1l1 );
+
+            // Propagate carries between columns
+            c += CarryBits( d );
+            b += CarryBits( c );
+            a += CarryBits( b );
+
+            // Remove the used carries
+            c = Digits( c );
+            b = Digits( b );
+            a = Digits( a );

-            return { high_high + CarryBits( high_low ) + CarryBits( low_high ),
-                     ( low_high << 32 ) | Digits( low_low ) };
 #undef CarryBits
 #undef Digits
-        }

-        //! Returns 128 bit result of lhs * rhs
-        inline ExtendedMultResult<std::uint64_t>
-        extendedMult( std::uint64_t lhs, std::uint64_t rhs ) {
-#if defined( CATCH_CONFIG_UINT128 )
-            auto result = __uint128_t( lhs ) * __uint128_t( rhs );
-            return { static_cast<std::uint64_t>( result >> 64 ),
-                     static_cast<std::uint64_t>( result ) };
-#elif defined( CATCH_CONFIG_MSVC_UMUL128 )
-            std::uint64_t high;
-            std::uint64_t low = _umul128( lhs, rhs, &high );
-            return { high, low };
-#else
-            return extendedMultPortable( lhs, rhs );
-#endif
+            return {
+                a << 32 | b, // upper 64 bits
+                c << 32 | d  // lower 64 bits
+            };
        }

-
        template <typename UInt>
        constexpr ExtendedMultResult<UInt> extendedMult( UInt lhs, UInt rhs ) {
            static_assert( std::is_unsigned<UInt>::value,
@@ -187,7 +166,6 @@ namespace Catch {
         * get by simple casting ([0, ..., INT_MAX, INT_MIN, ..., -1])
         */
        template <typename OriginalType, typename UnsignedType>
-        constexpr
        std::enable_if_t<std::is_signed<OriginalType>::value, UnsignedType>
        transposeToNaturalOrder( UnsignedType in ) {
            static_assert(
@@ -208,7 +186,6 @@ namespace Catch {

        template <typename OriginalType,
                  typename UnsignedType>
-        constexpr
        std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
            transposeToNaturalOrder(UnsignedType in) {
            static_assert(
--- a/src/catch2/internal/catch_result_type.cpp
+++ b/src/catch2/internal/catch_result_type.cpp
@@ -0,0 +1,26 @@
+
+//              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
--- a/src/catch2/internal/catch_result_type.hpp
+++ b/src/catch2/internal/catch_result_type.hpp
@@ -33,10 +33,8 @@ namespace Catch {

    }; };

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


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

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

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

 } // end namespace Catch

--- a/src/catch2/internal/catch_run_context.cpp
+++ b/src/catch2/internal/catch_run_context.cpp
@@ -170,7 +170,6 @@ 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 );
@@ -186,7 +185,6 @@ namespace Catch {

        auto const& testInfo = testCase.getTestCaseInfo();
        m_reporter->testCaseStarting(testInfo);
-        testCase.prepareTestCase();
        m_activeTestCase = &testCase;


@@ -237,17 +235,15 @@ namespace Catch {
            m_reporter->testCasePartialStarting(testInfo, testRuns);

            const auto beforeRunTotals = m_totals;
-            runCurrentTest();
-            std::string oneRunCout = m_outputRedirect->getStdout();
-            std::string oneRunCerr = m_outputRedirect->getStderr();
-            m_outputRedirect->clearBuffers();
+            std::string oneRunCout, oneRunCerr;
+            runCurrentTest(oneRunCout, oneRunCerr);
            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);

+            m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
            ++testRuns;
        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());

@@ -258,7 +254,6 @@ namespace Catch {
            deltaTotals.testCases.failed++;
        }
        m_totals.testCases += deltaTotals.testCases;
-        testCase.tearDownTestCase();
        m_reporter->testCaseEnded(TestCaseStats(testInfo,
                                  deltaTotals,
                                  CATCH_MOVE(redirectedCout),
@@ -292,10 +287,7 @@ namespace Catch {
            m_lastAssertionPassed = true;
        }

-        {
-            auto _ = scopedDeactivate( *m_outputRedirect );
-            m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) );
-        }
+        m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals));

        if ( result.getResultType() != ResultWas::Warning ) {
            m_messageScopes.clear();
@@ -312,7 +304,6 @@ namespace Catch {
    }

    void RunContext::notifyAssertionStarted( AssertionInfo const& info ) {
-        auto _ = scopedDeactivate( *m_outputRedirect );
        m_reporter->assertionStarting( info );
    }

@@ -331,10 +322,7 @@ namespace Catch {
        SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) );
        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;

-        {
-            auto _ = scopedDeactivate( *m_outputRedirect );
-            m_reporter->sectionStarting( sectionInfo );
-        }
+        m_reporter->sectionStarting(sectionInfo);

        assertions = m_totals.assertions;

@@ -394,15 +382,7 @@ namespace Catch {
            m_activeSections.pop_back();
        }

-        {
-            auto _ = scopedDeactivate( *m_outputRedirect );
-            m_reporter->sectionEnded(
-                SectionStats( CATCH_MOVE( endInfo.sectionInfo ),
-                              assertions,
-                              endInfo.durationInSeconds,
-                              missingAssertions ) );
-        }
-
+        m_reporter->sectionEnded(SectionStats(CATCH_MOVE(endInfo.sectionInfo), assertions, endInfo.durationInSeconds, missingAssertions));
        m_messages.clear();
        m_messageScopes.clear();
    }
@@ -419,19 +399,15 @@ namespace Catch {
    }

    void RunContext::benchmarkPreparing( StringRef name ) {
-        auto _ = scopedDeactivate( *m_outputRedirect );
-        m_reporter->benchmarkPreparing( name );
+        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 );
    }

@@ -462,13 +438,8 @@ 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.
@@ -479,13 +450,6 @@ 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)
@@ -495,7 +459,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();

@@ -526,7 +490,7 @@ namespace Catch {
        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
    }

-    void RunContext::runCurrentTest() {
+    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
        m_reporter->sectionStarting(testCaseSection);
@@ -537,8 +501,18 @@ namespace Catch {

        Timer timer;
        CATCH_TRY {
-            {
-                auto _ = scopedActivate( *m_outputRedirect );
+            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 {
                timer.start();
                invokeActiveTestCase();
            }
@@ -583,12 +557,11 @@ 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();
    }

@@ -632,13 +605,13 @@ namespace Catch {
    void RunContext::handleMessage(
            AssertionInfo const& info,
            ResultWas::OfType resultType,
-            std::string&& message,
+            StringRef message,
            AssertionReaction& reaction
    ) {
        m_lastAssertionInfo = info;

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

--- a/src/catch2/internal/catch_run_context.hpp
+++ b/src/catch2/internal/catch_run_context.hpp
@@ -29,7 +29,6 @@ namespace Catch {
    class IConfig;
    class IEventListener;
    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
-    class OutputRedirect;

    ///////////////////////////////////////////////////////////////////////////

@@ -55,7 +54,7 @@ namespace Catch {
        void handleMessage
                (   AssertionInfo const& info,
                    ResultWas::OfType resultType,
-                    std::string&& message,
+                    StringRef message,
                    AssertionReaction& reaction ) override;
        void handleUnexpectedExceptionNotThrown
                (   AssertionInfo const& info,
@@ -116,7 +115,7 @@ namespace Catch {

    private:

-        void runCurrentTest();
+        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
        void invokeActiveTestCase();

        void resetAssertionInfo();
@@ -149,7 +148,6 @@ 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;
--- a/src/catch2/internal/catch_test_case_registry_impl.cpp
+++ b/src/catch2/internal/catch_test_case_registry_impl.cpp
@@ -123,8 +123,6 @@ namespace Catch {
        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
    }

-    TestRegistry::~TestRegistry() = default;
-
    void TestRegistry::registerTest(Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker) {
        m_handles.emplace_back(testInfo.get(), testInvoker.get());
        m_viewed_test_infos.push_back(testInfo.get());
--- a/src/catch2/internal/catch_test_case_registry_impl.hpp
+++ b/src/catch2/internal/catch_test_case_registry_impl.hpp
@@ -36,8 +36,6 @@ namespace Catch {
        std::vector<TestCaseHandle> const& getAllTests() const override;
        std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const override;

-        ~TestRegistry() override; // = default
-
    private:
        std::vector<Detail::unique_ptr<TestCaseInfo>> m_owned_test_infos;
        // Keeps a materialized vector for `getAllInfos`.
--- a/src/catch2/internal/catch_test_macro_impl.hpp
+++ b/src/catch2/internal/catch_test_macro_impl.hpp
@@ -38,6 +38,8 @@

 #endif

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

@@ -78,7 +80,7 @@
        catch( ... ) { \
            catchAssertionHandler.handleUnexpectedInflightException(); \
        } \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

 ///////////////////////////////////////////////////////////////////////////////
@@ -99,7 +101,7 @@
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

 ///////////////////////////////////////////////////////////////////////////////
@@ -123,7 +125,7 @@
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )


@@ -147,7 +149,7 @@
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

 #endif // CATCH_CONFIG_DISABLE
--- a/src/catch2/internal/catch_test_registry.cpp
+++ b/src/catch2/internal/catch_test_registry.cpp
@@ -16,8 +16,6 @@
 #include <iterator>

 namespace Catch {
-    void ITestInvoker::prepareTestCase() {}
-    void ITestInvoker::tearDownTestCase() {}
    ITestInvoker::~ITestInvoker() = default;

    namespace {
@@ -54,7 +52,7 @@ namespace Catch {
            TestType m_testAsFunction;

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

            void invoke() const override { m_testAsFunction(); }
--- a/src/catch2/internal/catch_test_registry.hpp
+++ b/src/catch2/internal/catch_test_registry.hpp
@@ -32,8 +32,7 @@ template<typename C>
 class TestInvokerAsMethod : public ITestInvoker {
    void (C::*m_testAsMethod)();
 public:
-    constexpr TestInvokerAsMethod( void ( C::*testAsMethod )() ) noexcept:
-        m_testAsMethod( testAsMethod ) {}
+    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}

    void invoke() const override {
        C obj;
@@ -48,34 +47,6 @@ 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:
@@ -172,26 +143,6 @@ 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, ... ) \
--- a/src/catch2/internal/catch_textflow.cpp
+++ b/src/catch2/internal/catch_textflow.cpp
@@ -26,228 +26,117 @@ 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;

-            if ( m_parsedTo == current_line.end() ) {
-                m_lineEnd = m_parsedTo;
-                return;
+            std::string const& current_line = m_column.m_string;
+            if ( current_line[m_lineStart] == '\n' ) {
+                ++m_parsedTo;
            }

-            assert( m_lineStart != current_line.end() );
-            if ( *m_lineStart == '\n' ) { ++m_parsedTo; }
-
            const auto maxLineLength = m_column.m_width - indentSize();
-            std::size_t lineLength = 0;
-            while ( m_parsedTo != current_line.end() &&
-                    lineLength < maxLineLength && *m_parsedTo != '\n' ) {
+            const auto maxParseTo = std::min(current_line.size(), m_lineStart + maxLineLength);
+            while ( m_parsedTo < maxParseTo &&
+                    current_line[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 ( lineLength < maxLineLength ) {
-                m_lineEnd = m_parsedTo;
+            if ( m_parsedTo < m_lineStart + maxLineLength ) {
+                m_lineLength = m_parsedTo - m_lineStart;
            } 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)
-                m_lineEnd = m_parsedTo;
-                while ( lineLength > 0 &&
-                        !isBoundary( current_line, m_lineEnd ) ) {
-                    --lineLength;
-                    --m_lineEnd;
+                size_t newLineLength = maxLineLength;
+                while ( newLineLength > 0 && !isBoundary( current_line, m_lineStart + newLineLength ) ) {
+                    --newLineLength;
                }
-                while ( lineLength > 0 &&
-                        isWhitespace( *m_lineEnd.oneBefore() ) ) {
-                    --lineLength;
-                    --m_lineEnd;
+                while ( newLineLength > 0 &&
+                        isWhitespace( current_line[m_lineStart + newLineLength - 1] ) ) {
+                    --newLineLength;
                }

-                // If we found one, then that is where we linebreak, otherwise
-                // we have to split text with a hyphen
-                if ( lineLength == 0 ) {
+                // 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
                    m_addHyphen = true;
-                    m_lineEnd = m_parsedTo.oneBefore();
+                    m_lineLength = maxLineLength - 1;
                }
            }
        }

        size_t Column::const_iterator::indentSize() const {
-            auto initial = m_lineStart == m_column.m_string.begin()
-                               ? m_column.m_initialIndent
-                               : std::string::npos;
+            auto initial =
+                m_lineStart == 0 ? m_column.m_initialIndent : std::string::npos;
            return initial == std::string::npos ? m_column.m_indent : initial;
        }

-        std::string Column::const_iterator::addIndentAndSuffix(
-            AnsiSkippingString::const_iterator start,
-            AnsiSkippingString::const_iterator end ) const {
+        std::string
+        Column::const_iterator::addIndentAndSuffix( size_t position,
+                                              size_t length ) const {
            std::string ret;
            const auto desired_indent = indentSize();
-            // ret.reserve( desired_indent + (end - start) + m_addHyphen );
+            ret.reserve( desired_indent + length + m_addHyphen );
            ret.append( desired_indent, ' ' );
-            // ret.append( start, end );
-            ret += m_column.m_string.substring( start, end );
-            if ( m_addHyphen ) { ret.push_back( '-' ); }
+            ret.append( m_column.m_string, position, length );
+            if ( m_addHyphen ) {
+                ret.push_back( '-' );
+            }

            return ret;
        }

-        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() ) {
+        Column::const_iterator::const_iterator( Column const& column ): m_column( column ) {
            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_lineStart == m_lineEnd ) {
-                m_lineStart = m_column.m_string.end();
+            if ( m_lineLength == 0 ) {
+                m_lineStart = m_column.m_string.size();
            }
        }

        std::string Column::const_iterator::operator*() const {
            assert( m_lineStart <= m_parsedTo );
-            return addIndentAndSuffix( m_lineStart, m_lineEnd );
+            return addIndentAndSuffix( m_lineStart, m_lineLength );
        }

        Column::const_iterator& Column::const_iterator::operator++() {
-            m_lineStart = m_lineEnd;
-            AnsiSkippingString const& current_line = m_column.m_string;
-            if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) {
-                m_lineStart++;
+            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;
            } else {
-                while ( m_lineStart != current_line.end() &&
-                        isWhitespace( *m_lineStart ) ) {
+                while ( m_lineStart < current_line.size() &&
+                        isWhitespace( current_line[m_lineStart] ) ) {
                    ++m_lineStart;
                }
            }

-            if ( m_lineStart != current_line.end() ) { calcLength(); }
+            if ( m_lineStart != current_line.size() ) {
+                calcLength();
+            }
            return *this;
        }

@@ -344,25 +233,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 ) {
--- a/src/catch2/internal/catch_textflow.hpp
+++ b/src/catch2/internal/catch_textflow.hpp
@@ -20,107 +20,6 @@ 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
         *
@@ -130,11 +29,10 @@ namespace Catch {
         */
        class Column {
            // String to be written out
-            AnsiSkippingString m_string;
+            std::string 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;
@@ -149,19 +47,16 @@ namespace Catch {

                Column const& m_column;
                // Where does the current line start?
-                AnsiSkippingString::const_iterator m_lineStart;
+                size_t m_lineStart = 0;
                // How long should the current line be?
-                AnsiSkippingString::const_iterator m_lineEnd;
+                size_t m_lineLength = 0;
                // How far have we checked the string to iterate?
-                AnsiSkippingString::const_iterator m_parsedTo;
+                size_t m_parsedTo = 0;
                // 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.end() ),
-                    m_lineEnd( column.m_string.end() ),
-                    m_parsedTo( column.m_string.end() ) {}
+                    m_column( column ), m_lineStart( m_column.m_string.size() ) {}

                // Calculates the length of the current line
                void calcLength();
@@ -171,9 +66,8 @@ namespace Catch {

                // Creates an indented and (optionally) suffixed string from
                // current iterator position, indentation and length.
-                std::string addIndentAndSuffix(
-                    AnsiSkippingString::const_iterator start,
-                    AnsiSkippingString::const_iterator end ) const;
+                std::string addIndentAndSuffix( size_t position,
+                                                size_t length ) const;

            public:
                using difference_type = std::ptrdiff_t;
@@ -190,8 +84,7 @@ 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 );
@@ -201,7 +94,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 );
@@ -232,9 +125,7 @@ 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 );
--- a/src/catch2/internal/catch_uniform_integer_distribution.hpp
+++ b/src/catch2/internal/catch_uniform_integer_distribution.hpp
@@ -13,6 +13,22 @@

 namespace Catch {

+    namespace Detail {
+        // Indirection to enable make_unsigned<bool> behaviour.
+        template <typename T>
+        struct make_unsigned {
+            using type = std::make_unsigned_t<T>;
+        };
+
+        template <>
+        struct make_unsigned<bool> {
+            using type = uint8_t;
+        };
+
+        template <typename T>
+        using make_unsigned_t = typename make_unsigned<T>::type;
+    }
+
 /**
 * Implementation of uniform distribution on integers.
 *
@@ -28,7 +44,7 @@ template <typename IntegerType>
 class uniform_integer_distribution {
    static_assert(std::is_integral<IntegerType>::value, "...");

-    using UnsignedIntegerType = Detail::SizedUnsignedType_t<sizeof(IntegerType)>;
+    using UnsignedIntegerType = Detail::make_unsigned_t<IntegerType>;

    // Only the left bound is stored, and we store it converted to its
    // unsigned image. This avoids having to do the conversions inside
@@ -48,24 +64,24 @@ class uniform_integer_distribution {
    // distribution will be reused many times and this is an optimization.
    UnsignedIntegerType m_rejection_threshold = 0;

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

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

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

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

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

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

 } // end namespace Catch
--- a/src/catch2/internal/catch_wildcard_pattern.hpp
+++ b/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/catch_case_sensitive.hpp>
+#include <catch2/internal/catch_case_sensitive.hpp>

 #include <string>

--- a/src/catch2/internal/catch_xmlwriter.cpp
+++ b/src/catch2/internal/catch_xmlwriter.cpp
@@ -53,16 +53,36 @@ namespace {
        os.flags(f);
    }

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

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

 } // anonymous namespace

+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) |
+            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
+        );
+    }
+
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) &
+            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
+        );
+    }
+
+
+    XmlEncode::XmlEncode( StringRef str, ForWhat forWhat )
+    :   m_str( str ),
+        m_forWhat( forWhat )
+    {}
+
    void XmlEncode::encodeTo( std::ostream& os ) const {
        // Apostrophe escaping not necessary if we always use " to write attributes
        // (see: http://www.w3.org/TR/xml/#syntax)
--- a/src/catch2/internal/catch_xmlwriter.hpp
+++ b/src/catch2/internal/catch_xmlwriter.hpp
@@ -13,25 +13,16 @@

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

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

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

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

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

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

--- a/src/catch2/matchers/catch_matchers_floating_point.cpp
+++ b/src/catch2/matchers/catch_matchers_floating_point.cpp
@@ -176,7 +176,7 @@ namespace Detail {

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

--- a/src/catch2/matchers/catch_matchers_range_equals.hpp
+++ b/src/catch2/matchers/catch_matchers_range_equals.hpp
@@ -28,14 +28,12 @@ namespace Catch {

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

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

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

            template <typename RangeLike>
-            constexpr
            bool match( RangeLike&& rng ) const {
                using std::begin;
                using std::end;
@@ -99,7 +95,6 @@ namespace Catch {
         * Uses `std::equal_to` to do the comparison
         */
        template <typename RangeLike>
-        constexpr
        std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
                         RangeEqualsMatcher<RangeLike, std::equal_to<>>>
        RangeEquals( RangeLike&& range ) {
@@ -113,7 +108,6 @@ namespace Catch {
         * Uses to provided predicate `predicate` to do the comparisons
         */
        template <typename RangeLike, typename Equality>
-        constexpr
        RangeEqualsMatcher<RangeLike, Equality>
        RangeEquals( RangeLike&& range, Equality&& predicate ) {
            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
@@ -126,7 +120,6 @@ namespace Catch {
         * Uses `std::equal_to` to do the comparison
         */
        template <typename RangeLike>
-        constexpr
        std::enable_if_t<
            !Detail::is_matcher<RangeLike>::value,
            UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
@@ -141,7 +134,6 @@ namespace Catch {
         * Uses to provided predicate `predicate` to do the comparisons
         */
        template <typename RangeLike, typename Equality>
-        constexpr
        UnorderedRangeEqualsMatcher<RangeLike, Equality>
        UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
--- a/src/catch2/matchers/catch_matchers_string.hpp
+++ b/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/internal/catch_stringref.hpp>
 #include <catch2/matchers/catch_matchers.hpp>
-#include <catch2/catch_case_sensitive.hpp>
+#include <catch2/internal/catch_case_sensitive.hpp>
+#include <catch2/internal/catch_stringref.hpp>

 #include <string>

--- a/src/catch2/matchers/internal/catch_matchers_impl.hpp
+++ b/src/catch2/matchers/internal/catch_matchers_impl.hpp
@@ -18,22 +18,12 @@

 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:
-        constexpr MatchExpr( ArgT && arg, MatcherT const& matcher )
+        MatchExpr( ArgT && arg, MatcherT const& matcher )
        :   ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
            m_arg( CATCH_FORWARD(arg) ),
            m_matcher( matcher )
@@ -46,13 +36,6 @@ namespace Catch {
        }
    };

-#ifdef __clang__
-#    pragma clang diagnostic pop
-#elif defined __GNUC__
-#    pragma GCC diagnostic pop
-#endif
-
-
    namespace Matchers {
        template <typename ArgT>
        class MatcherBase;
@@ -63,8 +46,7 @@ namespace Catch {
    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );

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

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


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


--- a/src/catch2/meson.build
+++ b/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,7 +173,6 @@ 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',
@@ -234,6 +233,7 @@ 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',
--- a/src/catch2/reporters/catch_reporter_junit.cpp
+++ b/src/catch2/reporters/catch_reporter_junit.cpp
@@ -88,7 +88,7 @@ namespace Catch {
            xml( m_stream )
        {
            m_preferences.shouldRedirectStdOut = true;
-            m_preferences.shouldReportAllAssertions = false;
+            m_preferences.shouldReportAllAssertions = true;
            m_shouldStoreSuccesfulAssertions = false;
        }

@@ -198,7 +198,7 @@ namespace Catch {
        if( !rootName.empty() )
            name = rootName + '/' + name;

-        if ( sectionNode.stats.assertions.total() > 0
+        if( sectionNode.hasAnyAssertions()
           || !sectionNode.stdOut.empty()
           || !sectionNode.stdErr.empty() ) {
            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
--- a/src/catch2/reporters/catch_reporter_sonarqube.cpp
+++ b/src/catch2/reporters/catch_reporter_sonarqube.cpp
@@ -73,9 +73,9 @@ namespace Catch {
        if (!rootName.empty())
            name = rootName + '/' + name;

-        if ( sectionNode.stats.assertions.total() > 0
+        if ( sectionNode.hasAnyAssertions()
            || !sectionNode.stdOut.empty()
-            || !sectionNode.stdErr.empty() ) {
+            ||  !sectionNode.stdErr.empty() ) {
            XmlWriter::ScopedElement e = xml.scopedElement("testCase");
            xml.writeAttribute("name"_sr, name);
            xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
--- a/src/catch2/reporters/catch_reporter_sonarqube.hpp
+++ b/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 = false;
+            m_preferences.shouldReportAllAssertions = true;
            m_shouldStoreSuccesfulAssertions = false;
        }

--- a/tests/BUILD.bazel
+++ b/tests/BUILD.bazel
@@ -1,83 +0,0 @@
-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",
-    ],
-)
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -59,7 +59,7 @@ if (CATCH_BUILD_SURROGATES)
  )
  target_link_libraries(Catch2SurrogateTarget PRIVATE Catch2WithMain)

-endif()
+endif(CATCH_BUILD_SURROGATES)

 ####
 # Temporary workaround for VS toolset changes in 2017
@@ -70,7 +70,7 @@ if (MSVC)
 configure_file(${CATCH_DIR}/tools/misc/SelfTest.vcxproj.user
               ${CMAKE_BINARY_DIR}/tests
               COPYONLY)
-endif() #Temporary workaround
+endif(MSVC) #Temporary workaround


 # define the sources of the self test
--- a/tests/ExtraTests/CMakeLists.txt
+++ b/tests/ExtraTests/CMakeLists.txt
@@ -183,7 +183,7 @@ if (NOT WIN32)
    PROPERTIES
      PASS_REGULAR_EXPRESSION "Catch will terminate"
  )
-endif()
+endif(NOT WIN32)


 add_test(NAME CATCH_CONFIG_DISABLE_EXCEPTIONS-3 COMMAND DisabledExceptions-CustomHandler "Tests that run")
@@ -467,18 +467,6 @@ 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
@@ -568,7 +556,6 @@ add_executable(AmalgamatedTestCompilation
  ${CATCH_DIR}/extras/catch_amalgamated.cpp
 )
 target_include_directories(AmalgamatedTestCompilation PRIVATE ${CATCH_DIR}/extras)
-target_compile_features(AmalgamatedTestCompilation PRIVATE cxx_std_14)

 add_test(NAME AmalgamatedFileTest COMMAND AmalgamatedTestCompilation)
 set_tests_properties(
--- a/tests/ExtraTests/X02-DisabledMacros.cpp
+++ b/tests/ExtraTests/X02-DisabledMacros.cpp
@@ -11,28 +11,34 @@
 * and expressions in assertion macros are not run.
 */

-#include <catch2/benchmark/catch_benchmark.hpp>
+
 #include <catch2/catch_test_macros.hpp>
+#include <catch2/benchmark/catch_benchmark.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
@@ -54,26 +60,6 @@ TEST_CASE( "Disabled Macros" ) {
    BENCHMARK( "Disabled benchmark" ) { REQUIRE( 1 == 2 ); };
 }

-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
+#if defined(__clang__)
+#pragma clang diagnostic pop
 #endif
--- a/tests/ExtraTests/X36-ReportingCrashWithJunitReporter.cpp
+++ b/tests/ExtraTests/X36-ReportingCrashWithJunitReporter.cpp
@@ -1,32 +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
-
-/**\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
-    }
-}
--- a/tests/SelfTest/Baselines/automake.sw.approved.txt
+++ b/tests/SelfTest/Baselines/automake.sw.approved.txt
@@ -68,8 +68,6 @@ 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>
@@ -105,7 +103,6 @@ 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
@@ -357,6 +354,7 @@ 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
--- a/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
@@ -66,8 +66,6 @@
 :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,7 +101,6 @@
 :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
@@ -346,6 +343,7 @@
 :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
--- a/tests/SelfTest/Baselines/compact.sw.approved.txt
+++ b/tests/SelfTest/Baselines/compact.sw.approved.txt
@@ -241,10 +241,6 @@ 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
@@ -253,22 +249,12 @@ 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.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 )
+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 )
 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>
@@ -277,8 +263,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.29999999999999716 != Approx( 100.0 )
-Approx.tests.cpp:<line number>: passed: 100.3 == Approx(100.0).margin(0.5) for: 100.29999999999999716 == 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 )
 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
@@ -296,33 +282,19 @@ 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.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: 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: 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.233999968f
-==
-Approx( 1.23399999999999999 )
-Approx.tests.cpp:<line number>: passed: dMedium == Approx( 1.234f ) for: 1.23399999999999999
-==
-Approx( 1.23399996757507324 )
+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 )
 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"
@@ -389,12 +361,6 @@ 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: {?}
@@ -543,7 +509,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.00000099999999748 != Approx( 100.0 )
+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: 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"
@@ -563,39 +529,27 @@ 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.01000000000000512 != Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 101.01 != Approx(100).epsilon(0.01) for: 101.01 != 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.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.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.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.30000000000000027
-==
-Approx( 1.30099999999999993 )
+Condition.tests.cpp:<line number>: failed: x == Approx( 1.301 ) for: 1.3 == Approx( 1.301 )
 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.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.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.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.30000000000000027
-==
-Approx( 1.30000000000000004 )
+Condition.tests.cpp:<line number>: passed: x == Approx( 1.3 ) for: 1.3 == Approx( 1.3 )
 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"
@@ -642,21 +596,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.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: 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: 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.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: 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: 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.59999999999999964
+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: 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.00000000000000022 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.0 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])
@@ -664,7 +618,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.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 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 )
@@ -672,23 +626,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.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: 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: 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.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( 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( -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.60000038146972656
+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: 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.000000119f 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.0f 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])
@@ -696,7 +650,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.00100000004749745 of 0.0 or and 0.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.001 of 0.0 or and 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 )
@@ -876,122 +830,68 @@ 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.90000000000000002
-==
-Approx( -0.90000000000000002 ) with 1 message: 'Current expected value is -0.9'
+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.next() for: true with 1 message: 'Current expected value is -0.9'
-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.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.next() for: true with 1 message: 'Current expected value is -0.8'
-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.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.next() for: true with 1 message: 'Current expected value is -0.7'
-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.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.next() for: true with 1 message: 'Current expected value is -0.6'
-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.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.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.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.next() for: true with 1 message: 'Current expected value is -0.4'
-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.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.next() for: true with 1 message: 'Current expected value is -0.3'
-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.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.next() for: true with 1 message: 'Current expected value is -0.2'
-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.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.next() for: true with 1 message: 'Current expected value is -0.1'
-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.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.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.09999999999999987
-==
-Approx( 0.09999999999999987 ) with 1 message: 'Current expected value is 0.1'
+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.next() for: true with 1 message: 'Current expected value is 0.1'
-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.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.next() for: true with 1 message: 'Current expected value is 0.2'
-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.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.next() for: true with 1 message: 'Current expected value is 0.3'
-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.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.next() for: true with 1 message: 'Current expected value is 0.4'
-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.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.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.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.next() for: true with 1 message: 'Current expected value is 0.6'
-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.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.next() for: true with 1 message: 'Current expected value is 0.7'
-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.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.next() for: true with 1 message: 'Current expected value is 0.8'
-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.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.next() for: true with 1 message: 'Current expected value is 0.9'
-GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx( rangeEnd ) for: 0.99999999999999978 == Approx( 1.0 )
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx( rangeEnd ) for: 1.0 == 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.69999999999999996
-==
-Approx( -0.69999999999999996 ) with 1 message: 'Current expected value is -0.7'
+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.next() for: true with 1 message: 'Current expected value is -0.7'
-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.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.next() for: true with 1 message: 'Current expected value is -0.4'
-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.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.next() for: true with 1 message: 'Current expected value is -0.1'
-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.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.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.69999999999999996
-==
-Approx( -0.69999999999999996 ) with 1 message: 'Current expected value is -0.7'
+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.next() for: true with 1 message: 'Current expected value is -0.7'
-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.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.next() for: true with 1 message: 'Current expected value is -0.4'
-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.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.next() for: true with 1 message: 'Current expected value is -0.1'
-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.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.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'
@@ -1022,18 +922,10 @@ 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.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 )
+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 )
 TestCaseInfoHasher.tests.cpp:<line number>: passed: h1( dummy ) != h2( dummy ) for: 3422778688 (0x<hex digits>)
 !=
 130711275 (0x<hex digits>)
@@ -1072,25 +964,17 @@ 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.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.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.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.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.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.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"
@@ -1181,18 +1065,10 @@ 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.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 )
+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 )
 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" )
@@ -1259,9 +1135,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.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.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.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"
@@ -1278,9 +1154,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.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.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.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"
@@ -1478,9 +1354,7 @@ 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.98999999999999999
-==
-Approx( 0.98999999999999999 )
+CmdLine.tests.cpp:<line number>: passed: config.benchmarkConfidenceInterval == Catch::Approx(0.99) for: 0.99 == Approx( 0.99 )
 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: {?}
@@ -1735,30 +1609,14 @@ 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.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
+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
 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"
@@ -2167,7 +2025,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.14000000000000012'
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: '3.14'
 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
@@ -2313,26 +2171,14 @@ 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.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
+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
 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 }
@@ -2507,15 +2353,9 @@ 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.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: 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: 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:
@@ -2592,15 +2432,14 @@ 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_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 )
+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 )
 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'
@@ -2770,19 +2609,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.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: "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: "{ 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.5f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.5f }"
+ToStringTuple.tests.cpp:<line number>: passed: "{ { 42 }, { }, 1.2f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.2f }"
 ==
-"{ { 42 }, { }, 1.5f }"
+"{ { 42 }, { }, 1.2f }"
 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.94999999999999996 == 0.94999999999999996
+InternalBenchmark.tests.cpp:<line number>: passed: e.confidence_interval == 0.95 for: 0.95 == 0.95
 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: !{?}
@@ -2850,7 +2689,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:  419 |  313 passed |  86 failed | 6 skipped | 14 failed as expected
-assertions: 2265 | 2083 passed | 147 failed | 35 failed as expected
+test cases:  417 |  312 passed |  85 failed | 6 skipped | 14 failed as expected
+assertions: 2260 | 2079 passed | 146 failed | 35 failed as expected


--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Chris Thrasher	7ee2173aca	Update CI image to macOS 14	2024-03-12 12:47:55 -06:00
Chris Thrasher	20d3f1939d	Ignore C++98 related compiler warnings Catch2 has long since required a standard newer than C++98 so we can safely ignore any warnings related to such old standards.	2024-03-12 11:27:06 -06:00