Remove redundant destructors

Classes will automatically inherit the virtual-ness of their base class destructors. If the base class already has a virtual destructor and the derived class needs default destructor semantics then the derived class can omit defining the destructor in favor of the compiler automatically defining it. This has an additional benefit of reenabling move semantics. The presence of a user-specified destructor automatically disables move operations.
2025-09-13 17:05:39 +02:00 · 2023-12-30 18:56:54 -07:00
181 changed files with 3427 additions and 8297 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,81 +0,0 @@
---
-# Note: Alas, `Checks` is a string, not an array.
-#       Comments in the block string are not parsed and are passed in the value.
-#       They must thus be delimited by ',' from either side - then they are
-#       harmless. It's terrible, but it works.
-Checks: >-
-  clang-diagnostic-*,
-  clang-analyzer-*,
-  -clang-analyzer-optin.core.EnumCastOutOfRange,
-
-  bugprone-*,
-  -bugprone-unchecked-optional-access,
-  ,# This is ridiculous, as it triggers on constants,
-  -bugprone-implicit-widening-of-multiplication-result,
-  -bugprone-easily-swappable-parameters,
-  ,# Is not really useful, has false positives, triggers for no-noexcept move constructors ...,
-  -bugprone-exception-escape,
-  -bugprone-narrowing-conversions,
-  -bugprone-chained-comparison,# RIP decomposers,
-
-  modernize-*,
-  -modernize-avoid-c-arrays,
-  -modernize-use-auto,
-  -modernize-use-emplace,
-  -modernize-use-nullptr,# it went crazy with three-way comparison operators,
-  -modernize-use-trailing-return-type,
-  -modernize-return-braced-init-list,
-  -modernize-concat-nested-namespaces,
-  -modernize-use-nodiscard,
-  -modernize-use-default-member-init,
-  -modernize-type-traits,# we need to support C++14,
-  -modernize-deprecated-headers,
-  ,# There's a lot of these and most of them are probably not useful,
-  -modernize-pass-by-value,
-
-  performance-*,
-  -performance-enum-size,
-
-  portability-*,
-
-  readability-*,
-  -readability-braces-around-statements,
-  -readability-container-size-empty,
-  -readability-convert-member-functions-to-static,
-  -readability-else-after-return,
-  -readability-function-cognitive-complexity,
-  -readability-function-size,
-  -readability-identifier-length,
-  -readability-implicit-bool-conversion,
-  -readability-isolate-declaration,
-  -readability-magic-numbers,
-  -readability-named-parameter,
-  -readability-qualified-auto,
-  -readability-redundant-access-specifiers,
-  -readability-simplify-boolean-expr,
-  -readability-static-definition-in-anonymous-namespace,
-  -readability-uppercase-literal-suffix,
-  -readability-use-anyofallof,
-  -readability-avoid-return-with-void-value,
-
-  ,# time hogs,
-  -bugprone-throw-keyword-missing,
-  -modernize-replace-auto-ptr,
-  -readability-identifier-naming,
-
-  ,# We cannot use this until clang-tidy supports custom unique_ptr,
-  -bugprone-use-after-move,
-  ,# Doesn't recognize unevaluated context in CATCH_MOVE and CATCH_FORWARD,
-  -bugprone-macro-repeated-side-effects,
-WarningsAsErrors: >-
-  clang-analyzer-core.*,
-  clang-analyzer-cplusplus.*,
-  clang-analyzer-security.*,
-  clang-analyzer-unix.*,
-  performance-move-const-arg,
-  performance-unnecessary-value-param,
-  readability-duplicate-include,
-HeaderFilterRegex: '.*\.(c|cxx|cpp)$'
-FormatStyle:     none
-CheckOptions: {}
-...
--- a/.conan/test_package/CMakeLists.txt
+++ b/.conan/test_package/CMakeLists.txt
@@ -1,8 +1,12 @@
-cmake_minimum_required(VERSION 3.15)
-project(PackageTest CXX)
+cmake_minimum_required(VERSION 3.2.0)
+project(test_package CXX)

-find_package(Catch2 CONFIG REQUIRED)
+include("${CMAKE_BINARY_DIR}/conanbuildinfo.cmake")
+conan_basic_setup()

-add_executable(test_package test_package.cpp)
-target_link_libraries(test_package Catch2::Catch2WithMain)
-target_compile_features(test_package PRIVATE cxx_std_14)
+find_package(Catch2 REQUIRED CONFIG)
+
+add_executable(${PROJECT_NAME} test_package.cpp)
+
+target_link_libraries(${PROJECT_NAME} Catch2::Catch2WithMain)
+set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD 14)
--- a/.conan/test_package/conanfile.py
+++ b/.conan/test_package/conanfile.py
@@ -1,28 +1,12 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-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
+from conans import ConanFile, CMake
 import os


 class TestPackageConan(ConanFile):
    settings = "os", "compiler", "build_type", "arch"
-    generators = "CMakeToolchain", "CMakeDeps", "VirtualRunEnv"
-    test_type = "explicit"
-
-    def requirements(self):
-        self.requires(self.tested_reference_str)
-
-    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)
+    generators = "cmake_find_package_multi", "cmake"

    def build(self):
        cmake = CMake(self)
@@ -30,11 +14,7 @@ class TestPackageConan(ConanFile):
        cmake.build()

    def test(self):
-        if can_run(self):
-            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'
+        assert os.path.isfile(os.path.join(
+            self.deps_cpp_info["catch2"].rootpath, "licenses", "LICENSE.txt"))
+        bin_path = os.path.join("bin", "test_package")
+        self.run("%s -s" % bin_path, run_environment=True)
--- a/.github/workflows/linux-meson-builds.yml
+++ b/.github/workflows/linux-meson-builds.yml
@@ -40,5 +40,6 @@ jobs:

    - name: Run tests
      working-directory: ${{runner.workspace}}/meson-build
+      # Hardcode 2 cores we know are there
      run: |
        meson test --verbose
--- a/.github/workflows/linux-other-builds.yml
+++ b/.github/workflows/linux-other-builds.yml
@@ -102,53 +102,5 @@ jobs:
      env:
          CTEST_OUTPUT_ON_FAILURE: 1
      working-directory: ${{runner.workspace}}/build
-      run: ctest -C ${{matrix.build_type}} -j `nproc` ${{matrix.other_ctest_args}}
-  clang-tidy:
-    name: clang-tidy ${{matrix.version}}, ${{matrix.build_description}}, C++${{matrix.std}} ${{matrix.build_type}}
-    runs-on: ubuntu-22.04
-    strategy:
-      matrix:
-        include:
-          - version: "15"
-            build_description: all
-            build_type: Debug
-            std: 17
-            other_pkgs: ''
-            cmake_configurations: -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Prepare environment
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y ninja-build clang-${{matrix.version}} clang-tidy-${{matrix.version}} ${{matrix.other_pkgs}}
-
-    - name: Configure build
-      working-directory: ${{runner.workspace}}
-      env:
-        CXX: clang++-${{matrix.version}}
-        CXXFLAGS: ${{matrix.cxxflags}}
-      # Note: $GITHUB_WORKSPACE is distinct from ${{runner.workspace}}.
-      #       This is important
-      run: |
-        clangtidy="clang-tidy-${{matrix.version}};-use-color"
-        # Use a dummy compiler/linker/ar/ranlib to effectively disable the
-        # compilation and only run clang-tidy.
-        cmake -Bbuild -H$GITHUB_WORKSPACE \
-              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
-              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
-              -DCMAKE_CXX_STANDARD_REQUIRED=ON \
-              -DCMAKE_CXX_EXTENSIONS=OFF \
-              -DCATCH_DEVELOPMENT_BUILD=ON \
-              -DCMAKE_CXX_CLANG_TIDY="$clangtidy" \
-              -DCMAKE_CXX_COMPILER_LAUNCHER=/usr/bin/true \
-              -DCMAKE_AR=/usr/bin/true \
-              -DCMAKE_CXX_COMPILER_AR=/usr/bin/true \
-              -DCMAKE_RANLIB=/usr/bin/true \
-              -DCMAKE_CXX_LINK_EXECUTABLE=/usr/bin/true \
-              ${{matrix.cmake_configurations}} \
-              -G Ninja
-
-    - name: Run clang-tidy
-      working-directory: ${{runner.workspace}}/build
-      run: ninja
+      # Hardcode 2 cores we know are there
+      run: ctest -C ${{matrix.build_type}} -j 2 ${{matrix.other_ctest_args}}
--- a/.github/workflows/linux-simple-builds.yml
+++ b/.github/workflows/linux-simple-builds.yml
@@ -120,4 +120,5 @@ jobs:
      env:
          CTEST_OUTPUT_ON_FAILURE: 1
      working-directory: ${{runner.workspace}}/build
-      run: ctest -C ${{matrix.build_type}} -j `nproc`
+      # Hardcode 2 cores we know are there
+      run: ctest -C ${{matrix.build_type}} -j 2
--- 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,15 @@ on: [push, pull_request]

 jobs:
  build:
-    runs-on: macos-12
+    # macos-12 updated to a toolchain that crashes when linking the
+    # test binary. This seems to be a known bug in that version,
+    # and will eventually get fixed in an update. After that, we can go
+    # back to newer macos images.
+    runs-on: macos-11
    strategy:
      matrix:
        cxx:
+          - g++-11
          - clang++
        build_type: [Debug, Release]
        std: [14, 17]
@@ -24,6 +29,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
@@ -1,31 +0,0 @@
-name: Package Manager Builds
-
-on: [push, pull_request]
-
-jobs:
-  conan_builds:
-    name: Conan ${{matrix.conan_version}}
-    runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        conan_version:
-          - '1.63'
-          - '2.1'
-
-        include:
-          # Conan 1 has default profiles installed
-          - conan_version: '1.63'
-            profile_generate: 'false'
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Install conan
-      run: pip install conan==${{matrix.conan_version}}
-
-    - name: Setup conan profiles
-      if: matrix.profile_generate != 'false'
-      run: conan profile detect
-
-    - name: Run conan package create
-      run: conan create . -tf .conan/test_package
--- a/.gitignore
+++ b/.gitignore
@@ -25,9 +25,7 @@ Build
 cmake-build-*
 benchmark-dir
 .conan/test_package/build
-**/CMakeUserPresets.json
 bazel-*
-MODULE.bazel.lock
 build-fuzzers
 debug-build
 .vscode
@@ -37,4 +35,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"
@@ -79,7 +78,6 @@ function(add_warnings_to_targets targets)
          "-Wreturn-std-move"
          "-Wshadow"
          "-Wstrict-aliasing"
-          "-Wsubobject-linkage"
          "-Wsuggest-destructor-override"
          "-Wsuggest-override"
          "-Wundef"
--- 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.0 # CML version placeholder, don't delete
+  VERSION 3.5.0 # CML version placeholder, don't delete
  LANGUAGES CXX
  # HOMEPAGE_URL is not supported until CMake version 3.12, which
  # we do not target yet.
@@ -76,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/appveyor.yml
+++ b/appveyor.yml
@@ -5,10 +5,10 @@ version: "{build}-{branch}"
 clone_depth: 20

 # We want to build everything, except for branches that are explicitly
-# for messing around with Github Actions.
+# for messing around with travis.
 branches:
  except:
-    - /devel-gha.+/
+    - /dev-travis.+/


 # We need a more up to date pip because Python 2.7 is EOL soon
@@ -70,14 +70,3 @@ environment:
      additional_flags: "/permissive- /std:c++latest"
      platform: x64
      configuration: Debug
-
-    - FLAVOR: VS 2017 x64 Debug
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      platform: x64
-      configuration: Debug
-
-    - FLAVOR: VS 2017 x64 Release Coverage
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      coverage: 1
-      platform: x64
-      configuration: Debug
--- a/conanfile.py
+++ b/conanfile.py
@@ -1,14 +1,5 @@
 #!/usr/bin/env python
-from conan import ConanFile
-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
-import os
-import re
-
-required_conan_version = ">=1.53.0"
+from conans import ConanFile, CMake, tools

 class CatchConan(ConanFile):
    name = "catch2"
@@ -17,113 +8,53 @@ class CatchConan(ConanFile):
    url = "https://github.com/catchorg/Catch2"
    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,
-    }
+    generators = "cmake"

-    @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")
-        with open("CMakeLists.txt") as file:
-            for line in file:
-                result = pattern.search(line)
-                if result:
-                    self.version = result.group(1)
-
-        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 _configure_cmake(self):
+        cmake = CMake(self)
+        cmake.definitions["BUILD_TESTING"] = "OFF"
+        cmake.definitions["CATCH_INSTALL_DOCS"] = "OFF"
+        cmake.definitions["CATCH_INSTALL_EXTRAS"] = "ON"
+        cmake.configure(build_folder="build")
+        return cmake

    def build(self):
-        cmake = CMake(self)
-        cmake.configure()
+        # We need this workaround until the toolchains feature
+        # to inject stuff like MD/MT
+        line_to_replace = 'list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake")'
+        tools.replace_in_file("CMakeLists.txt", line_to_replace,
+                              '''{}
+include("{}/conanbuildinfo.cmake")
+conan_basic_setup()'''.format(line_to_replace, self.install_folder.replace("\\", "/")))
+
+        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)
+        self.copy(pattern="LICENSE.txt", dst="licenses")
+        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"))

    def package_info(self):
        lib_suffix = "d" if self.settings.build_type == "Debug" else ""

-        self.cpp_info.set_property("cmake_file_name", "Catch2")
-        self.cpp_info.set_property("cmake_target_name", "Catch2::Catch2WithMain")
-        self.cpp_info.set_property("pkg_config_name", "catch2-with-main")
-
+        self.cpp_info.names["cmake_find_package"] = "Catch2"
+        self.cpp_info.names["cmake_find_package_multi"] = "Catch2"
        # 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"].names["cmake_find_package"] = "Catch2"
+        self.cpp_info.components["catch2base"].names["cmake_find_package_multi"] = "Catch2"
+        self.cpp_info.components["catch2base"].names["pkg_config"] = "Catch2"
        self.cpp_info.components["catch2base"].libs = ["Catch2" + lib_suffix]
        self.cpp_info.components["catch2base"].builddirs.append("lib/cmake/Catch2")
-
        # Catch2WithMain
-        self.cpp_info.components["catch2main"].set_property("cmake_file_name", "Catch2::Catch2WithMain")
-        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"].names["cmake_find_package"] = "Catch2WithMain"
+        self.cpp_info.components["catch2main"].names["cmake_find_package_multi"] = "Catch2WithMain"
+        self.cpp_info.components["catch2main"].names["pkg_config"] = "Catch2WithMain"
        self.cpp_info.components["catch2main"].libs = ["Catch2Main" + lib_suffix]
        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.
@@ -385,7 +384,7 @@ install it to the default location, like so:
 ```
 $ git clone https://github.com/catchorg/Catch2.git
 $ cd Catch2
-$ cmake -B build -S . -DBUILD_TESTING=OFF
+$ cmake -Bbuild -H. -DBUILD_TESTING=OFF
 $ sudo cmake --build build/ --target install
 ```

@@ -409,24 +408,6 @@ cd vcpkg
 The catch2 port in vcpkg is kept up to date by microsoft team members and community contributors.
 If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.

-## Installing Catch2 from Bazel
-
-Catch2 is now a supported module in the Bazel Central Registry. You only need to add one line to your MODULE.bazel file;
-please see https://registry.bazel.build/modules/catch2 for the latest supported version.
-
-You can then add `catch2_main` to each of your C++ test build rules as follows:
-
-```
-cc_test(
-    name = "example_test",
-    srcs = ["example_test.cpp"],
-    deps = [
-        ":example",
-        "@catch2//:catch2_main",
-    ],
-)
-```
-
 ---

 [Home](Readme.md#top)
--- 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
@@ -366,14 +365,14 @@ There are currently two warnings implemented:
 ## Reporting timings
 <pre>-d, --durations &lt;yes/no></pre>

-When set to ```yes``` Catch will report the duration of each test case, in seconds with millisecond precision. Note that it does this regardless of whether a test case passes or fails. Note, also, the certain reporters (e.g. Junit) always report test case durations regardless of this option being set or not.
+When set to ```yes``` Catch will report the duration of each test case, in milliseconds. Note that it does this regardless of whether a test case passes or fails. Note, also, the certain reporters (e.g. Junit) always report test case durations regardless of this option being set or not.

 <pre>-D, --min-duration &lt;value></pre>

 > `--min-duration` was [introduced](https://github.com/catchorg/Catch2/pull/1910) in Catch2 2.13.0

 When set, Catch will report the duration of each test case that took more
-than &lt;value> seconds, in seconds with millisecond precision. This option is overridden by both
+than &lt;value> seconds, in milliseconds. This option is overridden by both
 `-d yes` and `-d no`, so that either all durations are reported, or none
 are.

--- 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/generators.md
+++ b/docs/generators.md
@@ -206,26 +206,12 @@ or OO ranges.
 Unlike `std::uniform_int_distribution`, Catch2's generators also support
 various single-byte integral types, such as `char` or `bool`.

-
-#### Reproducibility
-
-Given the same seed, the output from the integral generators is fully
-reproducible across different platforms.
-
-For floating point generators, the situation is much more complex.
-Generally Catch2 only promises reproducibility (or even just correctness!)
-on platforms that obey the IEEE-754 standard. Furthermore, reproducibility
-only applies between binaries that perform floating point math in the
-same way, e.g. if you compile a binary targetting the x87 FPU and another
-one targetting SSE2 for floating point math, their results will vary.
-Similarly, binaries compiled with compiler flags that relax the IEEE-754
-adherence, e.g. `-ffast-math`, might provide different results than those
-compiled for strict IEEE-754 adherence.
-
-Finally, we provide zero guarantees on the reproducibility of generating
-`long double`s, as the internals of `long double` varies across different
-platforms.
-
+Given the same seed, the output from the integral generators is
+reproducible across different platforms. For floating point generators,
+we only promise reproducibility on platforms that obey the IEEE 754
+standard, and where `float` is 4 bytes and `double` is 8 bytes. We provide
+no guarantees for `long double`, as the internals of `long double` can
+vary wildly across different platforms.


 ## Generator interface
--- a/docs/limitations.md
+++ b/docs/limitations.md
@@ -173,19 +173,3 @@ TEST_CASE("b") {

 If you are seeing a problem like this, i.e. weird test paths that trigger only under Clang with `libc++`, or only under very specific version of `libstdc++`, it is very likely you are seeing this. The only known workaround is to use a fixed version of your standard library.

-
-### Visual Studio 2022 -- can't compile assertion with the spaceship operator
-
-[The C++ standard requires that `std::foo_ordering` is only comparable with
-a literal 0](https://eel.is/c++draft/cmp#categories.pre-3). There are
-multiple strategies a stdlib implementation can take to achieve this, and
-MSVC's STL has changed the strategy they use between two releases of VS 2022.
-
-With the new strategy, `REQUIRE((a <=> b) == 0)` no longer compiles under
-MSVC. Note that Catch2 can compile code using MSVC STL's new strategy,
-but only when compiled with a C++20 conforming compiler. MSVC is currently
-not conformant enough, but `clang-cl` will compile the assertion above
-using MSVC STL without problem.
-
-This change got in with MSVC v19.37](https://godbolt.org/z/KG9obzdvE).
-
--- 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,12 +2,6 @@

 # Release notes
 **Contents**<br>
-[3.7.0](#370)<br>
-[3.6.0](#360)<br>
-[3.5.4](#354)<br>
-[3.5.3](#353)<br>
-[3.5.2](#352)<br>
-[3.5.1](#351)<br>
 [3.5.0](#350)<br>
 [3.4.0](#340)<br>
 [3.3.2](#332)<br>
@@ -64,117 +58,6 @@
 [Even Older versions](#even-older-versions)<br>


-## 3.7.0
-
-### Improvements
-* Slightly improved compile times of benchmarks
-* Made the resolution estimation in benchmarks slightly more precise
-* Added new test case macro, `TEST_CASE_PERSISTENT_FIXTURE` (#2885, #1602)
-  * Unlike `TEST_CASE_METHOD`, the same underlying instance is used for all partial runs of that test case
-* **MASSIVELY** improved performance of the JUnit reporter when handling successful assertions (#2897)
-  * For 1 test case and 10M assertions, the new reporter runs 3x faster and uses up only 8 MB of memory, while the old one needs 7 GB of memory.
-* Reworked how output redirects works.
-  * Combining a reporter writing to stdout with capturing reporter no longer leads to the capturing reporter seeing all of the other reporter's output.
-  * The file based redirect no longer opens up a new temporary file for each partial test case run, so it will not run out of temporary files when running many tests in single process.
-
-### Miscellaneous
-* Better documentation for matchers on thrown exceptions (`REQUIRE_THROWS_MATCHES`)
-* Improved `catch_discover_tests`'s handling of environment paths (#2878)
-  * It won't reorder paths in `DL_PATHS` or `DYLD_FRAMEWORK_PATHS` args
-  * It won't overwrite the environment paths for test discovery
-
-
-## 3.6.0
-
-### Fixes
-* Fixed Windows ARM64 build by fixing the preprocessor condition guarding use `_umul128` intrinsic.
-* Fixed Windows ARM64EC build by removing intrinsic pragma it does not understand. (#2858)
-  * Why doesn't the x64-emulation build mode understand x64 pragmas? Don't ask me, ask the MSVC guys.
-* Fixed the JUnit reporter sometimes crashing when reporting a fatal error. (#1210, #2855)
-  * The binary will still exit, but through the original error, rather than secondary error inside the reporter.
-  * The underlying fix applies to all reporters, not just the JUnit one, but only JUnit was currently causing troubles.
-
-### Improvements
-* Disable `-Wnon-virtual-dtor` in Decomposer and Matchers (#2854)
-* `precision` in floating point stringmakers defaults to `max_digits10`.
-  * This means that floating point values will be printed with enough precision to disambiguate any two floats.
-* Column wrapping ignores ansi colour codes when calculating string width (#2833, #2849)
-  * This makes the output much more readable when the provided messages contain colour codes.
-
-### Miscellaneous
-* Conan support improvements
-  * `compatibility_cppstr` is set to False. (#2860)
-    * This means that Conan won't let you mix library and project with different C++ standard settings.
-  * The implementation library CMake target name through Conan is properly set to `Catch2::Catch2` (#2861)
-* `SelfTest` target can be built through Bazel (#2857)
-
-
-## 3.5.4
-
-### Fixes
-* 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
-* Fixed OOB access when computing filename tag (from the `-#` flag) for file without extension (#2798)
-* Fixed the linking against `log` on Android to be `PRIVATE` (#2815)
-* Fixed `Wuseless-cast` in benchmarking internals (#2823)
-
-### Improvements
-* Restored compatibility with VS2017 (#2792, #2822)
-  * The baseline for Catch2 is still C++14 with some reasonable workarounds for specific compilers, so if VS2017 starts acting up again, the support will be dropped again.
-* Suppressed clang-tidy's `bugprone-chained-comparison` in assertions (#2801)
-* Improved the static analysis mode to evaluate arguments to `TEST_CASE` and `SECTION` (#2817)
-  * Clang-tidy should no longer warn about runtime arguments to these macros being unused in static analysis mode.
-  * Clang-tidy can warn on issues involved arguments to these macros.
-* Added support for literal-zero detectors based on `consteval` constructors
-  * This is required for compiling `REQUIRE((a <=> b) == 0)` against MSVC's stdlib.
-  * Sadly, MSVC still cannot compile this assertion as it does not implement C++20 correctly.
-  * You can use `clang-cl` with MSVC's stdlib instead.
-  * If for some godforsaken reasons you want to understand this better, read the two relevant commits: [`dc51386b9fd61f99ea9c660d01867e6ad489b403`](https://github.com/catchorg/Catch2/commit/dc51386b9fd61f99ea9c660d01867e6ad489b403), and [`0787132fc82a75e3fb255aa9484ca1dc1eff2a30`](https://github.com/catchorg/Catch2/commit/0787132fc82a75e3fb255aa9484ca1dc1eff2a30).
-
-### Miscellaneous
-* Disabled tests for FP random generator reproducibility on non-SSE2 x86 targets (#2796)
-* Modified the in-tree Conan recipe to support Conan 2 (#2805)
-
-
-## 3.5.2
-
-### Fixes
-* Fixed `-Wsubobject-linkage` in the Console reporter (#2794)
-* Fixed adding new CLI Options to lvalue parser using `|` (#2787)
-
-
-## 3.5.1
-
-### Improvements
-* Significantly improved performance of the CLI parsing.
-  * This includes the cost of preparing the CLI parser, so Catch2's binaries start much faster.
-
-### Miscellaneous
-* Added support for Bazel modules (#2781)
-* Added CMake option to disable the build reproducibility settings (#2785)
-* Added `log` library linking to the Meson build (#2784)
-

 ## 3.5.0

--- a/docs/reporters.md
+++ b/docs/reporters.md
@@ -5,7 +5,7 @@ Reporters are a customization point for most of Catch2's output, e.g.
 formatting and writing out [assertions (whether passing or failing),
 sections, test cases, benchmarks, and so on](reporter-events.md#top).

-Catch2 comes with a bunch of reporters by default (currently 9), and
+Catch2 comes with a bunch of reporters by default (currently 8), and
 you can also write your own reporter. Because multiple reporters can
 be active at the same time, your own reporters do not even have to handle
 all reporter event, just the ones you are interested in, e.g. benchmarks.
--- 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/docs/tutorial.md
+++ b/docs/tutorial.md
@@ -16,7 +16,7 @@ Ideally you should be using Catch2 through its [CMake integration](cmake-integra
 Catch2 also provides pkg-config files and two file (header + cpp)
 distribution, but this documentation will assume you are using CMake. If
 you are using the two file distribution instead, remember to replace
-the included header with `catch_amalgamated.hpp` ([step by step instructions](migrate-v2-to-v3.md#how-to-migrate-projects-from-v2-to-v3)).
+the included header with `catch_amalgamated.hpp`.


 ## Writing tests
--- 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/210-Evt-EventListeners.cpp
+++ b/examples/210-Evt-EventListeners.cpp
@@ -385,7 +385,8 @@ struct MyListener : Catch::EventListenerBase {
 CATCH_REGISTER_LISTENER( MyListener )

 // Get rid of Wweak-tables
-MyListener::~MyListener() = default;
+MyListener::~MyListener() {}
+

 // -----------------------------------------------------------------------
 // 3. Test cases:
--- a/examples/231-Cfg-OutputStreams.cpp
+++ b/examples/231-Cfg-OutputStreams.cpp
@@ -22,7 +22,7 @@ class out_buff : public std::stringbuf {
    std::FILE* m_stream;
 public:
    out_buff(std::FILE* stream):m_stream(stream) {}
-    ~out_buff() override;
+    ~out_buff();
    int sync() override {
        int ret = 0;
        for (unsigned char c : str()) {
--- a/examples/232-Cfg-CustomMain.cpp
+++ b/examples/232-Cfg-CustomMain.cpp
@@ -1,41 +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
-
-// 232-Cfg-CustomMain.cpp
-// Show how to use custom main and add a custom option to the CLI parser
-
-#include <catch2/catch_session.hpp>
-
-#include <iostream>
-
-int main(int argc, char** argv) {
-  Catch::Session session; // There must be exactly one instance
-
-  int height = 0; // Some user variable you want to be able to set
-
-  // Build a new parser on top of Catch2's
-  using namespace Catch::Clara;
-  auto cli
-    = session.cli()           // Get Catch2's command line parser
-    | Opt( height, "height" ) // bind variable to a new option, with a hint string
-         ["--height"]         // the option names it will respond to
-         ("how high?");       // description string for the help output
-
-  // Now pass the new composite back to Catch2 so it uses that
-  session.cli( cli );
-
-  // Let Catch2 (using Clara) parse the command line
-  int returnCode = session.applyCommandLine( argc, argv );
-  if( returnCode != 0 ) // Indicates a command line error
-      return returnCode;
-
-  // if set on the command line then 'height' is now set at this point
-  std::cout << "height: " << height << '\n';
-
-  return session.run();
-}
--- a/examples/300-Gen-OwnGenerator.cpp
+++ b/examples/300-Gen-OwnGenerator.cpp
@@ -21,7 +21,7 @@
 namespace {

 // This class shows how to implement a simple generator for Catch tests
-class RandomIntGenerator final : public Catch::Generators::IGenerator<int> {
+class RandomIntGenerator : public Catch::Generators::IGenerator<int> {
    std::minstd_rand m_rand;
    std::uniform_int_distribution<> m_dist;
    int current_number;
--- a/examples/301-Gen-MapTypeConversion.cpp
+++ b/examples/301-Gen-MapTypeConversion.cpp
@@ -24,12 +24,12 @@ namespace {
 // Returns a line from a stream. You could have it e.g. read lines from
 // a file, but to avoid problems with paths in examples, we will use
 // a fixed stringstream.
-class LineGenerator final : public Catch::Generators::IGenerator<std::string> {
+class LineGenerator : public Catch::Generators::IGenerator<std::string> {
    std::string m_line;
    std::stringstream m_stream;
 public:
-    explicit LineGenerator( std::string const& lines ) {
-        m_stream.str( lines );
+    LineGenerator() {
+        m_stream.str("1\n2\n3\n4\n");
        if (!next()) {
            Catch::Generators::Detail::throw_generator_exception("Couldn't read a single line");
        }
@@ -49,19 +49,18 @@ std::string const& LineGenerator::get() const {
 // This helper function provides a nicer UX when instantiating the generator
 // Notice that it returns an instance of GeneratorWrapper<std::string>, which
 // is a value-wrapper around std::unique_ptr<IGenerator<std::string>>.
-Catch::Generators::GeneratorWrapper<std::string>
-lines( std::string const& lines ) {
+Catch::Generators::GeneratorWrapper<std::string> lines(std::string /* ignored for example */) {
    return Catch::Generators::GeneratorWrapper<std::string>(
-        new LineGenerator( lines ) );
+        new LineGenerator()
+    );
 }

 } // end anonymous namespace


 TEST_CASE("filter can convert types inside the generator expression", "[example][generator]") {
-    auto num = GENERATE(
-        map<int>( []( std::string const& line ) { return std::stoi( line ); },
-                  lines( "1\n2\n3\n4\n" ) ) );
+    auto num = GENERATE(map<int>([](std::string const& line) { return std::stoi(line); },
+                                 lines("fake-file")));

    REQUIRE(num > 0);
 }
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -28,10 +28,8 @@ 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
    300-Gen-OwnGenerator.cpp
    301-Gen-MapTypeConversion.cpp
    302-Gen-Table.cpp
@@ -44,7 +42,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
@@ -124,13 +124,6 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
    test executable and when the tests are executed themselves. This requires
    cmake/ctest >= 3.22.

-  ``DL_FRAMEWORK_PATHS path...``
-    Specifies paths that need to be set for the dynamic linker to find libraries
-    packaged as frameworks on Apple platforms when running the test executable
-    (DYLD_FRAMEWORK_PATH). These paths will both be set when retrieving the list
-    of test cases from the test executable and when the tests are executed themselves.
-    This requires cmake/ctest >= 3.22.
-
  `DISCOVERY_MODE mode``
    Provides control over when ``catch_discover_tests`` performs test discovery.
    By default, ``POST_BUILD`` sets up a post-build command to perform test discovery
@@ -153,7 +146,7 @@ function(catch_discover_tests TARGET)
    ""
    ""
    "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX;DISCOVERY_MODE"
-    "TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS;DL_FRAMEWORK_PATHS"
+    "TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS"
    ${ARGN}
  )

@@ -163,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)
@@ -213,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
@@ -259,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.0', # CML version placeholder, don't delete
+  version: '3.5.0', # 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
@@ -354,7 +354,7 @@ endif()
 add_library(Catch2::Catch2 ALIAS Catch2)

 if (ANDROID)
-    target_link_libraries(Catch2 PRIVATE log)
+    target_link_libraries(Catch2 INTERFACE log)
 endif()

 set_target_properties(Catch2 PROPERTIES
@@ -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_analyse.cpp
+++ b/src/catch2/benchmark/detail/catch_analyse.cpp
@@ -63,8 +63,8 @@ namespace Catch {
                    FDuration mean = FDuration(0);
                    int i = 0;
                    for (auto it = first; it < last; ++it, ++i) {
-                        samples.push_back(*it);
-                        mean += *it;
+                        samples.push_back(FDuration(*it));
+                        mean += FDuration(*it);
                    }
                    mean /= i;

--- 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,16 +38,21 @@ 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<decltype( n )> dist( 0,
+                                                                       n - 1 );

                    sample out;
                    out.reserve( resamples );
+                    // We allocate the vector outside the loop to avoid realloc
+                    // per resample
                    std::vector<double> resampled;
                    resampled.reserve( n );
                    for ( size_t i = 0; i < resamples; ++i ) {
                        resampled.clear();
                        for ( size_t s = 0; s < n; ++s ) {
-                            resampled.push_back( first[dist( rng )] );
+                            resampled.push_back(
+                                first[static_cast<std::ptrdiff_t>(
+                                    dist( rng ) )] );
                        }
                        const auto estimate =
                            estimator( resampled.data(), resampled.data() + resampled.size() );
--- 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_approx.cpp
+++ b/src/catch2/catch_approx.cpp
@@ -25,7 +25,7 @@ bool marginComparison(double lhs, double rhs, double margin) {
 namespace Catch {

    Approx::Approx ( double value )
-    :   m_epsilon( static_cast<double>(std::numeric_limits<float>::epsilon())*100. ),
+    :   m_epsilon( std::numeric_limits<float>::epsilon()*100. ),
        m_margin( 0.0 ),
        m_scale( 0.0 ),
        m_value( value )
--- 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_config.hpp
+++ b/src/catch2/catch_config.hpp
@@ -69,7 +69,7 @@ namespace Catch {
        bool benchmarkNoAnalysis = false;
        unsigned int benchmarkSamples = 100;
        double benchmarkConfidenceInterval = 0.95;
-        unsigned int benchmarkResamples = 100'000;
+        unsigned int benchmarkResamples = 100000;
        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;

        Verbosity verbosity = Verbosity::Normal;
--- a/src/catch2/catch_message.cpp
+++ b/src/catch2/catch_message.cpp
@@ -91,8 +91,6 @@ namespace Catch {
                    m_messages.back().message += " := ";
                    start = pos;
                }
-                break;
-            default:; // noop
            }
        }
        assert(openings.empty() && "Mismatched openings");
--- 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_registry_hub.cpp
+++ b/src/catch2/catch_registry_hub.cpp
@@ -20,6 +20,7 @@
 #include <catch2/internal/catch_noncopyable.hpp>
 #include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/internal/catch_reporter_registry.hpp>

 #include <exception>

--- 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,15 +80,13 @@ 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;
            }
-            // In theory we could have filename without any extension in it
-            if ( lastDot == 0 ) { return StringRef(); }
-
            --lastDot;
+
            size_t nameStart = lastDot;
            while (nameStart > 0 && filename[nameStart - 1] != '/' && filename[nameStart - 1] != '\\') {
                --nameStart;
@@ -98,7 +96,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 +257,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
@@ -68,7 +68,7 @@ namespace Catch {
    struct TestCaseInfo : Detail::NonCopyable {

        TestCaseInfo(StringRef _className,
-                     NameAndTags const& _nameAndTags,
+                     NameAndTags const& _tags,
                     SourceLineInfo const& _lineInfo);

        bool isHidden() const;
@@ -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
@@ -54,13 +54,13 @@ namespace Detail {
        }
    } // end unnamed namespace

-    std::string convertIntoString(StringRef string, bool escapeInvisibles) {
+    std::string convertIntoString(StringRef string, bool escape_invisibles) {
        std::string ret;
        // This is enough for the "don't escape invisibles" case, and a good
        // lower bound on the "escape invisibles" case.
        ret.reserve(string.size() + 2);

-        if (!escapeInvisibles) {
+        if (!escape_invisibles) {
            ret += '"';
            ret += string;
            ret += '"';
@@ -138,7 +138,7 @@ std::string StringMaker<char const*>::convert(char const* str) {
        return{ "{null string}" };
    }
 }
-std::string StringMaker<char*>::convert(char* str) { // NOLINT(readability-non-const-parameter)
+std::string StringMaker<char*>::convert(char* str) {
    if (str) {
        return Detail::convertIntoString( str );
    } else {
@@ -235,17 +235,17 @@ std::string StringMaker<signed char>::convert(signed char value) {
 std::string StringMaker<char>::convert(char c) {
    return ::Catch::Detail::stringify(static_cast<signed char>(c));
 }
-std::string StringMaker<unsigned char>::convert(unsigned char value) {
-    return ::Catch::Detail::stringify(static_cast<char>(value));
+std::string StringMaker<unsigned char>::convert(unsigned char c) {
+    return ::Catch::Detail::stringify(static_cast<char>(c));
 }

-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_tostring.hpp
+++ b/src/catch2/catch_tostring.hpp
@@ -279,11 +279,11 @@ namespace Catch {
    };
    template<>
    struct StringMaker<signed char> {
-        static std::string convert(signed char value);
+        static std::string convert(signed char c);
    };
    template<>
    struct StringMaker<unsigned char> {
-        static std::string convert(unsigned char value);
+        static std::string convert(unsigned char c);
    };

    template<>
--- 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, 0, "", 0 );
+        static Version version( 3, 5, 0, "", 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_MINOR 5
 #define CATCH_VERSION_PATCH 0

 #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_clara.hpp
+++ b/src/catch2/internal/catch_clara.hpp
@@ -673,9 +673,7 @@ namespace Catch {

            template <typename T>
            friend Parser operator|( Parser const& p, T&& rhs ) {
-                Parser temp( p );
-                temp |= rhs;
-                return temp;
+                return Parser( p ) |= CATCH_FORWARD(rhs);
            }

            template <typename T>
--- a/src/catch2/internal/catch_commandline.cpp
+++ b/src/catch2/internal/catch_commandline.cpp
@@ -47,7 +47,7 @@ namespace Catch {
                    line = trim(line);
                    if( !line.empty() && !startsWith( line, '#' ) ) {
                        if( !startsWith( line, '"' ) )
-                            line = '"' + CATCH_MOVE(line) + '"';
+                            line = '"' + line + '"';
                        config.testsOrTags.push_back( line );
                        config.testsOrTags.emplace_back( "," );
                    }
--- a/src/catch2/internal/catch_compiler_capabilities.hpp
+++ b/src/catch2/internal/catch_compiler_capabilities.hpp
@@ -29,12 +29,12 @@

 #ifdef __cplusplus

-#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-#    define CATCH_CPP17_OR_GREATER
+#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
+#    define CATCH_CPP14_OR_GREATER
 #  endif

-#  if (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
-#    define CATCH_CPP20_OR_GREATER
+#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#    define CATCH_CPP17_OR_GREATER
 #  endif

 #endif
--- a/src/catch2/internal/catch_console_colour.cpp
+++ b/src/catch2/internal/catch_console_colour.cpp
@@ -230,21 +230,21 @@ namespace {

 namespace Catch {

-    Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
+    Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode implSelection,
                                                   IStream* stream ) {
 #if defined( CATCH_CONFIG_COLOUR_WIN32 )
-        if ( colourSelection == ColourMode::Win32 ) {
+        if ( implSelection == ColourMode::Win32 ) {
            return Detail::make_unique<Win32ColourImpl>( stream );
        }
 #endif
-        if ( colourSelection == ColourMode::ANSI ) {
+        if ( implSelection == ColourMode::ANSI ) {
            return Detail::make_unique<ANSIColourImpl>( stream );
        }
-        if ( colourSelection == ColourMode::None ) {
+        if ( implSelection == ColourMode::None ) {
            return Detail::make_unique<NoColourImpl>( stream );
        }

-        if ( colourSelection == ColourMode::PlatformDefault) {
+        if ( implSelection == ColourMode::PlatformDefault) {
 #if defined( CATCH_CONFIG_COLOUR_WIN32 )
            if ( Win32ColourImpl::useImplementationForStream( *stream ) ) {
                return Detail::make_unique<Win32ColourImpl>( stream );
@@ -256,7 +256,7 @@ namespace Catch {
            return Detail::make_unique<NoColourImpl>( stream );
        }

-        CATCH_ERROR( "Could not create colour impl for selection " << static_cast<int>(colourSelection) );
+        CATCH_ERROR( "Could not create colour impl for selection " << static_cast<int>(implSelection) );
    }

    bool isColourImplAvailable( ColourMode colourSelection ) {
--- 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.cpp
+++ b/src/catch2/internal/catch_decomposer.cpp
@@ -10,12 +10,7 @@

 namespace Catch {

-    void ITransientExpression::streamReconstructedExpression(
-        std::ostream& os ) const {
-        // We can't make this function pure virtual to keep ITransientExpression
-        // constexpr, so we write error message instead
-        os << "Some class derived from ITransientExpression without overriding streamReconstructedExpression";
-    }
+    ITransientExpression::~ITransientExpression() = default;

    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
        if( lhs.size() + rhs.size() < 40 &&
--- a/src/catch2/internal/catch_decomposer.hpp
+++ b/src/catch2/internal/catch_decomposer.hpp
@@ -13,91 +13,10 @@
 #include <catch2/internal/catch_compare_traits.hpp>
 #include <catch2/internal/catch_test_failure_exception.hpp>
 #include <catch2/internal/catch_logical_traits.hpp>
-#include <catch2/internal/catch_compiler_capabilities.hpp>

 #include <type_traits>
 #include <iosfwd>

-/** \file
- * Why does decomposing look the way it does:
- *
- * Conceptually, decomposing is simple. We change `REQUIRE( a == b )` into
- * `Decomposer{} <= a == b`, so that `Decomposer{} <= a` is evaluated first,
- * and our custom operator is used for `a == b`, because `a` is transformed
- * into `ExprLhs<T&>` and then into `BinaryExpr<T&, U&>`.
- *
- * In practice, decomposing ends up a mess, because we have to support
- * various fun things.
- *
- * 1) Types that are only comparable with literal 0, and they do this by
- *    comparing against a magic type with pointer constructor and deleted
- *    other constructors. Example: `REQUIRE((a <=> b) == 0)` in libstdc++
- *
- * 2) Types that are only comparable with literal 0, and they do this by
- *    comparing against a magic type with consteval integer constructor.
- *    Example: `REQUIRE((a <=> b) == 0)` in current MSVC STL.
- *
- * 3) Types that have no linkage, and so we cannot form a reference to
- *    them. Example: some implementations of traits.
- *
- * 4) Starting with C++20, when the compiler sees `a == b`, it also uses
- *    `b == a` when constructing the overload set. For us this means that
- *    when the compiler handles `ExprLhs<T> == b`, it also tries to resolve
- *    the overload set for `b == ExprLhs<T>`.
- *
- * To accomodate these use cases, decomposer ended up rather complex.
- *
- * 1) These types are handled by adding SFINAE overloads to our comparison
- *    operators, checking whether `T == U` are comparable with the given
- *    operator, and if not, whether T (or U) are comparable with literal 0.
- *    If yes, the overload compares T (or U) with 0 literal inline in the
- *    definition.
- *
- *    Note that for extra correctness, we check  that the other type is
- *    either an `int` (literal 0 is captured as `int` by templates), or
- *    a `long` (some platforms use 0L for `NULL` and we want to support
- *    that for pointer comparisons).
- *
- * 2) For these types, `is_foo_comparable<T, int>` is true, but letting
- *    them fall into the overload that actually does `T == int` causes
- *    compilation error. Handling them requires that the decomposition
- *    is `constexpr`, so that P2564R3 applies and the `consteval` from
- *    their accompanying magic type is propagated through the `constexpr`
- *    call stack.
- *
- *    However this is not enough to handle these types automatically,
- *    because our default is to capture types by reference, to avoid
- *    runtime copies. While these references cannot become dangling,
- *    they outlive the constexpr context and thus the default capture
- *    path cannot be actually constexpr.
- *
- *    The solution is to capture these types by value, by explicitly
- *    specializing `Catch::capture_by_value` for them. Catch2 provides
- *    specialization for `std::foo_ordering`s, but users can specialize
- *    the trait for their own types as well.
- *
- * 3) If a type has no linkage, we also cannot capture it by reference.
- *    The solution is once again to capture them by value. We handle
- *    the common cases by using `std::is_arithmetic` as the default
- *    for `Catch::capture_by_value`, but that is only a some-effort
- *    heuristic. But as with 2), users can specialize `capture_by_value`
- *    for their own types as needed.
- *
- * 4) To support C++20 and make the SFINAE on our decomposing operators
- *    work, the SFINAE has to happen in return type, rather than in
- *    a template type. This is due to our use of logical type traits
- *    (`conjunction`/`disjunction`/`negation`), that we use to workaround
- *    an issue in older (9-) versions of GCC. I still blame C++20 for
- *    this, because without the comparison order switching, the logical
- *    traits could still be used in template type.
- *
- * There are also other side concerns, e.g. supporting both `REQUIRE(a)`
- * and `REQUIRE(a == b)`, or making `REQUIRE_THAT(a, IsEqual(b))` slot
- * nicely into the same expression handling logic, but these are rather
- * straightforward and add only a bit of complexity (e.g. common base
- * class for decomposed expressions).
- */
-
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable:4389) // '==' : signed/unsigned mismatch
@@ -110,46 +29,13 @@
 #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>)
-#  include <compare>
-#    if defined( __cpp_lib_three_way_comparison ) && \
-            __cpp_lib_three_way_comparison >= 201907L
-#      define CATCH_CONFIG_CPP20_COMPARE_OVERLOADS
-#    endif
 #endif

 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
-    //       keep this as it used to be and it can be changed later.
-    template <typename T>
-    struct capture_by_value
-        : std::integral_constant<bool, std::is_arithmetic<T>{}> {};
-
-#if defined( CATCH_CONFIG_CPP20_COMPARE_OVERLOADS )
-    template <>
-    struct capture_by_value<std::strong_ordering> : std::true_type {};
-    template <>
-    struct capture_by_value<std::weak_ordering> : std::true_type {};
-    template <>
-    struct capture_by_value<std::partial_ordering> : std::true_type {};
-#endif
-
    template <typename T>
    struct always_false : std::false_type {};

@@ -157,22 +43,23 @@ 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; }
-        //! This function **has** to be overriden by the derived class.
-        virtual void streamReconstructedExpression( std::ostream& os ) const;
+        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
+        auto getResult() const -> bool { return m_result; }
+        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;

-        constexpr ITransientExpression( bool isBinaryExpression, bool result )
+        ITransientExpression( bool isBinaryExpression, bool result )
        :   m_isBinaryExpression( isBinaryExpression ),
            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;
+
+        // We don't actually need a virtual destructor, but many static analysers
+        // complain if it's not here :-(
+        virtual ~ITransientExpression(); // = default;

        friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) {
            expr.streamReconstructedExpression(out);
@@ -194,7 +81,7 @@ namespace Catch {
        }

    public:
-        constexpr BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
        :   ITransientExpression{ true, comparisonResult },
            m_lhs( lhs ),
            m_op( op ),
@@ -267,7 +154,7 @@ namespace Catch {
        }

    public:
-        explicit constexpr UnaryExpr( LhsT lhs )
+        explicit UnaryExpr( LhsT lhs )
        :   ITransientExpression{ false, static_cast<bool>(lhs) },
            m_lhs( lhs )
        {}
@@ -278,31 +165,31 @@ namespace Catch {
    class ExprLhs {
        LhsT m_lhs;
    public:
-        explicit constexpr ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
+        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}

 #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<                                                   \
+    friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )                       \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                Detail::negation<capture_by_value<             \
-                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
+                                Detail::negation<std::is_arithmetic<           \
+                                    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<                                                   \
+    friend auto operator op( ExprLhs&& lhs, RhsT rhs )                         \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                capture_by_value<RhsT>>::value,                \
+                                std::is_arithmetic<RhsT>>::value,              \
            BinaryExpr<LhsT, RhsT>> {                                          \
        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<                                                   \
+    friend auto operator op( ExprLhs&& lhs, RhsT rhs )                         \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_eq_0_comparable<LhsT>,                              \
@@ -315,8 +202,8 @@ namespace Catch {
            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs };   \
    }                                                                          \
    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
+    friend auto operator op( ExprLhs&& lhs, RhsT rhs )                         \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_eq_0_comparable<RhsT>,                              \
@@ -333,30 +220,29 @@ namespace Catch {

    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR

-
 #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<                                                   \
+    friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )                       \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                Detail::negation<capture_by_value<             \
-                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
+                                Detail::negation<std::is_arithmetic<           \
+                                    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<                                                   \
+    friend auto operator op( ExprLhs&& lhs, RhsT rhs )                         \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                capture_by_value<RhsT>>::value,                \
+                                std::is_arithmetic<RhsT>>::value,              \
            BinaryExpr<LhsT, RhsT>> {                                          \
        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<                                                   \
+    friend auto operator op( ExprLhs&& lhs, RhsT rhs )                         \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_##id##_0_comparable<LhsT>,                          \
@@ -367,8 +253,8 @@ namespace Catch {
            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs };   \
    }                                                                          \
    template <typename RhsT>                                                   \
-    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
-        -> std::enable_if_t<                                                   \
+    friend auto operator op( ExprLhs&& lhs, RhsT rhs )                         \
+        ->std::enable_if_t<                                                    \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_##id##_0_comparable<RhsT>,                          \
@@ -388,17 +274,17 @@ 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,             \
+    friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )                       \
+        ->std::enable_if_t<                                                    \
+            !std::is_arithmetic<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>> {                          \
+    friend auto operator op( ExprLhs&& lhs, RhsT rhs )                         \
+        ->std::enable_if_t<std::is_arithmetic<RhsT>::value,                    \
+                           BinaryExpr<LhsT, RhsT>> {                           \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }
@@ -423,22 +309,19 @@ namespace Catch {
            "wrap the expression inside parentheses, or decompose it");
        }

-        constexpr auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
+        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
            return UnaryExpr<LhsT>{ m_lhs };
        }
    };

    struct Decomposer {
-        template <typename T,
-                  std::enable_if_t<!capture_by_value<Detail::RemoveCVRef_t<T>>::value,
-                      int> = 0>
-        constexpr friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs<T const&> {
+        template<typename T, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<T>>::value, int> = 0>
+        friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs<T const&> {
            return ExprLhs<const T&>{ lhs };
        }

-        template <typename T,
-                  std::enable_if_t<capture_by_value<T>::value, int> = 0>
-        constexpr friend auto operator <= ( Decomposer &&, T value ) -> ExprLhs<T> {
+        template<typename T, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
+        friend auto operator <= ( Decomposer &&, T value ) -> ExprLhs<T> {
            return ExprLhs<T>{ value };
        }
    };
--- a/src/catch2/internal/catch_enum_values_registry.hpp
+++ b/src/catch2/internal/catch_enum_values_registry.hpp
@@ -24,7 +24,7 @@ namespace Catch {

            std::vector<Catch::Detail::unique_ptr<EnumInfo>> m_enumInfos;

-            EnumInfo const& registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values) override;
+            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
        };

        std::vector<StringRef> parseEnums( StringRef enums );
--- 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_jsonwriter.cpp
+++ b/src/catch2/internal/catch_jsonwriter.cpp
@@ -31,7 +31,7 @@ namespace Catch {
        m_os{ os }, m_indent_level{ indent_level } {
        m_os << '{';
    }
-    JsonObjectWriter::JsonObjectWriter( JsonObjectWriter&& source ) noexcept:
+    JsonObjectWriter::JsonObjectWriter( JsonObjectWriter&& source ):
        m_os{ source.m_os },
        m_indent_level{ source.m_indent_level },
        m_should_comma{ source.m_should_comma },
@@ -62,7 +62,7 @@ namespace Catch {
        m_os{ os }, m_indent_level{ indent_level } {
        m_os << '[';
    }
-    JsonArrayWriter::JsonArrayWriter( JsonArrayWriter&& source ) noexcept:
+    JsonArrayWriter::JsonArrayWriter( JsonArrayWriter&& source ):
        m_os{ source.m_os },
        m_indent_level{ source.m_indent_level },
        m_should_comma{ source.m_should_comma },
--- a/src/catch2/internal/catch_jsonwriter.hpp
+++ b/src/catch2/internal/catch_jsonwriter.hpp
@@ -65,7 +65,7 @@ namespace Catch {
        JsonObjectWriter( std::ostream& os );
        JsonObjectWriter( std::ostream& os, std::uint64_t indent_level );

-        JsonObjectWriter( JsonObjectWriter&& source ) noexcept;
+        JsonObjectWriter( JsonObjectWriter&& source );
        JsonObjectWriter& operator=( JsonObjectWriter&& source ) = delete;

        ~JsonObjectWriter();
@@ -84,7 +84,7 @@ namespace Catch {
        JsonArrayWriter( std::ostream& os );
        JsonArrayWriter( std::ostream& os, std::uint64_t indent_level );

-        JsonArrayWriter( JsonArrayWriter&& source ) noexcept;
+        JsonArrayWriter( JsonArrayWriter&& source );
        JsonArrayWriter& operator=( JsonArrayWriter&& source ) = delete;

        ~JsonArrayWriter();
--- 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,523 +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_USE_ASYNC)
-#include <thread>
-#include <mutex>
+#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

-#if defined( CATCH_CONFIG_NEW_CAPTURE ) || defined(CATCH_CONFIG_USE_ASYNC)
-#    if defined( _MSC_VER )
-#        include <io.h> //_dup and _dup2
-#        include <fcntl.h> // _O_BINARY
-#        define dup _dup
-#        define dup2 _dup2
-#        define fileno _fileno
-#        define close _close
-#    else
-#        include <unistd.h> // dup and dup2
-#    endif
-#endif

 namespace Catch {

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

-        public:
-            RedirectedStream( 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;
-            RedirectedStream 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

-
-#if defined( CATCH_CONFIG_USE_ASYNC )
-
-        static inline void pipe_or_throw( int descriptors[2] ) {
-#    if defined( _MSC_VER )
-            constexpr int defaultPipeSize{ 0 };
-
-            int result{ _pipe( descriptors, defaultPipeSize, _O_BINARY ) };
-#    else
-            int result{ pipe( descriptors ) };
-#    endif
-
-            if ( result ) {
-                CATCH_INTERNAL_ERROR( "pipe-or-throw" );
-                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
-            }
-        }
-
-        static inline size_t
-        read_or_throw( int descriptor, void* buffer, size_t size ) {
-#    if defined( _MSC_VER )
-            int result{
-                _read( descriptor, buffer, static_cast<unsigned>( size ) ) };
-#    else
-            ssize_t result{ read( descriptor, buffer, size ) };
-#    endif
-
-            if ( result == -1 ) {
-                CATCH_INTERNAL_ERROR( "read-or-throw" );
-                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
-            }
-
-            return static_cast<size_t>( result );
-        }
-
-        static inline void close_or_throw( int descriptor ) {
-            if ( close( descriptor ) ) {
-                CATCH_INTERNAL_ERROR( "close-or-throw" );
-                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
-            }
-        }
-
-        static inline int dup_or_throw( int descriptor ) {
-            int result{ dup( descriptor ) };
-
-            if ( result == -1 ) {
-                CATCH_INTERNAL_ERROR( "dup-or-throw" );
-                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
-            }
-
-            return result;
-        }
-
-        static inline int dup2_or_throw( int sourceDescriptor,
-                                         int destinationDescriptor ) {
-            int result{ dup2( sourceDescriptor, destinationDescriptor ) };
-
-            if ( result == -1 ) {
-                CATCH_INTERNAL_ERROR( "dup2-or-throw" );
-                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
-            }
-
-            return result;
-        }
-
-        static inline int fileno_or_throw( std::FILE* file ) {
-            int result{ fileno( file ) };
-
-            if ( result == -1 ) {
-                CATCH_INTERNAL_ERROR( "fileno-or-throw" );
-                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
-            }
-
-            return result;
-        }
-
-        static inline void fflush_or_throw( std::FILE* file ) {
-            if ( std::fflush( file ) ) {
-                CATCH_INTERNAL_ERROR( "fflush-or-throw" );
-                // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
-            }
-        }
-
-        class StreamPipeHandler {
-            int m_originalFd = -1;
-            int m_pipeReadEnd = -1;
-            int m_pipeWriteEnd = -1;
-            FILE* m_targetStream;
-            std::mutex m_mutex;
-            std::string m_captured;
-            std::thread m_readThread;
-
-        public:
-            StreamPipeHandler( FILE* original ):
-                m_originalFd( dup_or_throw( fileno( original ) ) ),
-                m_targetStream(original)
-            {
-                CATCH_ENFORCE( m_originalFd >= 0, "Could not dup stream" );
-                int pipe_fds[2];
-                pipe_or_throw( pipe_fds );
-                m_pipeReadEnd = pipe_fds[0];
-                m_pipeWriteEnd = pipe_fds[1];
-
-                m_readThread = std::thread([this]() {
-                    constexpr size_t bufferSize = 4096;
-                    char buffer[bufferSize];
-                    size_t sizeRead;
-                    while ( ( sizeRead = read_or_throw(
-                                  m_pipeReadEnd, buffer, bufferSize ) ) != 0 ) {
-                        std::unique_lock<std::mutex> _( m_mutex );
-                        m_captured.append( buffer, sizeRead );
-                    }
-                });
-            }
-
-            ~StreamPipeHandler() {
-                close_or_throw( m_pipeWriteEnd );
-                m_readThread.join();
-            }
-
-            std::string getCapturedOutput() {
-                std::unique_lock<std::mutex> _( m_mutex );
-                return m_captured;
-            }
-
-            void clearCapturedOutput() {
-                std::unique_lock<std::mutex> _( m_mutex );
-                m_captured.clear();
-            }
-
-            void startCapture() {
-                fflush_or_throw( m_targetStream );
-                int ret = dup2_or_throw( m_pipeWriteEnd, fileno( m_targetStream ) );
-                CATCH_ENFORCE( ret >= 0,
-                               "dup2 pipe-write -> original stream failed " << errno );
-            }
-            void stopCapture() {
-                fflush_or_throw( m_targetStream );
-                int ret = dup2_or_throw( m_originalFd, fileno( m_targetStream ) );
-                CATCH_ENFORCE( ret >= 0,
-                               "dup2 of original fd -> original stream failed " << errno );
-            }
-        };
-
-        class PipeRedirect : public OutputRedirect {
-        private:
-            StreamPipeHandler m_stdout;
-            StreamPipeHandler m_stderr;
-        public:
-            PipeRedirect():
-                m_stdout(stdout),
-                m_stderr(stderr){}
-
-            void activateImpl() override {
-                m_stdout.startCapture();
-                m_stderr.startCapture();
-            }
-            void deactivateImpl() override {
-                m_stdout.stopCapture();
-                m_stderr.stopCapture();
-            }
-            std::string getStdout() override {
-                return m_stdout.getCapturedOutput();
-            }
-            std::string getStderr() override {
-                return m_stderr.getCapturedOutput();
-            }
-            void clearBuffers() override {
-                m_stdout.clearCapturedOutput();
-                m_stderr.clearCapturedOutput();
-            }
-        };
-
-#endif // CATCH_CONFIG_USE_ASYNC
-
-
-    } // end namespace
-
-    bool isRedirectAvailable( OutputRedirect::Kind kind ) {
-        switch ( kind ) {
-        // These two are always available
-        case OutputRedirect::None:
-        case OutputRedirect::Streams:
-            return true;
-#if defined( CATCH_CONFIG_NEW_CAPTURE )
-        case OutputRedirect::FileDescriptors:
-            return true;
-#endif
-#if defined(CATCH_CONFIG_USE_ASYNC)
-        case OutputRedirect::Pipes:
-            return true;
-#endif
-        default:
-            return false;
-        }
-    }
-
-    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual ) {
-        if ( actual ) {
-            // TODO: Clean this up later
-#if defined( CATCH_CONFIG_NEW_CAPTURE )
-            return Detail::make_unique<FileRedirect>();
-#else
-            //return Detail::make_unique<StreamRedirect>();
-            return Detail::make_unique<PipeRedirect>();
-#endif
-        } else {
-            return Detail::make_unique<NoopRedirect>();
-        }
-    }
-
-    RedirectGuard scopedActivate( OutputRedirect& redirectImpl ) {
-        return RedirectGuard( true, redirectImpl );
-    }
-
-    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl ) {
-        return RedirectGuard( false, redirectImpl );
-    }
-
-    OutputRedirect::~OutputRedirect() = default;
-
-    RedirectGuard::RedirectGuard( bool activate, OutputRedirect& redirectImpl ):
-        m_redirect( &redirectImpl ),
-        m_activate( activate ),
-        m_previouslyActive( redirectImpl.isActive() ) {
-
-        // Skip cases where there is no actual state change.
-        if ( m_activate == m_previouslyActive ) { return; }
-
-        if ( m_activate ) {
-            m_redirect->activate();
-        } else {
-            m_redirect->deactivate();
-        }
-    }
-
-    RedirectGuard::~RedirectGuard() noexcept( false ) {
-        if ( m_moved ) { return; }
-        // Skip cases where there is no actual state change.
-        if ( m_activate == m_previouslyActive ) { return; }
-
-        if ( m_activate ) {
-            m_redirect->deactivate();
-        } else {
-            m_redirect->activate();
-        }
-    }
-
-    RedirectGuard::RedirectGuard( RedirectGuard&& rhs ) noexcept:
-        m_redirect( rhs.m_redirect ),
-        m_activate( rhs.m_activate ),
-        m_previouslyActive( rhs.m_previouslyActive ),
-        m_moved( false ) {
-        rhs.m_moved = true;
-    }
-
-    RedirectGuard& RedirectGuard::operator=( RedirectGuard&& rhs ) noexcept {
-        m_redirect = rhs.m_redirect;
-        m_activate = rhs.m_activate;
-        m_previouslyActive = rhs.m_previouslyActive;
-        m_moved = false;
-        rhs.m_moved = true;
-        return *this;
-    }
-
 } // namespace Catch

-#if defined( CATCH_CONFIG_NEW_CAPTURE )
-#    if defined( _MSC_VER )
-#        undef dup
-#        undef dup2
-#        undef fileno
-#    endif
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #undef dup
+    #undef dup2
+    #undef fileno
+    #endif
 #endif
--- a/src/catch2/internal/catch_output_redirect.hpp
+++ b/src/catch2/internal/catch_output_redirect.hpp
@@ -8,71 +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 temp files
-            FileDescriptors,
-            //! Redirect the stdout/stderr file descriptors into anonymous pipes
-            Pipes,
-        };
+        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,65 @@ namespace Catch {
        struct ExtendedMultResult {
            T upper;
            T lower;
-            constexpr bool operator==( ExtendedMultResult const& rhs ) const {
-                return upper == rhs.upper && lower == rhs.lower;
+            friend bool operator==( ExtendedMultResult const& lhs,
+                                    ExtendedMultResult const& rhs ) {
+                return lhs.upper == rhs.upper && lhs.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 +167,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 +187,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_reporter_spec_parser.cpp
+++ b/src/catch2/internal/catch_reporter_spec_parser.cpp
@@ -117,7 +117,7 @@ namespace Catch {
            auto kv = splitKVPair( parts[i] );
            auto key = kv.key, value = kv.value;

-            if ( key.empty() || value.empty() ) { // NOLINT(bugprone-branch-clone)
+            if ( key.empty() || value.empty() ) {
                return {};
            } else if ( key[0] == 'X' ) {
                // This is a reporter-specific option, we don't check these
--- 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_section.hpp
+++ b/src/catch2/internal/catch_section.hpp
@@ -69,9 +69,7 @@ namespace Catch {
    namespace Detail {
        // Intentionally without linkage, as it should only be used as a dummy
        // symbol for static analysis.
-        // The arguments are used as a dummy for checking warnings in the passed
-        // expressions.
-        int GetNewSectionHint( StringRef, const char* const = nullptr );
+        int GetNewSectionHint();
    } // namespace Detail
 } // namespace Catch

@@ -82,8 +80,7 @@ namespace Catch {
        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                             \
        if ( [[maybe_unused]] const int catchInternalPreviousSectionHint =  \
                 catchInternalSectionHint,                                  \
-             catchInternalSectionHint =                                     \
-                 Catch::Detail::GetNewSectionHint(__VA_ARGS__);             \
+             catchInternalSectionHint = Catch::Detail::GetNewSectionHint(); \
             catchInternalPreviousSectionHint == __LINE__ )                 \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

@@ -93,8 +90,7 @@ namespace Catch {
        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                             \
        if ( [[maybe_unused]] const int catchInternalPreviousSectionHint =  \
                 catchInternalSectionHint,                                  \
-             catchInternalSectionHint = Catch::Detail::GetNewSectionHint(   \
-                ( Catch::ReusableStringStream() << __VA_ARGS__ ).str());    \
+             catchInternalSectionHint = Catch::Detail::GetNewSectionHint(); \
             catchInternalPreviousSectionHint == __LINE__ )                 \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

--- a/Show More
+++ b/Show More