Flush AND sleep

Refactor pipe-based redirect to not always create new thread and pipe
WIP: rebase pipe redirect onto current redirect interface
2024-09-15 20:46:24 +02:00 · 2024-09-15 20:22:40 +02:00 · 2024-09-13 19:17:39 +02:00
67 changed files with 711 additions and 1026 deletions
--- a/.bazelrc
+++ b/.bazelrc
@@ -1,6 +1,3 @@
 # Enable Bzlmod for every Bazel command
 common --enable_bzlmod
 build --enable_platform_specific_config
 build:gcc9 --cxxopt=-std=c++2a
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -34,7 +34,7 @@ Checks: >-
  -modernize-pass-by-value,
  performance-*,
-  performance-enum-size,
+  -performance-enum-size,
  portability-*,
@@ -49,7 +49,6 @@ Checks: >-
  -readability-implicit-bool-conversion,
  -readability-isolate-declaration,
  -readability-magic-numbers,
  -readability-math-missing-parentheses, #no, 'a + B * C' obeying math rules is not confusing,
  -readability-named-parameter,
  -readability-qualified-auto,
  -readability-redundant-access-specifiers,
--- a/.conan/test_package/CMakeLists.txt
+++ b/.conan/test_package/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.15)
 project(PackageTest CXX)
 find_package(Catch2 CONFIG REQUIRED)
--- a/.github/workflows/mac-builds-m1.yml
+++ b/.github/workflows/mac-builds-m1.yml
@@ -1,4 +1,4 @@
-name: Arm Mac builds
+name: M1 Mac builds
 on: [push, pull_request]
--- a/.github/workflows/mac-builds.yml
+++ b/.github/workflows/mac-builds.yml
@@ -1,14 +1,10 @@
-name: Intel Mac builds
+name: Mac builds
 on: [push, pull_request]
 jobs:
  build:
-    # From macos-14 forward, the baseline "macos-X" image is Arm based,
+    runs-on: macos-12
    # and not Intel based. Thus this is the newest image we can use for
    # Intel MacOS CI, and there don't seem to be any plans to keep providing
    # the Intel based images for free to OSS projects.
    runs-on: macos-13
    strategy:
      matrix:
        cxx:
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -56,8 +56,6 @@ expand_template(
        "#cmakedefine CATCH_CONFIG_WCHAR": "",
        "#cmakedefine CATCH_CONFIG_WINDOWS_CRTDBG": "",
        "#cmakedefine CATCH_CONFIG_WINDOWS_SEH": "",
        "#cmakedefine CATCH_CONFIG_USE_BUILTIN_CONSTANT_P": "",
        "#cmakedefine CATCH_CONFIG_NO_USE_BUILTIN_CONSTANT_P": "",
    },
    template = "src/catch2/catch_user_config.hpp.in",
 )
--- a/CMake/CatchConfigOptions.cmake
+++ b/CMake/CatchConfigOptions.cmake
@@ -44,7 +44,6 @@ set(_OverridableOptions
  "WINDOWS_SEH"
  "GETENV"
  "EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT"
  "USE_BUILTIN_CONSTANT_P"
 )
 foreach(OptionName ${_OverridableOptions})
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.10)
 # detect if Catch is being bundled,
 # disable testsuite in that case
@@ -8,8 +8,6 @@ else()
  set(NOT_SUBPROJECT OFF)
 endif()
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 option(CATCH_INSTALL_DOCS "Install documentation alongside library" ON)
 option(CATCH_INSTALL_EXTRAS "Install extras (CMake scripts, debugger helpers) alongside library" ON)
 option(CATCH_DEVELOPMENT_BUILD "Build tests, enable warnings, enable Werror, etc" OFF)
@@ -35,12 +33,15 @@ if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 endif()
 project(Catch2
-  VERSION 3.8.1 # CML version placeholder, don't delete
+  VERSION 3.7.0 # CML version placeholder, don't delete
  LANGUAGES CXX
-  HOMEPAGE_URL "https://github.com/catchorg/Catch2"
+  # HOMEPAGE_URL is not supported until CMake version 3.12, which
  # we do not target yet.
  # HOMEPAGE_URL "https://github.com/catchorg/Catch2"
  DESCRIPTION "A modern, C++-native, unit test framework."
 )
 # Provide path for scripts. We first add path to the scripts we don't use,
 # but projects including us might, and set the path up to parent scope.
 # Then we also add path that we use to configure the project, but is of
@@ -85,22 +86,18 @@ if (BUILD_TESTING AND CATCH_BUILD_TESTING AND NOT_SUBPROJECT)
    if (NOT PYTHONINTERP_FOUND)
        message(FATAL_ERROR "Python not found, but required for tests")
    endif()
    set(CMAKE_FOLDER "tests")
    add_subdirectory(tests)
 endif()
 if(CATCH_BUILD_EXAMPLES)
    set(CMAKE_FOLDER "Examples")
    add_subdirectory(examples)
 endif()
 if(CATCH_BUILD_EXTRA_TESTS)
    set(CMAKE_FOLDER "tests/ExtraTests")
    add_subdirectory(tests/ExtraTests)
 endif()
 if(CATCH_BUILD_FUZZERS)
    set(CMAKE_FOLDER "fuzzing")
    add_subdirectory(fuzzing)
 endif()
@@ -190,6 +187,12 @@ if (NOT_SUBPROJECT)
        ${PKGCONFIG_INSTALL_DIR}
    )
    # CPack/CMake started taking the package version from project version 3.12
    # So we need to set the version manually for older CMake versions
    if(${CMAKE_VERSION} VERSION_LESS "3.12.0")
        set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
    endif()
    set(CPACK_PACKAGE_CONTACT "https://github.com/catchorg/Catch2/")
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -1,4 +1,3 @@
 module(name = "catch2")
 bazel_dep(name = "bazel_skylib", version = "1.7.1")
 bazel_dep(name = "rules_cc", version = "0.0.17")
--- a/WORKSPACE.bazel
+++ b/WORKSPACE.bazel
@@ -0,0 +1,16 @@
 workspace(name = "catch2")
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 http_archive(
    name = "bazel_skylib",
    sha256 = "bc283cdfcd526a52c3201279cda4bc298652efa898b10b4db0837dc51652756f",
    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",
    ],
 )
 load("@bazel_skylib//:workspace.bzl", "bazel_skylib_workspace")
 bazel_skylib_workspace()
--- a/docs/cmake-integration.md
+++ b/docs/cmake-integration.md
@@ -81,11 +81,12 @@ to your CMake module path.
 `Catch.cmake` provides function `catch_discover_tests` to get tests from
 a target. This function works by running the resulting executable with
-`--list-test` flag, and then parsing the output to find all existing tests.
+`--list-test-names-only` flag, and then parsing the output to find all
 existing tests.
 #### Usage
 ```cmake
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.5)
 project(baz LANGUAGES CXX VERSION 0.0.1)
@@ -127,8 +128,6 @@ catch_discover_tests(target
                     [OUTPUT_PREFIX prefix]
                     [OUTPUT_SUFFIX suffix]
                     [DISCOVERY_MODE <POST_BUILD|PRE_TEST>]
                     [SKIP_IS_FAILURE]
                     [ADD_TAGS_AS_LABELS]
 )
 ```
@@ -212,15 +211,6 @@ execution (useful e.g. in cross-compilation environments).
 calling ``catch_discover_tests``. This provides a mechanism for globally
 selecting a preferred test discovery behavior.
 * `SKIP_IS_FAILURE`
 Skipped tests will be marked as failed instead.
 * `ADD_TAGS_AS_LABELS`
 Add the tags from tests as labels to CTest.
 ### `ParseAndAddCatchTests.cmake`
 ⚠ This script is [deprecated](https://github.com/catchorg/Catch2/pull/2120)
@@ -239,7 +229,7 @@ parsed are *silently ignored*.
 #### Usage
 ```cmake
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.5)
 project(baz LANGUAGES CXX VERSION 0.0.1)
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -158,14 +158,11 @@ by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.
    CATCH_CONFIG_ANDROID_LOGWRITE           // Use android's logging system for debug output
    CATCH_CONFIG_GLOBAL_NEXTAFTER           // Use nextafter{,f,l} instead of std::nextafter
    CATCH_CONFIG_GETENV                     // System has a working `getenv`
    CATCH_CONFIG_USE_BUILTIN_CONSTANT_P     // Use __builtin_constant_p to trigger warnings
 > [`CATCH_CONFIG_ANDROID_LOGWRITE`](https://github.com/catchorg/Catch2/issues/1743) and [`CATCH_CONFIG_GLOBAL_NEXTAFTER`](https://github.com/catchorg/Catch2/pull/1739) were introduced in Catch2 2.10.0
 > `CATCH_CONFIG_GETENV` was [introduced](https://github.com/catchorg/Catch2/pull/2562) in Catch2 3.2.0
 > `CATCH_CONFIG_USE_BUILTIN_CONSTANT_P` was introduced in Catch2 vX.Y.Z
 Currently Catch enables `CATCH_CONFIG_WINDOWS_SEH` only when compiled with MSVC, because some versions of MinGW do not have the necessary Win32 API support.
 `CATCH_CONFIG_POSIX_SIGNALS` is on by default, except when Catch is compiled under `Cygwin`, where it is disabled by default (but can be force-enabled by defining `CATCH_CONFIG_POSIX_SIGNALS`).
@@ -186,12 +183,6 @@ With the exception of `CATCH_CONFIG_EXPERIMENTAL_REDIRECT`,
 these toggles can be disabled by using `_NO_` form of the toggle,
 e.g. `CATCH_CONFIG_NO_WINDOWS_SEH`.
 `CATCH_CONFIG_USE_BUILTIN_CONSTANT_P` is ON by default for Clang and GCC
 (but as far as possible, not for other compilers masquerading for these
 two). However, it can cause bugs where the enclosed code is evaluated, even
 though it should not be, e.g. in [#2925](https://github.com/catchorg/Catch2/issues/2925).
 ### `CATCH_CONFIG_FAST_COMPILE`
 This compile-time flag speeds up compilation of assertion macros by ~20%,
 by disabling the generation of assertion-local try-catch blocks for
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -2,9 +2,6 @@
 # Release notes
 **Contents**<br>
 [3.8.1](#381)<br>
 [3.8.0](#380)<br>
 [3.7.1](#371)<br>
 [3.7.0](#370)<br>
 [3.6.0](#360)<br>
 [3.5.4](#354)<br>
@@ -67,58 +64,6 @@
 [Even Older versions](#even-older-versions)<br>
 ## 3.8.1
 ### Fixes
 * Fixed bug where catch_discover_tests fails when no TEST_CASEs are present (#2962)
 * Fixed Clang 19 -Wc++20-extensions warning (#2968)
 ## 3.8.0
 ### Improvements
 * Added `std::initializer_list` overloads for `(Unordered)RangeEquals` matcher (#2915, #2919)
 * Added explicit casts to silence GCC's `Wconversion` (#2875)
 * Made the use of `builtin_constant_p` tricks in assertion macros configurable (#2925)
  * It is used to prod GCC-like compilers into providing warnings for the asserted expressions, but the compilers miscompile it annoyingly often.
 * Cleaned out Clang-Tidy's `performance-enum-size` warnings
 * Added support for using `from_range` generator with iterators with `value_type = const T` (#2926)
  * This is not correct `value_type` typedef, but it is used in the wild and the change does not make the code meaningfully worse.
 ### Fixes
 * Fixed crash when stringifying pre-1970 (epoch) dates on Windows (#2944)
 ### Miscellaneous
 * Fixes and improvements for `catch_discover_tests` CMake helper
  * Removed redundant `CTEST_FILE` param when creating the indirection file for `PRE_TEST` discovery mode (#2936)
  * Rewrote the test discovery logic to use output from the JSON reporter
    * This means that `catch_discover_tests` now requires CMake 3.19 or newer
  * Added `ADD_TAGS_AS_LABELS` option. If specified, each CTest test will be labeled with corrensponding Catch2's test tag
 * Bumped up the minimum required CMake version to build Catch2 to 3.16
 * Meson build now provides option to avoid installing Catch2
 * Bazel build is moved to Bzlmod.
 ## 3.7.1
 ### Improvements
 * Applied the JUnit reporter's optimization from last release to the SonarQube reporter
 * Suppressed `-Wuseless-cast` in `CHECK_THROWS_MATCHES` (#2904)
 * Standardize exit codes for various failures
  * Running no tests is now guaranteed to exit with 2 (without the `--allow-running-no-tests` flag)
  * All tests skipped is now always 4 (...)
  * Assertion failures are now always 42
  * and so on
 ### Fixes
 * Fixed out-of-bounds access when the arg parser encounters single `-` as an argument (#2905)
 ### Miscellaneous
 * Added `catch_config_prefix_messages.hpp` to meson build (#2903)
 * `catch_discover_tests` now supports skipped tests (#2873)
  * You can get the old behaviour by calling `catch_discover_tests` with `SKIP_IS_FAILURE` option.
 ## 3.7.0
 ### Improvements
--- a/docs/tostring.md
+++ b/docs/tostring.md
@@ -75,7 +75,7 @@ CATCH_TRANSLATE_EXCEPTION( MyType const& ex ) {
 Enums that already have a `<<` overload for `std::ostream` will convert to strings as expected.
 If you only need to convert enums to strings for test reporting purposes you can provide a `StringMaker` specialisations as any other type.
-However, as a convenience, Catch provides the `CATCH_REGISTER_ENUM` helper macro that will generate the `StringMaker` specialisation for you with minimal code.
+However, as a convenience, Catch provides the `REGISTER_ENUM` helper macro that will generate the `StringMaker` specialisation for you with minimal code.
 Simply provide it the (qualified) enum name, followed by all the enum values, and you're done!
 E.g.
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required( VERSION 3.16 )
+cmake_minimum_required( VERSION 3.10 )
 project( Catch2Examples LANGUAGES CXX )
--- a/extras/Catch.cmake
+++ b/extras/Catch.cmake
@@ -38,8 +38,6 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
                         [OUTPUT_PREFIX prefix]
                         [OUTPUT_SUFFIX suffix]
                         [DISCOVERY_MODE <POST_BUILD|PRE_TEST>]
                         [SKIP_IS_FAILURE]
                         [ADD_TAGS_AS_LABELS]
    )
  ``catch_discover_tests`` sets up a post-build command on the test executable
@@ -133,7 +131,7 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
    of test cases from the test executable and when the tests are executed themselves.
    This requires cmake/ctest >= 3.22.
-  ``DISCOVERY_MODE mode``
+  `DISCOVERY_MODE mode``
    Provides control over when ``catch_discover_tests`` performs test discovery.
    By default, ``POST_BUILD`` sets up a post-build command to perform test discovery
    at build time. In certain scenarios, like cross-compiling, this ``POST_BUILD``
@@ -146,12 +144,6 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
    calling ``catch_discover_tests``. This provides a mechanism for globally selecting
    a preferred test discovery behavior without having to modify each call site.
  ``SKIP_IS_FAILURE``
    Disables skipped test detection.
  ``ADD_TAGS_AS_LABELS``
    Adds all test tags as CTest labels.
 #]=======================================================================]
 #------------------------------------------------------------------------------
@@ -159,16 +151,12 @@ function(catch_discover_tests TARGET)
  cmake_parse_arguments(
    ""
-    "SKIP_IS_FAILURE;ADD_TAGS_AS_LABELS"
+    ""
    "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"
    ${ARGN}
  )
  if (${CMAKE_VERSION} VERSION_LESS "3.19")
    message(FATAL_ERROR "This script requires JSON support from CMake version 3.19 or greater.")
  endif()
  if(NOT _WORKING_DIRECTORY)
    set(_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
  endif()
@@ -204,9 +192,6 @@ function(catch_discover_tests TARGET)
    TARGET ${TARGET}
    PROPERTY CROSSCOMPILING_EMULATOR
  )
  if (NOT _SKIP_IS_FAILURE)
    set(_PROPERTIES ${_PROPERTIES} SKIP_RETURN_CODE 4)
  endif()
  if(_DISCOVERY_MODE STREQUAL "POST_BUILD")
    add_custom_command(
@@ -230,7 +215,6 @@ function(catch_discover_tests TARGET)
              -D "TEST_DL_PATHS=${_DL_PATHS}"
              -D "TEST_DL_FRAMEWORK_PATHS=${_DL_FRAMEWORK_PATHS}"
              -D "CTEST_FILE=${ctest_tests_file}"
              -D "ADD_TAGS_AS_LABELS=${_ADD_TAGS_AS_LABELS}"
              -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
      VERBATIM
    )
@@ -276,7 +260,7 @@ function(catch_discover_tests TARGET)
      "      CTEST_FILE"             " [==[" "${ctest_tests_file}"        "]==]"   "\n"
      "      TEST_DL_PATHS"          " [==[" "${_DL_PATHS}"               "]==]"   "\n"
      "      TEST_DL_FRAMEWORK_PATHS" " [==[" "${_DL_FRAMEWORK_PATHS}"     "]==]"   "\n"
-      "      ADD_TAGS_AS_LABELS"     " [==[" "${_ADD_TAGS_AS_LABELS}"     "]==]"   "\n"
+      "      CTEST_FILE"             " [==[" "${CTEST_FILE}"              "]==]"   "\n"
      "    )"                                                                      "\n"
      "  endif()"                                                                  "\n"
      "  include(\"${ctest_tests_file}\")"                                         "\n"
@@ -303,10 +287,22 @@ function(catch_discover_tests TARGET)
    endif()
  endif()
-  # Add discovered tests to directory TEST_INCLUDE_FILES
+  if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
-  set_property(DIRECTORY
+    # Add discovered tests to directory TEST_INCLUDE_FILES
-    APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
+    set_property(DIRECTORY
-  )
+      APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
    )
  else()
    # Add discovered tests as directory TEST_INCLUDE_FILE if possible
    get_property(test_include_file_set DIRECTORY PROPERTY TEST_INCLUDE_FILE SET)
    if (NOT ${test_include_file_set})
      set_property(DIRECTORY
        PROPERTY TEST_INCLUDE_FILE "${ctest_include_file}"
      )
    else()
      message(FATAL_ERROR "Cannot set more than one TEST_INCLUDE_FILE")
    endif()
  endif()
 endfunction()
--- a/extras/CatchAddTests.cmake
+++ b/extras/CatchAddTests.cmake
@@ -22,11 +22,10 @@ function(catch_discover_tests_impl)
    ""
    ""
    "TEST_EXECUTABLE;TEST_WORKING_DIR;TEST_OUTPUT_DIR;TEST_OUTPUT_PREFIX;TEST_OUTPUT_SUFFIX;TEST_PREFIX;TEST_REPORTER;TEST_SPEC;TEST_SUFFIX;TEST_LIST;CTEST_FILE"
-    "TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR;TEST_DL_PATHS;TEST_DL_FRAMEWORK_PATHS;ADD_TAGS_AS_LABELS"
+    "TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR;TEST_DL_PATHS;TEST_DL_FRAMEWORK_PATHS"
    ${ARGN}
  )
  set(add_tags "${_ADD_TAGS_AS_LABELS}")
  set(prefix "${_TEST_PREFIX}")
  set(suffix "${_TEST_SUFFIX}")
  set(spec ${_TEST_SPEC})
@@ -73,19 +72,25 @@ function(catch_discover_tests_impl)
  endif()
  execute_process(
-    COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} --list-tests --reporter json
+    COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
-    OUTPUT_VARIABLE listing_output
+    OUTPUT_VARIABLE output
    RESULT_VARIABLE result
    WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
  )
  if(NOT ${result} EQUAL 0)
    message(FATAL_ERROR
-      "Error listing tests from executable '${_TEST_EXECUTABLE}':\n"
+      "Error running test executable '${_TEST_EXECUTABLE}':\n"
      "  Result: ${result}\n"
-      "  Output: ${listing_output}\n"
+      "  Output: ${output}\n"
    )
  endif()
  # Make sure to escape ; (semicolons) in test names first, because
  # that'd break the foreach loop for "Parse output" later and create
  # wrongly splitted and thus failing test cases (false positives)
  string(REPLACE ";" "\;" output "${output}")
  string(REPLACE "\n" ";" output "${output}")
  # Prepare reporter
  if(reporter)
    set(reporter_arg "--reporter ${reporter}")
@@ -105,7 +110,7 @@ function(catch_discover_tests_impl)
      )
    elseif(NOT ${reporter_check_result} EQUAL 0)
      message(FATAL_ERROR
-        "Error checking for reporter in test executable '${_TEST_EXECUTABLE}':\n"
+        "Error running test executable '${_TEST_EXECUTABLE}':\n"
        "  Result: ${reporter_check_result}\n"
        "  Output: ${reporter_check_output}\n"
      )
@@ -134,92 +139,46 @@ function(catch_discover_tests_impl)
    endforeach()
  endif()
-  # Parse JSON output for list of tests/class names/tags
+  # Parse output
-  string(JSON version GET "${listing_output}" "version")
+  foreach(line ${output})
-  if (NOT version STREQUAL "1")
+    set(test "${line}")
    message(FATAL_ERROR "Unsupported catch output version: '${version}'")
  endif()
  # Speed-up reparsing by cutting away unneeded parts of JSON.
  string(JSON test_listing GET "${listing_output}" "listings" "tests")
  string(JSON num_tests LENGTH "${test_listing}")
  # Exit early if no tests are detected
  if(num_tests STREQUAL "0")
    return()
  endif()
  # CMake's foreach-RANGE is inclusive, so we have to subtract 1
  math(EXPR num_tests "${num_tests} - 1")
  foreach(idx RANGE ${num_tests})
    string(JSON single_test GET ${test_listing} ${idx})
    string(JSON test_tags GET "${single_test}" "tags")
    string(JSON plain_name GET "${single_test}" "name")
    # Escape characters in test case names that would be parsed by Catch2
    # Note that the \ escaping must happen FIRST! Do not change the order.
-    set(escaped_name "${plain_name}")
+    set(test_name "${test}")
-    foreach(char \\ , [ ] ;)
+    foreach(char \\ , [ ])
-      string(REPLACE ${char} "\\${char}" escaped_name "${escaped_name}")
+      string(REPLACE ${char} "\\${char}" test_name "${test_name}")
    endforeach(char)
    # ...add output dir
    if(output_dir)
-      string(REGEX REPLACE "[^A-Za-z0-9_]" "_" escaped_name_clean "${escaped_name}")
+      string(REGEX REPLACE "[^A-Za-z0-9_]" "_" test_name_clean "${test_name}")
-      set(output_dir_arg "--out ${output_dir}/${output_prefix}${escaped_name_clean}${output_suffix}")
+      set(output_dir_arg "--out ${output_dir}/${output_prefix}${test_name_clean}${output_suffix}")
    endif()
    # ...and add to script
    add_command(add_test
-      "${prefix}${plain_name}${suffix}"
+      "${prefix}${test}${suffix}"
      ${_TEST_EXECUTOR}
      "${_TEST_EXECUTABLE}"
-      "${escaped_name}"
+      "${test_name}"
      ${extra_args}
      "${reporter_arg}"
      "${output_dir_arg}"
    )
    add_command(set_tests_properties
-      "${prefix}${plain_name}${suffix}"
+      "${prefix}${test}${suffix}"
      PROPERTIES
      WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
      ${properties}
    )
    if (add_tags)
      string(JSON num_tags LENGTH "${test_tags}")
      math(EXPR num_tags "${num_tags} - 1")
      set(tag_list "")
      if (num_tags GREATER_EQUAL "0")
        foreach(tag_idx RANGE ${num_tags})
          string(JSON a_tag GET "${test_tags}" "${tag_idx}")
          # Catch2's tags can contain semicolons, which are list element separators
          # in CMake, so we have to escape them. Ideally we could use the [=[...]=]
          # syntax for this, but CTest currently keeps the square quotes in the label
          # name. So we add 2 backslashes to escape it instead.
          # **IMPORTANT**: The number of backslashes depends on how many layers
          #                of CMake the tag goes. If this script is changed, the
          #                number of backslashes to escape may change as well.
          string(REPLACE ";" "\\;" a_tag "${a_tag}")
          list(APPEND tag_list "${a_tag}")
        endforeach()
        add_command(set_tests_properties
          "${prefix}${plain_name}${suffix}"
          PROPERTIES
          LABELS "${tag_list}"
        )
      endif()
    endif(add_tags)
    if(environment_modifications)
      add_command(set_tests_properties
-        "${prefix}${plain_name}${suffix}"
+        "${prefix}${test}${suffix}"
        PROPERTIES
        ENVIRONMENT_MODIFICATION "${environment_modifications}")
    endif()
-    list(APPEND tests "${prefix}${plain_name}${suffix}")
+    list(APPEND tests "${prefix}${test}${suffix}")
  endforeach()
  # Create a list of all discovered tests, which users may use to e.g. set
@@ -248,6 +207,5 @@ if(CMAKE_SCRIPT_MODE_FILE)
    TEST_DL_PATHS ${TEST_DL_PATHS}
    TEST_DL_FRAMEWORK_PATHS ${TEST_DL_FRAMEWORK_PATHS}
    CTEST_FILE ${CTEST_FILE}
    ADD_TAGS_AS_LABELS ${ADD_TAGS_AS_LABELS}
  )
 endif()
--- a/extras/catch_amalgamated.cpp
+++ b/extras/catch_amalgamated.cpp
@@ -6,8 +6,8 @@
 // SPDX-License-Identifier: BSL-1.0
-//  Catch v3.8.1
+//  Catch v3.7.0
-//  Generated: 2025-04-08 12:33:19.863332
+//  Generated: 2024-08-14 12:04:53.604337
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -332,7 +332,7 @@ namespace Catch {
                                             double diff = b - m;
                                             return a + diff * diff;
                                         } ) /
-                        static_cast<double>( last - first );
+                        ( last - first );
                    return std::sqrt( variance );
                }
@@ -367,7 +367,7 @@ namespace Catch {
                                              double* first,
                                              double* last ) {
                auto count = last - first;
-                double idx = static_cast<double>((count - 1) * k) / static_cast<double>(q);
+                double idx = (count - 1) * k / static_cast<double>(q);
                int j = static_cast<int>(idx);
                double g = idx - j;
                std::nth_element(first, first + j, last);
@@ -470,10 +470,10 @@ namespace Catch {
                double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) );
                long n = static_cast<long>( resample.size() );
-                double prob_n = static_cast<double>(
+                double prob_n =
                    std::count_if( resample.begin(),
                                   resample.end(),
-                                   [point]( double x ) { return x < point; } )) /
+                                   [point]( double x ) { return x < point; } ) /
                    static_cast<double>( n );
                // degenerate case with uniform samples
                if ( Catch::Detail::directCompare( prob_n, 0. ) ) {
@@ -627,7 +627,7 @@ std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {
 namespace Catch {
-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const& _lazyExpression):
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
        lazyExpression(_lazyExpression),
        resultType(_resultType) {}
@@ -1170,13 +1170,7 @@ namespace Catch {
 namespace Catch {
    namespace {
-        static constexpr int TestFailureExitCode = 42;
+        const int MaxExitCode = 255;
        static constexpr int UnspecifiedErrorExitCode = 1;
        static constexpr int AllTestsSkippedExitCode = 4;
        static constexpr int NoTestsRunExitCode = 2;
        static constexpr int UnmatchedTestSpecExitCode = 3;
        static constexpr int InvalidTestSpecExitCode = 5;
        IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
@@ -1340,7 +1334,8 @@ namespace Catch {
    }
    int Session::applyCommandLine( int argc, char const * const * argv ) {
-        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
+        if( m_startupExceptions )
            return 1;
        auto result = m_cli.parse( Clara::Args( argc, argv ) );
@@ -1356,7 +1351,7 @@ namespace Catch {
                << TextFlow::Column( result.errorMessage() ).indent( 2 )
                << "\n\n";
            errStream->stream() << "Run with -? for usage\n\n" << std::flush;
-            return UnspecifiedErrorExitCode;
+            return MaxExitCode;
        }
        if( m_configData.showHelp )
@@ -1426,7 +1421,8 @@ namespace Catch {
    }
    int Session::runInternal() {
-        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
+        if( m_startupExceptions )
            return 1;
        if (m_configData.showHelp || m_configData.libIdentify) {
            return 0;
@@ -1437,7 +1433,7 @@ namespace Catch {
                          << ") must be greater than the shard index ("
                          << m_configData.shardIndex << ")\n"
                          << std::flush;
-            return UnspecifiedErrorExitCode;
+            return 1;
        }
        CATCH_TRY {
@@ -1460,7 +1456,7 @@ namespace Catch {
                for ( auto const& spec : invalidSpecs ) {
                    reporter->reportInvalidTestSpec( spec );
                }
-                return InvalidTestSpecExitCode;
+                return 1;
            }
@@ -1474,29 +1470,29 @@ namespace Catch {
            if ( tests.hadUnmatchedTestSpecs()
                && m_config->warnAboutUnmatchedTestSpecs() ) {
-                // UnmatchedTestSpecExitCode
+                return 3;
                return UnmatchedTestSpecExitCode;
            }
            if ( totals.testCases.total() == 0
                && !m_config->zeroTestsCountAsSuccess() ) {
-                return NoTestsRunExitCode;
+                return 2;
            }
            if ( totals.testCases.total() > 0 &&
                 totals.testCases.total() == totals.testCases.skipped
                && !m_config->zeroTestsCountAsSuccess() ) {
-                return AllTestsSkippedExitCode;
+                return 4;
            }
-            if ( totals.assertions.failed ) { return TestFailureExitCode; }
+            // Note that on unices only the lower 8 bits are usually used, clamping
-            return 0;
+            // the return value to 255 prevents false negative when some multiple
-
+            // of 256 tests has failed
            return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed));
        }
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
        catch( std::exception& ex ) {
            Catch::cerr() << ex.what() << '\n' << std::flush;
-            return UnspecifiedErrorExitCode;
+            return MaxExitCode;
        }
 #endif
    }
@@ -1532,26 +1528,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;
@@ -1590,7 +1586,7 @@ namespace Catch {
            return "Anonymous test case " + std::to_string(++counter);
        }
-        constexpr StringRef extractFilenamePart(StringRef filename) {
+        StringRef extractFilenamePart(StringRef filename) {
            size_t lastDot = filename.size();
            while (lastDot > 0 && filename[lastDot - 1] != '.') {
                --lastDot;
@@ -1608,7 +1604,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;
@@ -1769,6 +1765,10 @@ namespace Catch {
        return lhs.tags < rhs.tags;
    }
    TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const {
        return *m_info;
    }
 } // end namespace Catch
@@ -1909,7 +1909,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
@@ -1926,7 +1926,7 @@ namespace Catch {
        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
    }
    auto Timer::getElapsedSeconds() const -> double {
-        return static_cast<double>(getElapsedMicroseconds())/1000000.0;
+        return getElapsedMicroseconds()/1000000.0;
    }
@@ -1946,10 +1946,7 @@ namespace Detail {
        const int hexThreshold = 255;
        struct Endianness {
-            enum Arch : uint8_t {
+            enum Arch { Big, Little };
                Big,
                Little
            };
            static Arch which() {
                int one = 1;
@@ -2283,7 +2280,7 @@ namespace Catch {
    }
    Version const& libraryVersion() {
-        static Version version( 3, 8, 1, "", 0 );
+        static Version version( 3, 7, 0, "", 0 );
        return version;
    }
@@ -2539,8 +2536,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) {
+    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, CATCH_MOVE(message), m_reaction );
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
    }
    auto AssertionHandler::allowThrows() const -> bool {
@@ -2686,7 +2683,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(
@@ -3519,7 +3516,7 @@ namespace {
 #endif // Windows/ ANSI/ None
-#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC ) || defined( __GLIBC__ )
+#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )
 #    define CATCH_INTERNAL_HAS_ISATTY
 #    include <unistd.h>
 #endif
@@ -3659,6 +3656,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;
@@ -5261,7 +5264,7 @@ namespace {
    SimplePcg32::result_type SimplePcg32::operator()() {
        // prepare the output value
        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
-        const auto output = rotate_right(xorshifted, static_cast<uint32_t>(m_state >> 59u));
+        const auto output = rotate_right(xorshifted, m_state >> 59u);
        // advance state
        m_state = m_state * 6364136223846793005ULL + s_inc;
@@ -5544,6 +5547,26 @@ ReporterSpec::ReporterSpec(
 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
 #include <cstdio>
 #include <sstream>
 #include <vector>
@@ -6209,13 +6232,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 ) };
@@ -7130,7 +7153,7 @@ namespace Catch {
            TestType m_testAsFunction;
        public:
-            constexpr TestInvokerAsFunction( TestType testAsFunction ) noexcept:
+            TestInvokerAsFunction( TestType testAsFunction ) noexcept:
                m_testAsFunction( testAsFunction ) {}
            void invoke() const override { m_testAsFunction(); }
@@ -7865,16 +7888,36 @@ namespace {
        os.flags(f);
    }
-    constexpr bool shouldNewline(XmlFormatting fmt) {
+    bool shouldNewline(XmlFormatting fmt) {
        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline));
    }
-    constexpr bool shouldIndent(XmlFormatting fmt) {
+    bool shouldIndent(XmlFormatting fmt) {
        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent));
    }
 } // anonymous namespace
    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
        return static_cast<XmlFormatting>(
            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) |
            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
        );
    }
    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
        return static_cast<XmlFormatting>(
            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) &
            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
        );
    }
    XmlEncode::XmlEncode( StringRef str, ForWhat forWhat )
    :   m_str( str ),
        m_forWhat( forWhat )
    {}
    void XmlEncode::encodeTo( std::ostream& os ) const {
        // Apostrophe escaping not necessary if we always use " to write attributes
        // (see: http://www.w3.org/TR/xml/#syntax)
@@ -9111,7 +9154,7 @@ struct RowBreak {};
 struct OutputFlush {};
 class Duration {
-    enum class Unit : uint8_t {
+    enum class Unit {
        Auto,
        Nanoseconds,
        Microseconds,
@@ -9183,10 +9226,7 @@ public:
 };
 } // end anon namespace
-enum class Justification : uint8_t {
+enum class Justification { Left, Right };
    Left,
    Right
 };
 struct ColumnInfo {
    std::string name;
@@ -11010,9 +11050,9 @@ namespace Catch {
        if (!rootName.empty())
            name = rootName + '/' + name;
-        if ( sectionNode.stats.assertions.total() > 0
+        if ( sectionNode.hasAnyAssertions()
            || !sectionNode.stdOut.empty()
-            || !sectionNode.stdErr.empty() ) {
+            ||  !sectionNode.stdErr.empty() ) {
            XmlWriter::ScopedElement e = xml.scopedElement("testCase");
            xml.writeAttribute("name"_sr, name);
            xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
--- a/extras/catch_amalgamated.hpp
+++ b/extras/catch_amalgamated.hpp
@@ -6,8 +6,8 @@
 // SPDX-License-Identifier: BSL-1.0
-//  Catch v3.8.1
+//  Catch v3.7.0
-//  Generated: 2025-04-08 12:33:19.851017
+//  Generated: 2024-08-14 12:04:53.220567
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -150,7 +150,7 @@
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
         _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
-#    define CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
 #endif
@@ -174,45 +174,14 @@
 // clang-cl defines _MSC_VER as well as __clang__, which could cause the
 // start/stop internal suppression macros to be double defined.
 #if defined(__clang__) && !defined(_MSC_VER)
-#    define CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P
+
 #    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
 #    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
 #endif // __clang__ && !_MSC_VER
 #if defined(__clang__)
 #    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
 #    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
 #    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
 #    if (__clang_major__ >= 20)
 #        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
             _Pragma( "clang diagnostic ignored \"-Wvariadic-macro-arguments-omitted\"" )
 #    elif (__clang_major__ == 19)
 #        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
 	         _Pragma( "clang diagnostic ignored \"-Wc++20-extensions\"" )
 #    else
 #        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
             _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
 #    endif
 #    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
 #    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
 #endif // __clang__
 // As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
 // which results in calls to destructors being emitted for each temporary,
 // without a matching initialization. In practice, this can result in something
@@ -229,11 +198,35 @@
 // https://developer.nvidia.com/nvidia_bug/3321845.
 //
 // Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
-#if defined( __ibmxl__ ) || defined( __CUDACC__ ) || defined( __NVCOMPILER )
+#  if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
-#    define CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
-#endif
+#  endif
 #    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
 #    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
 #    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
 #    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
 #    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
 #    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
 #endif // __clang__
 ////////////////////////////////////////////////////////////////////////////////
 // We know some environments not to support full POSIX signals
@@ -457,22 +450,6 @@
 #endif
 // The goal of this macro is to avoid evaluation of the arguments, but
 // still have the compiler warn on problems inside...
 #if defined( CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
    !defined( CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P ) && !defined(CATCH_CONFIG_USE_BUILTIN_CONSTANT_P)
 #define CATCH_CONFIG_USE_BUILTIN_CONSTANT_P
 #endif
 #if defined( CATCH_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
    !defined( CATCH_CONFIG_NO_USE_BUILTIN_CONSTANT_P )
 #    define CATCH_INTERNAL_IGNORE_BUT_WARN( ... )                                              \
        (void)__builtin_constant_p( __VA_ARGS__ ) /* NOLINT(cppcoreguidelines-pro-type-vararg, \
                                                     hicpp-vararg) */
 #else
 #    define CATCH_INTERNAL_IGNORE_BUT_WARN( ... )
 #endif
 // Even if we do not think the compiler has that warning, we still have
 // to provide a macro that can be used by the code.
 #if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
@@ -509,6 +486,13 @@
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
 #endif
 // The goal of this macro is to avoid evaluation of the arguments, but
 // still have the compiler warn on problems inside...
 #if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
 #   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
 #endif
 #if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
 #   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
 #elif defined(__clang__) && (__clang_major__ < 5)
@@ -571,15 +555,10 @@ namespace Catch {
        friend void cleanUpContext();
    public:
-        constexpr IResultCapture* getResultCapture() const {
+        IResultCapture* getResultCapture() const { return m_resultCapture; }
-            return m_resultCapture;
+        IConfig const* getConfig() const { return m_config; }
-        }
+        void setResultCapture( IResultCapture* resultCapture );
-        constexpr IConfig const* getConfig() const { return m_config; }
+        void setConfig( IConfig const* config );
        constexpr void setResultCapture( IResultCapture* resultCapture ) {
            m_resultCapture = resultCapture;
        }
        constexpr void setConfig( IConfig const* config ) { m_config = config; }
    };
    Context& getCurrentMutableContext();
@@ -690,6 +669,7 @@ namespace Catch {
 #define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
 #include <string>
 #include <chrono>
@@ -839,10 +819,8 @@ namespace Catch {
    }; };
-    constexpr bool isOk( ResultWas::OfType resultType ) {
+    bool isOk( ResultWas::OfType resultType );
-        return ( resultType & ResultWas::FailureBit ) == 0;
+    bool isJustInfo( int flags );
    }
    constexpr bool isJustInfo( int flags ) { return flags == ResultWas::Info; }
    // ResultDisposition::Flags enum
@@ -854,18 +832,11 @@ namespace Catch {
        SuppressFail = 0x08         // Failures are reported but do not fail the test
    }; };
-    constexpr ResultDisposition::Flags operator|( ResultDisposition::Flags lhs,
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
                                        ResultDisposition::Flags rhs ) {
        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) |
                                                      static_cast<int>( rhs ) );
    }
-    constexpr bool isFalseTest( int flags ) {
+    bool shouldContinueOnFailure( int flags );
-        return ( flags & ResultDisposition::FalseTest ) != 0;
+    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    }
+    bool shouldSuppressFailure( int flags );
    constexpr bool shouldSuppressFailure( int flags ) {
        return ( flags & ResultDisposition::SuppressFail ) != 0;
    }
 } // end namespace Catch
@@ -1083,7 +1054,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,
@@ -1331,7 +1302,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;
            }
        };
@@ -3066,11 +3037,7 @@ struct ratio_string<std::milli> {
 #ifdef _MSC_VER
            std::tm timeInfo = {};
-            const auto err = gmtime_s(&timeInfo, &converted);
+            gmtime_s(&timeInfo, &converted);
            if ( err ) {
                return "gmtime from provided timepoint has failed. This "
                       "happens e.g. with pre-1970 dates using Microsoft libc";
            }
 #else
            std::tm* timeInfo = std::gmtime(&converted);
 #endif
@@ -3300,13 +3267,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;
        }
@@ -4045,7 +4012,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 )
 ///////////////////////////////////////////////////////////////////////////////
@@ -5305,9 +5272,6 @@ namespace Catch {
        bool m_isBinaryExpression;
        bool m_result;
    protected:
        ~ITransientExpression() = default;
    public:
        constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
        constexpr auto getResult() const -> bool { return m_result; }
@@ -5319,13 +5283,17 @@ namespace Catch {
            m_result( result )
        {}
-        constexpr ITransientExpression( ITransientExpression const& ) = default;
+        ITransientExpression() = default;
-        constexpr ITransientExpression& operator=( ITransientExpression const& ) = default;
+        ITransientExpression(ITransientExpression const&) = default;
        ITransientExpression& operator=(ITransientExpression const&) = default;
        friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) {
            expr.streamReconstructedExpression(out);
            return out;
        }
    protected:
        ~ITransientExpression() = default;
    };
    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
@@ -5634,12 +5602,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();
@@ -5695,6 +5663,8 @@ namespace Catch {
 #endif
 #define INTERNAL_CATCH_REACT( handler ) handler.complete();
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
    do { /* NOLINT(bugprone-infinite-loop) */ \
@@ -5707,7 +5677,7 @@ namespace Catch {
            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); /* NOLINT(bugprone-chained-comparison) */ \
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( (void)0, (false) && static_cast<const bool&>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
@@ -5735,7 +5705,7 @@ namespace Catch {
        catch( ... ) { \
            catchAssertionHandler.handleUnexpectedInflightException(); \
        } \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )
 ///////////////////////////////////////////////////////////////////////////////
@@ -5756,7 +5726,7 @@ namespace Catch {
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )
 ///////////////////////////////////////////////////////////////////////////////
@@ -5780,7 +5750,7 @@ namespace Catch {
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )
@@ -5804,7 +5774,7 @@ namespace Catch {
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )
 #endif // CATCH_CONFIG_DISABLE
@@ -6005,8 +5975,7 @@ template<typename C>
 class TestInvokerAsMethod : public ITestInvoker {
    void (C::*m_testAsMethod)();
 public:
-    constexpr TestInvokerAsMethod( void ( C::*testAsMethod )() ) noexcept:
+    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
        m_testAsMethod( testAsMethod ) {}
    void invoke() const override {
        C obj;
@@ -6027,8 +5996,7 @@ class TestInvokerFixture : public ITestInvoker {
    Detail::unique_ptr<C> m_fixture = nullptr;
 public:
-    constexpr TestInvokerFixture( void ( C::*testAsMethod )() const ) noexcept:
+    TestInvokerFixture( void ( C::*testAsMethod )() const) noexcept : m_testAsMethod( testAsMethod ) {}
        m_testAsMethod( testAsMethod ) {}
    void prepareTestCase() override {
        m_fixture = Detail::make_unique<C>();
@@ -7168,7 +7136,7 @@ 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 {
@@ -7183,9 +7151,7 @@ namespace Catch {
            m_invoker->invoke();
        }
-        constexpr TestCaseInfo const& getTestCaseInfo() const {
+        TestCaseInfo const& getTestCaseInfo() const;
            return *m_info;
        }
    };
    Detail::unique_ptr<TestCaseInfo>
@@ -7248,7 +7214,7 @@ namespace Catch {
        class ExceptionTranslator : public IExceptionTranslator {
        public:
-            constexpr ExceptionTranslator( std::string(*translateFunction)( T const& ) )
+            ExceptionTranslator( std::string(*translateFunction)( T const& ) )
            : m_translateFunction( translateFunction )
            {}
@@ -7349,8 +7315,8 @@ namespace Catch {
 #define CATCH_VERSION_MACROS_HPP_INCLUDED
 #define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 8
+#define CATCH_VERSION_MINOR 7
-#define CATCH_VERSION_PATCH 1
+#define CATCH_VERSION_PATCH 0
 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED
@@ -8077,7 +8043,7 @@ namespace Catch {
        struct ExtendedMultResult {
            T upper;
            T lower;
-            constexpr bool operator==( ExtendedMultResult const& rhs ) const {
+            bool operator==( ExtendedMultResult const& rhs ) const {
                return upper == rhs.upper && lower == rhs.lower;
            }
        };
@@ -8195,7 +8161,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(
@@ -8216,7 +8181,6 @@ namespace Catch {
        template <typename OriginalType,
                  typename UnsignedType>
        constexpr
        std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
            transposeToNaturalOrder(UnsignedType in) {
            static_assert(
@@ -8268,24 +8232,24 @@ class uniform_integer_distribution {
    // distribution will be reused many times and this is an optimization.
    UnsignedIntegerType m_rejection_threshold = 0;
-    static constexpr UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) {
+    UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) const {
        // This overflows and returns 0 if a == 0 and b == TYPE_MAX.
        // We handle that later when generating the number.
        return transposeTo(b) - transposeTo(a) + 1;
    }
-    static constexpr UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
+    static UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
        // distance == 0 means that we will return all possible values from
        // the type's range, and that we shouldn't reject anything.
        if ( ab_distance == 0 ) { return 0; }
        return ( ~ab_distance + 1 ) % ab_distance;
    }
-    static constexpr UnsignedIntegerType transposeTo(IntegerType in) {
+    static UnsignedIntegerType transposeTo(IntegerType in) {
        return Detail::transposeToNaturalOrder<IntegerType>(
            static_cast<UnsignedIntegerType>( in ) );
    }
-    static constexpr IntegerType transposeBack(UnsignedIntegerType in) {
+    static IntegerType transposeBack(UnsignedIntegerType in) {
        return static_cast<IntegerType>(
            Detail::transposeToNaturalOrder<IntegerType>(in) );
    }
@@ -8293,7 +8257,7 @@ class uniform_integer_distribution {
 public:
    using result_type = IntegerType;
-    constexpr uniform_integer_distribution( IntegerType a, IntegerType b ):
+    uniform_integer_distribution( IntegerType a, IntegerType b ):
        m_a( transposeTo(a) ),
        m_ab_distance( computeDistance(a, b) ),
        m_rejection_threshold( computeRejectionThreshold(m_ab_distance) ) {
@@ -8301,7 +8265,7 @@ public:
    }
    template <typename Generator>
-    constexpr result_type operator()( Generator& g ) {
+    result_type operator()( Generator& g ) {
        // All possible values of result_type are valid.
        if ( m_ab_distance == 0 ) {
            return transposeBack( Detail::fillBitsFrom<UnsignedIntegerType>( g ) );
@@ -8319,8 +8283,8 @@ public:
        return transposeBack(m_a + emul.upper);
    }
-    constexpr result_type a() const { return transposeBack(m_a); }
+    result_type a() const { return transposeBack(m_a); }
-    constexpr result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
+    result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
 };
 } // end namespace Catch
@@ -8733,7 +8697,7 @@ public:
 template <typename InputIterator,
          typename InputSentinel,
-          typename ResultType = std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type>>
+          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
 GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
    return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(from, to));
 }
@@ -9778,7 +9742,6 @@ namespace Catch {
                  typename Sentinel,
                  typename T,
                  typename Comparator>
        constexpr
        ForwardIter find_sentinel( ForwardIter start,
                                   Sentinel sentinel,
                                   T const& value,
@@ -9794,7 +9757,6 @@ namespace Catch {
                  typename Sentinel,
                  typename T,
                  typename Comparator>
        constexpr
        std::ptrdiff_t count_sentinel( ForwardIter start,
                                       Sentinel sentinel,
                                       T const& value,
@@ -9808,7 +9770,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 ) {
@@ -9821,8 +9782,8 @@ namespace Catch {
        }
        template <typename ForwardIter>
-        constexpr std::ptrdiff_t sentinel_distance( ForwardIter first,
+        std::ptrdiff_t sentinel_distance( ForwardIter first,
-                                                    ForwardIter last ) {
+                                          ForwardIter last ) {
            return std::distance( first, last );
        }
@@ -9831,11 +9792,11 @@ namespace Catch {
                  typename ForwardIter2,
                  typename Sentinel2,
                  typename Comparator>
-        constexpr bool check_element_counts( ForwardIter1 first_1,
+        bool check_element_counts( ForwardIter1 first_1,
-                                             const Sentinel1 end_1,
+                                   const Sentinel1 end_1,
-                                             ForwardIter2 first_2,
+                                   ForwardIter2 first_2,
-                                             const Sentinel2 end_2,
+                                   const Sentinel2 end_2,
-                                             Comparator cmp ) {
+                                   Comparator cmp ) {
            auto cursor = first_1;
            while ( cursor != end_1 ) {
                if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
@@ -9865,11 +9826,11 @@ namespace Catch {
                  typename ForwardIter2,
                  typename Sentinel2,
                  typename Comparator>
-        constexpr bool is_permutation( ForwardIter1 first_1,
+        bool is_permutation( ForwardIter1 first_1,
-                                       const Sentinel1 end_1,
+                             const Sentinel1 end_1,
-                                       ForwardIter2 first_2,
+                             ForwardIter2 first_2,
-                                       const Sentinel2 end_2,
+                             const Sentinel2 end_2,
-                                       Comparator cmp ) {
+                             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
@@ -10525,7 +10486,7 @@ namespace Catch {
        void handleMessage
                (   AssertionInfo const& info,
                    ResultWas::OfType resultType,
-                    std::string&& message,
+                    StringRef message,
                    AssertionReaction& reaction ) override;
        void handleUnexpectedExceptionNotThrown
                (   AssertionInfo const& info,
@@ -11310,25 +11271,16 @@ namespace Catch {
 #include <iosfwd>
 #include <vector>
 #include <cstdint>
 namespace Catch {
-    enum class XmlFormatting : std::uint8_t {
+    enum class XmlFormatting {
        None = 0x00,
        Indent = 0x01,
        Newline = 0x02,
    };
-    constexpr XmlFormatting operator|( XmlFormatting lhs, XmlFormatting rhs ) {
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) |
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
                                           static_cast<std::uint8_t>( rhs ) );
    }
    constexpr XmlFormatting operator&( XmlFormatting lhs, XmlFormatting rhs ) {
        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) &
                                           static_cast<std::uint8_t>( rhs ) );
    }
    /**
     * Helper for XML-encoding text (escaping angle brackets, quotes, etc)
@@ -11340,9 +11292,7 @@ namespace Catch {
    public:
        enum ForWhat { ForTextNodes, ForAttributes };
-        constexpr XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes ):
+        XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes );
            m_str( str ), m_forWhat( forWhat ) {}
        void encodeTo( std::ostream& os ) const;
@@ -11505,7 +11455,7 @@ namespace Catch {
        ArgT && m_arg;
        MatcherT const& m_matcher;
    public:
-        constexpr MatchExpr( ArgT && arg, MatcherT const& matcher )
+        MatchExpr( ArgT && arg, MatcherT const& matcher )
        :   ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
            m_arg( CATCH_FORWARD(arg) ),
            m_matcher( matcher )
@@ -11535,8 +11485,7 @@ namespace Catch {
    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );
    template<typename ArgT, typename MatcherT>
-    constexpr MatchExpr<ArgT, MatcherT>
+    auto makeMatchExpr( ArgT && arg, MatcherT const& matcher ) -> MatchExpr<ArgT, MatcherT> {
    makeMatchExpr( ArgT&& arg, MatcherT const& matcher ) {
        return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher );
    }
@@ -11550,7 +11499,7 @@ namespace Catch {
        INTERNAL_CATCH_TRY { \
            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher ) ); \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )
@@ -11560,10 +11509,7 @@ namespace Catch {
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
                static_cast<void>(__VA_ARGS__ ); \
                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( exceptionType const& ex ) { \
@@ -11574,7 +11520,7 @@ namespace Catch {
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
-        catchAssertionHandler.complete(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )
@@ -12643,14 +12589,12 @@ namespace Catch {
        public:
            template <typename TargetRangeLike2, typename Equality2>
            constexpr
            RangeEqualsMatcher( TargetRangeLike2&& range,
                                Equality2&& predicate ):
                m_desired( CATCH_FORWARD( range ) ),
                m_predicate( CATCH_FORWARD( predicate ) ) {}
            template <typename RangeLike>
            constexpr
            bool match( RangeLike&& rng ) const {
                auto rng_start = begin( rng );
                const auto rng_end = end( rng );
@@ -12683,14 +12627,12 @@ namespace Catch {
        public:
            template <typename TargetRangeLike2, typename Equality2>
            constexpr
            UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
                                         Equality2&& predicate ):
                m_desired( CATCH_FORWARD( range ) ),
                m_predicate( CATCH_FORWARD( predicate ) ) {}
            template <typename RangeLike>
            constexpr
            bool match( RangeLike&& rng ) const {
                using std::begin;
                using std::end;
@@ -12711,65 +12653,52 @@ namespace Catch {
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in another range.
         *
-         * Uses the provided predicate `predicate` to do the comparisons
+         * Uses `std::equal_to` to do the comparison
         * (defaulting to `std::equal_to`)
         */
-        template <typename RangeLike,
+        template <typename RangeLike>
-                  typename Equality = decltype( std::equal_to<>{} )>
+        std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
-        constexpr
+                         RangeEqualsMatcher<RangeLike, std::equal_to<>>>
        RangeEquals( RangeLike&& range ) {
            return { CATCH_FORWARD( range ), std::equal_to<>{} };
        }
        /**
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in another range.
         *
         * Uses to provided predicate `predicate` to do the comparisons
         */
        template <typename RangeLike, typename Equality>
        RangeEqualsMatcher<RangeLike, Equality>
-        RangeEquals( RangeLike&& range,
+        RangeEquals( RangeLike&& range, Equality&& predicate ) {
                     Equality&& predicate = std::equal_to<>{} ) {
            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
        }
        /**
         * Creates a matcher that checks if all elements in a range are equal
-         * to all elements in an initializer list.
+         * to all elements in another range, in some permutation
         *
-         * Uses the provided predicate `predicate` to do the comparisons
+         * Uses `std::equal_to` to do the comparison
         * (defaulting to `std::equal_to`)
         */
-        template <typename T,
+        template <typename RangeLike>
-                  typename Equality = decltype( std::equal_to<>{} )>
+        std::enable_if_t<
-        constexpr
+            !Detail::is_matcher<RangeLike>::value,
-        RangeEqualsMatcher<std::initializer_list<T>, Equality>
+            UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
-        RangeEquals( std::initializer_list<T> range,
+        UnorderedRangeEquals( RangeLike&& range ) {
-                     Equality&& predicate = std::equal_to<>{} ) {
+            return { CATCH_FORWARD( range ), std::equal_to<>{} };
            return { range, CATCH_FORWARD( predicate ) };
        }
        /**
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in another range, in some permutation.
         *
-         * Uses the provided predicate `predicate` to do the comparisons
+         * Uses to provided predicate `predicate` to do the comparisons
         * (defaulting to `std::equal_to`)
         */
-        template <typename RangeLike,
+        template <typename RangeLike, typename Equality>
                  typename Equality = decltype( std::equal_to<>{} )>
        constexpr
        UnorderedRangeEqualsMatcher<RangeLike, Equality>
-        UnorderedRangeEquals( RangeLike&& range,
+        UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
                              Equality&& predicate = std::equal_to<>{} ) {
            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
        }
        /**
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in an initializer list, in some permutation.
         *
         * Uses the provided predicate `predicate` to do the comparisons
         * (defaulting to `std::equal_to`)
         */
        template <typename T,
                  typename Equality = decltype( std::equal_to<>{} )>
        constexpr
        UnorderedRangeEqualsMatcher<std::initializer_list<T>, Equality>
        UnorderedRangeEquals( std::initializer_list<T> range,
                              Equality&& predicate = std::equal_to<>{} ) {
            return { range, CATCH_FORWARD( predicate ) };
        }
    } // namespace Matchers
 } // namespace Catch
@@ -13940,7 +13869,7 @@ namespace Catch {
        : CumulativeReporterBase(CATCH_MOVE(config))
        , xml(m_stream) {
            m_preferences.shouldRedirectStdOut = true;
-            m_preferences.shouldReportAllAssertions = false;
+            m_preferences.shouldReportAllAssertions = true;
            m_shouldStoreSuccesfulAssertions = false;
        }
--- a/meson.build
+++ b/meson.build
@@ -8,7 +8,7 @@
 project(
  'catch2',
  'cpp',
-  version: '3.8.1', # CML version placeholder, don't delete
+  version: '3.7.0', # CML version placeholder, don't delete
  license: 'BSL-1.0',
  meson_version: '>=0.54.1',
 )
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -1,2 +1 @@
 option('tests', type: 'boolean', value: true, description: 'Build the unit tests')
 option('install', type: 'boolean', value: true, description: 'Install the library')
--- a/src/catch2/benchmark/detail/catch_stats.cpp
+++ b/src/catch2/benchmark/detail/catch_stats.cpp
@@ -178,7 +178,7 @@ namespace Catch {
                                             double diff = b - m;
                                             return a + diff * diff;
                                         } ) /
-                        static_cast<double>( last - first );
+                        ( last - first );
                    return std::sqrt( variance );
                }
@@ -213,7 +213,7 @@ namespace Catch {
                                              double* first,
                                              double* last ) {
                auto count = last - first;
-                double idx = static_cast<double>((count - 1) * k) / static_cast<double>(q);
+                double idx = (count - 1) * k / static_cast<double>(q);
                int j = static_cast<int>(idx);
                double g = idx - j;
                std::nth_element(first, first + j, last);
@@ -316,10 +316,10 @@ namespace Catch {
                double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) );
                long n = static_cast<long>( resample.size() );
-                double prob_n = static_cast<double>(
+                double prob_n =
                    std::count_if( resample.begin(),
                                   resample.end(),
-                                   [point]( double x ) { return x < point; } )) /
+                                   [point]( double x ) { return x < point; } ) /
                    static_cast<double>( n );
                // degenerate case with uniform samples
                if ( Catch::Detail::directCompare( prob_n, 0. ) ) {
--- a/src/catch2/catch_session.cpp
+++ b/src/catch2/catch_session.cpp
@@ -34,13 +34,7 @@
 namespace Catch {
    namespace {
-        static constexpr int TestFailureExitCode = 42;
+        const int MaxExitCode = 255;
        static constexpr int UnspecifiedErrorExitCode = 1;
        static constexpr int AllTestsSkippedExitCode = 4;
        static constexpr int NoTestsRunExitCode = 2;
        static constexpr int UnmatchedTestSpecExitCode = 3;
        static constexpr int InvalidTestSpecExitCode = 5;
        IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
@@ -204,7 +198,8 @@ namespace Catch {
    }
    int Session::applyCommandLine( int argc, char const * const * argv ) {
-        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
+        if( m_startupExceptions )
            return 1;
        auto result = m_cli.parse( Clara::Args( argc, argv ) );
@@ -220,7 +215,7 @@ namespace Catch {
                << TextFlow::Column( result.errorMessage() ).indent( 2 )
                << "\n\n";
            errStream->stream() << "Run with -? for usage\n\n" << std::flush;
-            return UnspecifiedErrorExitCode;
+            return MaxExitCode;
        }
        if( m_configData.showHelp )
@@ -290,7 +285,8 @@ namespace Catch {
    }
    int Session::runInternal() {
-        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
+        if( m_startupExceptions )
            return 1;
        if (m_configData.showHelp || m_configData.libIdentify) {
            return 0;
@@ -301,7 +297,7 @@ namespace Catch {
                          << ") must be greater than the shard index ("
                          << m_configData.shardIndex << ")\n"
                          << std::flush;
-            return UnspecifiedErrorExitCode;
+            return 1;
        }
        CATCH_TRY {
@@ -324,7 +320,7 @@ namespace Catch {
                for ( auto const& spec : invalidSpecs ) {
                    reporter->reportInvalidTestSpec( spec );
                }
-                return InvalidTestSpecExitCode;
+                return 1;
            }
@@ -338,29 +334,29 @@ namespace Catch {
            if ( tests.hadUnmatchedTestSpecs()
                && m_config->warnAboutUnmatchedTestSpecs() ) {
-                // UnmatchedTestSpecExitCode
+                return 3;
                return UnmatchedTestSpecExitCode;
            }
            if ( totals.testCases.total() == 0
                && !m_config->zeroTestsCountAsSuccess() ) {
-                return NoTestsRunExitCode;
+                return 2;
            }
            if ( totals.testCases.total() > 0 &&
                 totals.testCases.total() == totals.testCases.skipped
                && !m_config->zeroTestsCountAsSuccess() ) {
-                return AllTestsSkippedExitCode;
+                return 4;
            }
-            if ( totals.assertions.failed ) { return TestFailureExitCode; }
+            // Note that on unices only the lower 8 bits are usually used, clamping
-            return 0;
+            // the return value to 255 prevents false negative when some multiple
-
+            // of 256 tests has failed
            return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed));
        }
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
        catch( std::exception& ex ) {
            Catch::cerr() << ex.what() << '\n' << std::flush;
-            return UnspecifiedErrorExitCode;
+            return MaxExitCode;
        }
 #endif
    }
--- a/src/catch2/catch_timer.cpp
+++ b/src/catch2/catch_timer.cpp
@@ -30,7 +30,7 @@ namespace Catch {
        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
    }
    auto Timer::getElapsedSeconds() const -> double {
-        return static_cast<double>(getElapsedMicroseconds())/1000000.0;
+        return getElapsedMicroseconds()/1000000.0;
    }
--- a/src/catch2/catch_tostring.cpp
+++ b/src/catch2/catch_tostring.cpp
@@ -22,10 +22,7 @@ namespace Detail {
        const int hexThreshold = 255;
        struct Endianness {
-            enum Arch : uint8_t {
+            enum Arch { Big, Little };
                Big,
                Little
            };
            static Arch which() {
                int one = 1;
--- a/src/catch2/catch_tostring.hpp
+++ b/src/catch2/catch_tostring.hpp
@@ -634,11 +634,7 @@ struct ratio_string<std::milli> {
 #ifdef _MSC_VER
            std::tm timeInfo = {};
-            const auto err = gmtime_s(&timeInfo, &converted);
+            gmtime_s(&timeInfo, &converted);
            if ( err ) {
                return "gmtime from provided timepoint has failed. This "
                       "happens e.g. with pre-1970 dates using Microsoft libc";
            }
 #else
            std::tm* timeInfo = std::gmtime(&converted);
 #endif
--- a/src/catch2/catch_user_config.hpp.in
+++ b/src/catch2/catch_user_config.hpp.in
@@ -178,15 +178,6 @@
 #endif
 #cmakedefine CATCH_CONFIG_USE_BUILTIN_CONSTANT_P
 #cmakedefine CATCH_CONFIG_NO_USE_BUILTIN_CONSTANT_P
 #if defined( CATCH_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
    defined( CATCH_CONFIG_NO_USE_BUILTIN_CONSTANT_P )
 #    error Cannot force USE_BUILTIN_CONSTANT_P to both ON and OFF
 #endif
 // ------
 // Simple toggle defines
 // their value is never used and they cannot be overridden
--- 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, 8, 1, "", 0 );
+        static Version version( 3, 7, 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 8
+#define CATCH_VERSION_MINOR 7
-#define CATCH_VERSION_PATCH 1
+#define CATCH_VERSION_PATCH 0
 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED
--- a/src/catch2/generators/catch_generators_range.hpp
+++ b/src/catch2/generators/catch_generators_range.hpp
@@ -91,7 +91,7 @@ public:
 template <typename InputIterator,
          typename InputSentinel,
-          typename ResultType = std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type>>
+          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
 GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
    return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(from, to));
 }
--- a/src/catch2/internal/catch_compiler_capabilities.hpp
+++ b/src/catch2/internal/catch_compiler_capabilities.hpp
@@ -62,7 +62,7 @@
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
         _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
-#    define CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
 #endif
@@ -86,45 +86,14 @@
 // clang-cl defines _MSC_VER as well as __clang__, which could cause the
 // start/stop internal suppression macros to be double defined.
 #if defined(__clang__) && !defined(_MSC_VER)
-#    define CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P
+
 #    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
 #    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
 #endif // __clang__ && !_MSC_VER
 #if defined(__clang__)
 #    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
 #    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
 #    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
 #    if (__clang_major__ >= 20)
 #        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
             _Pragma( "clang diagnostic ignored \"-Wvariadic-macro-arguments-omitted\"" )
 #    elif (__clang_major__ == 19)
 #        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
 	         _Pragma( "clang diagnostic ignored \"-Wc++20-extensions\"" )
 #    else
 #        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
             _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
 #    endif
 #    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
 #    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
 #endif // __clang__
 // As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
 // which results in calls to destructors being emitted for each temporary,
 // without a matching initialization. In practice, this can result in something
@@ -141,11 +110,35 @@
 // https://developer.nvidia.com/nvidia_bug/3321845.
 //
 // Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
-#if defined( __ibmxl__ ) || defined( __CUDACC__ ) || defined( __NVCOMPILER )
+#  if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
-#    define CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
-#endif
+#  endif
 #    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
 #    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
 #    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
 #    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
 #    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
 #    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
 #endif // __clang__
 ////////////////////////////////////////////////////////////////////////////////
 // We know some environments not to support full POSIX signals
@@ -369,22 +362,6 @@
 #endif
 // The goal of this macro is to avoid evaluation of the arguments, but
 // still have the compiler warn on problems inside...
 #if defined( CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
    !defined( CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P ) && !defined(CATCH_CONFIG_USE_BUILTIN_CONSTANT_P)
 #define CATCH_CONFIG_USE_BUILTIN_CONSTANT_P
 #endif
 #if defined( CATCH_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
    !defined( CATCH_CONFIG_NO_USE_BUILTIN_CONSTANT_P )
 #    define CATCH_INTERNAL_IGNORE_BUT_WARN( ... )                                              \
        (void)__builtin_constant_p( __VA_ARGS__ ) /* NOLINT(cppcoreguidelines-pro-type-vararg, \
                                                     hicpp-vararg) */
 #else
 #    define CATCH_INTERNAL_IGNORE_BUT_WARN( ... )
 #endif
 // Even if we do not think the compiler has that warning, we still have
 // to provide a macro that can be used by the code.
 #if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
@@ -421,6 +398,13 @@
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
 #endif
 // The goal of this macro is to avoid evaluation of the arguments, but
 // still have the compiler warn on problems inside...
 #if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
 #   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
 #endif
 #if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
 #   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
 #elif defined(__clang__) && (__clang_major__ < 5)
--- a/src/catch2/internal/catch_console_colour.cpp
+++ b/src/catch2/internal/catch_console_colour.cpp
@@ -161,7 +161,7 @@ namespace {
 #endif // Windows/ ANSI/ None
-#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC ) || defined( __GLIBC__ )
+#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )
 #    define CATCH_INTERNAL_HAS_ISATTY
 #    include <unistd.h>
 #endif
--- a/src/catch2/internal/catch_output_redirect.cpp
+++ b/src/catch2/internal/catch_output_redirect.cpp
@@ -17,12 +17,19 @@
 #include <iosfwd>
 #include <sstream>
-#if defined( CATCH_CONFIG_NEW_CAPTURE )
+#if defined(CATCH_CONFIG_USE_ASYNC)
 #include <thread>
 #include <mutex>
 #endif
 #if defined( CATCH_CONFIG_NEW_CAPTURE ) || defined(CATCH_CONFIG_USE_ASYNC)
 #    if defined( _MSC_VER )
 #        include <io.h> //_dup and _dup2
 #        include <fcntl.h> // _O_BINARY
 #        define dup _dup
 #        define dup2 _dup2
 #        define fileno _fileno
 #        define close _close
 #    else
 #        include <unistd.h> // dup and dup2
 #    endif
@@ -48,13 +55,13 @@ namespace Catch {
         * that the underlying stream's rdbuf aren't changed by other
         * users.
         */
-        class RedirectedStreamNew {
+        class RedirectedStream {
            std::ostream& m_originalStream;
            std::ostream& m_redirectionStream;
            std::streambuf* m_prevBuf;
        public:
-            RedirectedStreamNew( std::ostream& originalStream,
+            RedirectedStream( std::ostream& originalStream,
                                 std::ostream& redirectionStream ):
                m_originalStream( originalStream ),
                m_redirectionStream( redirectionStream ),
@@ -72,7 +79,7 @@ namespace Catch {
         */
        class StreamRedirect : public OutputRedirect {
            ReusableStringStream m_redirectedOut, m_redirectedErr;
-            RedirectedStreamNew m_cout, m_cerr, m_clog;
+            RedirectedStream m_cout, m_cerr, m_clog;
        public:
            StreamRedirect():
@@ -244,6 +251,182 @@ namespace Catch {
 #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 ) {
@@ -255,6 +438,10 @@ namespace Catch {
 #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;
@@ -267,7 +454,8 @@ namespace Catch {
 #if defined( CATCH_CONFIG_NEW_CAPTURE )
            return Detail::make_unique<FileRedirect>();
 #else
-            return Detail::make_unique<StreamRedirect>();
+            //return Detail::make_unique<StreamRedirect>();
            return Detail::make_unique<PipeRedirect>();
 #endif
        } else {
            return Detail::make_unique<NoopRedirect>();
--- a/src/catch2/internal/catch_output_redirect.hpp
+++ b/src/catch2/internal/catch_output_redirect.hpp
@@ -25,8 +25,10 @@ namespace Catch {
            None,
            //! Redirect std::cout/std::cerr/std::clog streams internally
            Streams,
-            //! Redirect the stdout/stderr file descriptors into files
+            //! Redirect the stdout/stderr file descriptors into temp files
            FileDescriptors,
            //! Redirect the stdout/stderr file descriptors into anonymous pipes
            Pipes,
        };
        virtual ~OutputRedirect(); // = default;
--- a/src/catch2/internal/catch_random_number_generator.cpp
+++ b/src/catch2/internal/catch_random_number_generator.cpp
@@ -52,7 +52,7 @@ namespace {
    SimplePcg32::result_type SimplePcg32::operator()() {
        // prepare the output value
        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
-        const auto output = rotate_right(xorshifted, static_cast<uint32_t>(m_state >> 59u));
+        const auto output = rotate_right(xorshifted, m_state >> 59u);
        // advance state
        m_state = m_state * 6364136223846793005ULL + s_inc;
--- a/src/catch2/internal/catch_xmlwriter.hpp
+++ b/src/catch2/internal/catch_xmlwriter.hpp
@@ -13,23 +13,22 @@
 #include <iosfwd>
 #include <vector>
 #include <cstdint>
 namespace Catch {
-    enum class XmlFormatting : std::uint8_t {
+    enum class XmlFormatting : uint8_t {
        None = 0x00,
        Indent = 0x01,
        Newline = 0x02,
    };
    constexpr XmlFormatting operator|( XmlFormatting lhs, XmlFormatting rhs ) {
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) |
+        return static_cast<XmlFormatting>( static_cast<uint8_t>( lhs ) |
-                                           static_cast<std::uint8_t>( rhs ) );
+                                           static_cast<uint8_t>( rhs ) );
    }
    constexpr XmlFormatting operator&( XmlFormatting lhs, XmlFormatting rhs ) {
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) &
+        return static_cast<XmlFormatting>( static_cast<uint8_t>( lhs ) &
-                                           static_cast<std::uint8_t>( rhs ) );
+                                           static_cast<uint8_t>( rhs ) );
    }
--- a/src/catch2/matchers/catch_matchers_range_equals.hpp
+++ b/src/catch2/matchers/catch_matchers_range_equals.hpp
@@ -96,65 +96,56 @@ namespace Catch {
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in another range.
         *
-         * Uses the provided predicate `predicate` to do the comparisons
+         * Uses `std::equal_to` to do the comparison
         * (defaulting to `std::equal_to`)
         */
-        template <typename RangeLike,
+        template <typename RangeLike>
-                  typename Equality = decltype( std::equal_to<>{} )>
+        constexpr
        std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
                         RangeEqualsMatcher<RangeLike, std::equal_to<>>>
        RangeEquals( RangeLike&& range ) {
            return { CATCH_FORWARD( range ), std::equal_to<>{} };
        }
        /**
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in another range.
         *
         * Uses to provided predicate `predicate` to do the comparisons
         */
        template <typename RangeLike, typename Equality>
        constexpr
        RangeEqualsMatcher<RangeLike, Equality>
-        RangeEquals( RangeLike&& range,
+        RangeEquals( RangeLike&& range, Equality&& predicate ) {
                     Equality&& predicate = std::equal_to<>{} ) {
            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
        }
        /**
         * Creates a matcher that checks if all elements in a range are equal
-         * to all elements in an initializer list.
+         * to all elements in another range, in some permutation
         *
-         * Uses the provided predicate `predicate` to do the comparisons
+         * Uses `std::equal_to` to do the comparison
         * (defaulting to `std::equal_to`)
         */
-        template <typename T,
+        template <typename RangeLike>
                  typename Equality = decltype( std::equal_to<>{} )>
        constexpr
-        RangeEqualsMatcher<std::initializer_list<T>, Equality>
+        std::enable_if_t<
-        RangeEquals( std::initializer_list<T> range,
+            !Detail::is_matcher<RangeLike>::value,
-                     Equality&& predicate = std::equal_to<>{} ) {
+            UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
-            return { range, CATCH_FORWARD( predicate ) };
+        UnorderedRangeEquals( RangeLike&& range ) {
            return { CATCH_FORWARD( range ), std::equal_to<>{} };
        }
        /**
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in another range, in some permutation.
         *
-         * Uses the provided predicate `predicate` to do the comparisons
+         * Uses to provided predicate `predicate` to do the comparisons
         * (defaulting to `std::equal_to`)
         */
-        template <typename RangeLike,
+        template <typename RangeLike, typename Equality>
                  typename Equality = decltype( std::equal_to<>{} )>
        constexpr
        UnorderedRangeEqualsMatcher<RangeLike, Equality>
-        UnorderedRangeEquals( RangeLike&& range,
+        UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
                              Equality&& predicate = std::equal_to<>{} ) {
            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
        }
        /**
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in an initializer list, in some permutation.
         *
         * Uses the provided predicate `predicate` to do the comparisons
         * (defaulting to `std::equal_to`)
         */
        template <typename T,
                  typename Equality = decltype( std::equal_to<>{} )>
        constexpr
        UnorderedRangeEqualsMatcher<std::initializer_list<T>, Equality>
        UnorderedRangeEquals( std::initializer_list<T> range,
                              Equality&& predicate = std::equal_to<>{} ) {
            return { range, CATCH_FORWARD( predicate ) };
        }
    } // namespace Matchers
 } // namespace Catch
--- a/src/catch2/meson.build
+++ b/src/catch2/meson.build
@@ -16,7 +16,6 @@ configure_file(
  format: 'cmake@',
  install_dir: get_option('includedir') / 'catch2',
  configuration: conf_data,
  install: get_option('install')
 )
 fs = import('fs')
@@ -340,9 +339,7 @@ foreach file : headers
    endif
  endforeach
-  if get_option('install')
+  install_headers(file, subdir: join_paths(include_subdir, folder))
    install_headers(file, subdir: join_paths(include_subdir, folder))
  endif
 endforeach
 catch2_dependencies = []
@@ -359,7 +356,7 @@ catch2 = static_library(
  sources,
  dependencies: catch2_dependencies,
  include_directories: '..',
-  install: get_option('install'),
+  install: true,
 )
 catch2_dep = declare_dependency(
@@ -367,21 +364,19 @@ catch2_dep = declare_dependency(
  include_directories: '..',
 )
-if get_option('install')
+pkg.generate(
-  pkg.generate(
+  catch2,
-    catch2,
+  filebase: 'catch2',
-    filebase: 'catch2',
+  description: 'A modern, C++-native, test framework for C++14 and above',
-    description: 'A modern, C++-native, test framework for C++14 and above',
+  url: 'https://github.com/catchorg/Catch2',
-    url: 'https://github.com/catchorg/Catch2',
+)
  )
 endif
 catch2_with_main = static_library(
  'Catch2Main',
  'internal/catch_main.cpp',
  link_with: catch2,
  include_directories: '..',
-  install: get_option('install'),
+  install: true,
 )
 catch2_with_main_dep = declare_dependency(
@@ -389,11 +384,9 @@ catch2_with_main_dep = declare_dependency(
  include_directories: '..',
 )
-if get_option('install')
+pkg.generate(
-  pkg.generate(
+  catch2_with_main,
-    catch2_with_main,
+  filebase: 'catch2-with-main',
-    filebase: 'catch2-with-main',
+  description: 'A modern, C++-native, test framework for C++14 and above (links in default main)',
-    description: 'A modern, C++-native, test framework for C++14 and above (links in default main)',
+  requires: 'catch2 = ' + meson.project_version(),
-    requires: 'catch2 = ' + meson.project_version(),
+)
  )
 endif
--- a/src/catch2/reporters/catch_reporter_console.cpp
+++ b/src/catch2/reporters/catch_reporter_console.cpp
@@ -214,7 +214,7 @@ struct RowBreak {};
 struct OutputFlush {};
 class Duration {
-    enum class Unit : uint8_t {
+    enum class Unit {
        Auto,
        Nanoseconds,
        Microseconds,
@@ -286,10 +286,7 @@ public:
 };
 } // end anon namespace
-enum class Justification : uint8_t {
+enum class Justification { Left, Right };
    Left,
    Right
 };
 struct ColumnInfo {
    std::string name;
--- a/tests/ExtraTests/CMakeLists.txt
+++ b/tests/ExtraTests/CMakeLists.txt
@@ -2,12 +2,13 @@
 # Build extra tests.
 #
-cmake_minimum_required( VERSION 3.16 )
+cmake_minimum_required( VERSION 3.10 )
 project( Catch2ExtraTests LANGUAGES CXX )
 message( STATUS "Extra tests included" )
 add_test(
  NAME TestShardingIntegration
  COMMAND ${PYTHON_EXECUTABLE} ${CATCH_DIR}/tests/TestScripts/testSharding.py $<TARGET_FILE:SelfTest>
--- a/tests/SelfTest/Baselines/automake.sw.approved.txt
+++ b/tests/SelfTest/Baselines/automake.sw.approved.txt
@@ -136,8 +136,8 @@ Nor would this
 :test-result: SKIP Empty generators can SKIP in constructor
 :test-result: PASS Empty stream name opens cout stream
 :test-result: FAIL EndsWith string matcher
-:test-result: PASS Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+:test-result: PASS Enums can quickly have stringification enabled using REGISTER_ENUM
-:test-result: PASS Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM
+:test-result: PASS Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM
 :test-result: PASS Epsilon only applies to Approx's value
 :test-result: XFAIL Equality checks that should fail
 :test-result: PASS Equality checks that should succeed
--- a/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
@@ -134,8 +134,8 @@
 :test-result: SKIP Empty generators can SKIP in constructor
 :test-result: PASS Empty stream name opens cout stream
 :test-result: FAIL EndsWith string matcher
-:test-result: PASS Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+:test-result: PASS Enums can quickly have stringification enabled using REGISTER_ENUM
-:test-result: PASS Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM
+:test-result: PASS Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM
 :test-result: PASS Epsilon only applies to Approx's value
 :test-result: XFAIL Equality checks that should fail
 :test-result: PASS Equality checks that should succeed
--- a/tests/SelfTest/Baselines/compact.sw.approved.txt
+++ b/tests/SelfTest/Baselines/compact.sw.approved.txt
@@ -2284,8 +2284,6 @@ MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( vector_a_
 MatchersRanges.tests.cpp:<line number>: passed: vector_a, !RangeEquals( vector_b, close_enough ) for: { 1, 2, 3 } not elements are { 3, 3, 4 }
 MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, RangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } elements are { 1, 2, 3, 4, 5 }
 MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } ) for: { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
 MatchersRanges.tests.cpp:<line number>: passed: array_a, RangeEquals( { 1, 2, 3 } ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
 MatchersRanges.tests.cpp:<line number>: passed: array_a, RangeEquals( { 2, 4, 6 }, []( int l, int r ) { return l * 2 == r; } ) for: { 1, 2, 3 } elements are { 2, 4, 6 }
 MatchersRanges.tests.cpp:<line number>: passed: mocked1, !RangeEquals( arr ) for: { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
 MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[0] for: true
 MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[1] for: true
@@ -2306,8 +2304,6 @@ MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals(
 MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
 MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
 MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, UnorderedRangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
 MatchersRanges.tests.cpp:<line number>: passed: array_a, UnorderedRangeEquals( { 10, 20, 1 } ) for: { 1, 10, 20 } unordered elements are { 10, 20, 1 }
 MatchersRanges.tests.cpp:<line number>: passed: array_a, UnorderedRangeEquals( { 11, 21, 2 }, []( int l, int r ) { return std::abs( l - r ) <= 1; } ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(0) for: {  } has size == 0
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, !SizeIs(2) for: {  } not has size == 2
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(Lt(2)) for: {  } size matches is less than 2
@@ -2855,6 +2851,6 @@ InternalBenchmark.tests.cpp:<line number>: passed: q3 == 23. for: 23.0 == 23.0
 Misc.tests.cpp:<line number>: passed:
 Misc.tests.cpp:<line number>: passed:
 test cases:  419 |  313 passed |  86 failed | 6 skipped | 14 failed as expected
-assertions: 2269 | 2087 passed | 147 failed | 35 failed as expected
+assertions: 2265 | 2083 passed | 147 failed | 35 failed as expected
--- a/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
@@ -2277,8 +2277,6 @@ MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( vector_a_
 MatchersRanges.tests.cpp:<line number>: passed: vector_a, !RangeEquals( vector_b, close_enough ) for: { 1, 2, 3 } not elements are { 3, 3, 4 }
 MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, RangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } elements are { 1, 2, 3, 4, 5 }
 MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } ) for: { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
 MatchersRanges.tests.cpp:<line number>: passed: array_a, RangeEquals( { 1, 2, 3 } ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
 MatchersRanges.tests.cpp:<line number>: passed: array_a, RangeEquals( { 2, 4, 6 }, []( int l, int r ) { return l * 2 == r; } ) for: { 1, 2, 3 } elements are { 2, 4, 6 }
 MatchersRanges.tests.cpp:<line number>: passed: mocked1, !RangeEquals( arr ) for: { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
 MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[0] for: true
 MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[1] for: true
@@ -2299,8 +2297,6 @@ MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals(
 MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
 MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
 MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, UnorderedRangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
 MatchersRanges.tests.cpp:<line number>: passed: array_a, UnorderedRangeEquals( { 10, 20, 1 } ) for: { 1, 10, 20 } unordered elements are { 10, 20, 1 }
 MatchersRanges.tests.cpp:<line number>: passed: array_a, UnorderedRangeEquals( { 11, 21, 2 }, []( int l, int r ) { return std::abs( l - r ) <= 1; } ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(0) for: {  } has size == 0
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, !SizeIs(2) for: {  } not has size == 2
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(Lt(2)) for: {  } size matches is less than 2
@@ -2844,6 +2840,6 @@ InternalBenchmark.tests.cpp:<line number>: passed: q3 == 23. for: 23.0 == 23.0
 Misc.tests.cpp:<line number>: passed:
 Misc.tests.cpp:<line number>: passed:
 test cases:  419 |  313 passed |  86 failed | 6 skipped | 14 failed as expected
-assertions: 2269 | 2087 passed | 147 failed | 35 failed as expected
+assertions: 2265 | 2083 passed | 147 failed | 35 failed as expected
--- a/tests/SelfTest/Baselines/console.std.approved.txt
+++ b/tests/SelfTest/Baselines/console.std.approved.txt
@@ -1611,5 +1611,5 @@ due to unexpected exception with message:
 ===============================================================================
 test cases:  419 |  327 passed |  71 failed | 7 skipped | 14 failed as expected
-assertions: 2252 | 2087 passed | 130 failed | 35 failed as expected
+assertions: 2248 | 2083 passed | 130 failed | 35 failed as expected
--- a/tests/SelfTest/Baselines/console.sw.approved.txt
+++ b/tests/SelfTest/Baselines/console.sw.approved.txt
@@ -4083,7 +4083,7 @@ with expansion:
  insensitive)
 -------------------------------------------------------------------------------
-Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+Enums can quickly have stringification enabled using REGISTER_ENUM
 -------------------------------------------------------------------------------
 EnumToString.tests.cpp:<line number>
 ...............................................................................
@@ -4117,7 +4117,7 @@ with expansion:
 -------------------------------------------------------------------------------
 Enums in namespaces can quickly have stringification enabled using
-CATCH_REGISTER_ENUM
+REGISTER_ENUM
 -------------------------------------------------------------------------------
 EnumToString.tests.cpp:<line number>
 ...............................................................................
@@ -14981,23 +14981,6 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
 with expansion:
  { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
 -------------------------------------------------------------------------------
 Usage of RangeEquals range matcher
  Compare against std::initializer_list
 -------------------------------------------------------------------------------
 MatchersRanges.tests.cpp:<line number>
 ...............................................................................
 MatchersRanges.tests.cpp:<line number>: PASSED:
  REQUIRE_THAT( array_a, RangeEquals( { 1, 2, 3 } ) )
 with expansion:
  { 1, 2, 3 } elements are { 1, 2, 3 }
 MatchersRanges.tests.cpp:<line number>: PASSED:
  REQUIRE_THAT( array_a, RangeEquals( { 2, 4, 6 }, []( int l, int r ) { return l * 2 == r; } ) )
 with expansion:
  { 1, 2, 3 } elements are { 2, 4, 6 }
 -------------------------------------------------------------------------------
 Usage of RangeEquals range matcher
  Check short-circuiting behaviour
@@ -15185,23 +15168,6 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
 with expansion:
  { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
 -------------------------------------------------------------------------------
 Usage of UnorderedRangeEquals range matcher
  Compare against std::initializer_list
 -------------------------------------------------------------------------------
 MatchersRanges.tests.cpp:<line number>
 ...............................................................................
 MatchersRanges.tests.cpp:<line number>: PASSED:
  REQUIRE_THAT( array_a, UnorderedRangeEquals( { 10, 20, 1 } ) )
 with expansion:
  { 1, 10, 20 } unordered elements are { 10, 20, 1 }
 MatchersRanges.tests.cpp:<line number>: PASSED:
  REQUIRE_THAT( array_a, UnorderedRangeEquals( { 11, 21, 2 }, []( int l, int r ) { return std::abs( l - r ) <= 1; } ) )
 with expansion:
  { 1, 10, 20 } unordered elements are { 11, 21, 2 }
 -------------------------------------------------------------------------------
 Usage of the SizeIs range matcher
  Some with stdlib containers
@@ -19013,5 +18979,5 @@ Misc.tests.cpp:<line number>: PASSED:
 ===============================================================================
 test cases:  419 |  313 passed |  86 failed | 6 skipped | 14 failed as expected
-assertions: 2269 | 2087 passed | 147 failed | 35 failed as expected
+assertions: 2265 | 2083 passed | 147 failed | 35 failed as expected
--- a/tests/SelfTest/Baselines/console.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/console.sw.multi.approved.txt
@@ -4081,7 +4081,7 @@ with expansion:
  insensitive)
 -------------------------------------------------------------------------------
-Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+Enums can quickly have stringification enabled using REGISTER_ENUM
 -------------------------------------------------------------------------------
 EnumToString.tests.cpp:<line number>
 ...............................................................................
@@ -4115,7 +4115,7 @@ with expansion:
 -------------------------------------------------------------------------------
 Enums in namespaces can quickly have stringification enabled using
-CATCH_REGISTER_ENUM
+REGISTER_ENUM
 -------------------------------------------------------------------------------
 EnumToString.tests.cpp:<line number>
 ...............................................................................
@@ -14974,23 +14974,6 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
 with expansion:
  { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
 -------------------------------------------------------------------------------
 Usage of RangeEquals range matcher
  Compare against std::initializer_list
 -------------------------------------------------------------------------------
 MatchersRanges.tests.cpp:<line number>
 ...............................................................................
 MatchersRanges.tests.cpp:<line number>: PASSED:
  REQUIRE_THAT( array_a, RangeEquals( { 1, 2, 3 } ) )
 with expansion:
  { 1, 2, 3 } elements are { 1, 2, 3 }
 MatchersRanges.tests.cpp:<line number>: PASSED:
  REQUIRE_THAT( array_a, RangeEquals( { 2, 4, 6 }, []( int l, int r ) { return l * 2 == r; } ) )
 with expansion:
  { 1, 2, 3 } elements are { 2, 4, 6 }
 -------------------------------------------------------------------------------
 Usage of RangeEquals range matcher
  Check short-circuiting behaviour
@@ -15178,23 +15161,6 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
 with expansion:
  { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
 -------------------------------------------------------------------------------
 Usage of UnorderedRangeEquals range matcher
  Compare against std::initializer_list
 -------------------------------------------------------------------------------
 MatchersRanges.tests.cpp:<line number>
 ...............................................................................
 MatchersRanges.tests.cpp:<line number>: PASSED:
  REQUIRE_THAT( array_a, UnorderedRangeEquals( { 10, 20, 1 } ) )
 with expansion:
  { 1, 10, 20 } unordered elements are { 10, 20, 1 }
 MatchersRanges.tests.cpp:<line number>: PASSED:
  REQUIRE_THAT( array_a, UnorderedRangeEquals( { 11, 21, 2 }, []( int l, int r ) { return std::abs( l - r ) <= 1; } ) )
 with expansion:
  { 1, 10, 20 } unordered elements are { 11, 21, 2 }
 -------------------------------------------------------------------------------
 Usage of the SizeIs range matcher
  Some with stdlib containers
@@ -19002,5 +18968,5 @@ Misc.tests.cpp:<line number>: PASSED:
 ===============================================================================
 test cases:  419 |  313 passed |  86 failed | 6 skipped | 14 failed as expected
-assertions: 2269 | 2087 passed | 147 failed | 35 failed as expected
+assertions: 2265 | 2083 passed | 147 failed | 35 failed as expected
--- a/tests/SelfTest/Baselines/junit.sw.approved.txt
+++ b/tests/SelfTest/Baselines/junit.sw.approved.txt
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuitesloose text artifact
 >
-  <testsuite name="<exe-name>" errors="17" failures="130" skipped="12" tests="2281" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+  <testsuite name="<exe-name>" errors="17" failures="130" skipped="12" tests="2277" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
    <properties>
      <property name="random-seed" value="1"/>
      <property name="filters" value="&quot;*&quot; ~[!nonportable] ~[!benchmark] ~[approvals]"/>
@@ -521,8 +521,8 @@ with expansion:
 at Matchers.tests.cpp:<line number>
      </failure>
    </testcase>
-    <testcase classname="<exe-name>.global" name="Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Enums can quickly have stringification enabled using REGISTER_ENUM" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Epsilon only applies to Approx's value" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Equality checks that should fail" time="{duration}" status="run">
      <skipped message="TEST_CASE tagged with !mayfail"/>
@@ -1652,7 +1652,6 @@ at Exception.tests.cpp:<line number>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Compare against std::initializer_list" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" time="{duration}" status="run"/>
@@ -1668,7 +1667,6 @@ at Exception.tests.cpp:<line number>
    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Compare against std::initializer_list" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Some with stdlib containers" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type requires ADL found size free function" time="{duration}" status="run"/>
--- a/tests/SelfTest/Baselines/junit.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/junit.sw.multi.approved.txt
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuites>
-  <testsuite name="<exe-name>" errors="17" failures="130" skipped="12" tests="2281" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+  <testsuite name="<exe-name>" errors="17" failures="130" skipped="12" tests="2277" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
    <properties>
      <property name="random-seed" value="1"/>
      <property name="filters" value="&quot;*&quot; ~[!nonportable] ~[!benchmark] ~[approvals]"/>
@@ -520,8 +520,8 @@ with expansion:
 at Matchers.tests.cpp:<line number>
      </failure>
    </testcase>
-    <testcase classname="<exe-name>.global" name="Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Enums can quickly have stringification enabled using REGISTER_ENUM" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Epsilon only applies to Approx's value" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Equality checks that should fail" time="{duration}" status="run">
      <skipped message="TEST_CASE tagged with !mayfail"/>
@@ -1651,7 +1651,6 @@ at Exception.tests.cpp:<line number>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Compare against std::initializer_list" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" time="{duration}" status="run"/>
@@ -1667,7 +1666,6 @@ at Exception.tests.cpp:<line number>
    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Compare against std::initializer_list" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Some with stdlib containers" time="{duration}" status="run"/>
    <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type requires ADL found size free function" time="{duration}" status="run"/>
--- a/tests/SelfTest/Baselines/sonarqube.sw.approved.txt
+++ b/tests/SelfTest/Baselines/sonarqube.sw.approved.txt
@@ -998,8 +998,8 @@ at Decomposition.tests.cpp:<line number>
    </testCase>
  </file>
  <file path="tests/<exe-name>/UsageTests/EnumToString.tests.cpp">
-    <testCase name="Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM" duration="{duration}"/>
+    <testCase name="Enums can quickly have stringification enabled using REGISTER_ENUM" duration="{duration}"/>
-    <testCase name="Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM" duration="{duration}"/>
+    <testCase name="Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" duration="{duration}"/>
    <testCase name="toString(enum class w/operator&lt;&lt;)" duration="{duration}"/>
    <testCase name="toString(enum class)" duration="{duration}"/>
    <testCase name="toString(enum w/operator&lt;&lt;)" duration="{duration}"/>
@@ -1607,7 +1607,6 @@ at Matchers.tests.cpp:<line number>
    <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Compare against std::initializer_list" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" duration="{duration}"/>
@@ -1623,7 +1622,6 @@ at Matchers.tests.cpp:<line number>
    <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
    <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
    <testCase name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
    <testCase name="Usage of UnorderedRangeEquals range matcher/Compare against std::initializer_list" duration="{duration}"/>
    <testCase name="Usage of the SizeIs range matcher" duration="{duration}"/>
    <testCase name="Usage of the SizeIs range matcher/Some with stdlib containers" duration="{duration}"/>
    <testCase name="Usage of the SizeIs range matcher/Type requires ADL found size free function" duration="{duration}"/>
--- a/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt
@@ -997,8 +997,8 @@ at Decomposition.tests.cpp:<line number>
    </testCase>
  </file>
  <file path="tests/<exe-name>/UsageTests/EnumToString.tests.cpp">
-    <testCase name="Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM" duration="{duration}"/>
+    <testCase name="Enums can quickly have stringification enabled using REGISTER_ENUM" duration="{duration}"/>
-    <testCase name="Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM" duration="{duration}"/>
+    <testCase name="Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" duration="{duration}"/>
    <testCase name="toString(enum class w/operator&lt;&lt;)" duration="{duration}"/>
    <testCase name="toString(enum class)" duration="{duration}"/>
    <testCase name="toString(enum w/operator&lt;&lt;)" duration="{duration}"/>
@@ -1606,7 +1606,6 @@ at Matchers.tests.cpp:<line number>
    <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Compare against std::initializer_list" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" duration="{duration}"/>
    <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" duration="{duration}"/>
@@ -1622,7 +1621,6 @@ at Matchers.tests.cpp:<line number>
    <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
    <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
    <testCase name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
    <testCase name="Usage of UnorderedRangeEquals range matcher/Compare against std::initializer_list" duration="{duration}"/>
    <testCase name="Usage of the SizeIs range matcher" duration="{duration}"/>
    <testCase name="Usage of the SizeIs range matcher/Some with stdlib containers" duration="{duration}"/>
    <testCase name="Usage of the SizeIs range matcher/Type requires ADL found size free function" duration="{duration}"/>
--- a/tests/SelfTest/Baselines/tap.sw.approved.txt
+++ b/tests/SelfTest/Baselines/tap.sw.approved.txt
@@ -1004,19 +1004,19 @@ ok {test-number} - Catch::makeStream( "" )->isConsole() for: true
 not ok {test-number} - testStringForMatching(), EndsWith( "Substring" ) for: "this string contains 'abc' as a substring" ends with: "Substring"
 # EndsWith string matcher
 not ok {test-number} - testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" ends with: "this" (case insensitive)
-# Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( EnumClass3::Value1 ) == "Value1" for: "Value1" == "Value1"
-# Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( EnumClass3::Value2 ) == "Value2" for: "Value2" == "Value2"
-# Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( EnumClass3::Value3 ) == "Value3" for: "Value3" == "Value3"
-# Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( EnumClass3::Value4 ) == "{** unexpected enum value **}" for: "{** unexpected enum value **}" == "{** unexpected enum value **}"
-# Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( ec3 ) == "Value2" for: "Value2" == "Value2"
-# Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( Bikeshed::Colours::Red ) == "Red" for: "Red" == "Red"
-# Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( Bikeshed::Colours::Blue ) == "Blue" for: "Blue" == "Blue"
 # Epsilon only applies to Approx's value
 ok {test-number} - 101.01 != Approx(100).epsilon(0.01) for: 101.01000000000000512 != Approx( 100.0 )
@@ -3580,10 +3580,6 @@ ok {test-number} - needs_adl1, RangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 }
 # Usage of RangeEquals range matcher
 ok {test-number} - needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } ) for: { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
 # Usage of RangeEquals range matcher
 ok {test-number} - array_a, RangeEquals( { 1, 2, 3 } ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
 # Usage of RangeEquals range matcher
 ok {test-number} - array_a, RangeEquals( { 2, 4, 6 }, []( int l, int r ) { return l * 2 == r; } ) for: { 1, 2, 3 } elements are { 2, 4, 6 }
 # Usage of RangeEquals range matcher
 ok {test-number} - mocked1, !RangeEquals( arr ) for: { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
 # Usage of RangeEquals range matcher
 ok {test-number} - mocked1.m_derefed[0] for: true
@@ -3623,10 +3619,6 @@ ok {test-number} - vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough
 ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
 # Usage of UnorderedRangeEquals range matcher
 ok {test-number} - needs_adl1, UnorderedRangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
 # Usage of UnorderedRangeEquals range matcher
 ok {test-number} - array_a, UnorderedRangeEquals( { 10, 20, 1 } ) for: { 1, 10, 20 } unordered elements are { 10, 20, 1 }
 # Usage of UnorderedRangeEquals range matcher
 ok {test-number} - array_a, UnorderedRangeEquals( { 11, 21, 2 }, []( int l, int r ) { return std::abs( l - r ) <= 1; } ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
 # Usage of the SizeIs range matcher
 ok {test-number} - empty_vec, SizeIs(0) for: {  } has size == 0
 # Usage of the SizeIs range matcher
@@ -4567,5 +4559,5 @@ ok {test-number} - q3 == 23. for: 23.0 == 23.0
 ok {test-number} -
 # xmlentitycheck
 ok {test-number} -
-1..2281
+1..2277
--- a/tests/SelfTest/Baselines/tap.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/tap.sw.multi.approved.txt
@@ -1002,19 +1002,19 @@ ok {test-number} - Catch::makeStream( "" )->isConsole() for: true
 not ok {test-number} - testStringForMatching(), EndsWith( "Substring" ) for: "this string contains 'abc' as a substring" ends with: "Substring"
 # EndsWith string matcher
 not ok {test-number} - testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" ends with: "this" (case insensitive)
-# Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( EnumClass3::Value1 ) == "Value1" for: "Value1" == "Value1"
-# Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( EnumClass3::Value2 ) == "Value2" for: "Value2" == "Value2"
-# Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( EnumClass3::Value3 ) == "Value3" for: "Value3" == "Value3"
-# Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( EnumClass3::Value4 ) == "{** unexpected enum value **}" for: "{** unexpected enum value **}" == "{** unexpected enum value **}"
-# Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( ec3 ) == "Value2" for: "Value2" == "Value2"
-# Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( Bikeshed::Colours::Red ) == "Red" for: "Red" == "Red"
-# Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM
+# Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM
 ok {test-number} - stringify( Bikeshed::Colours::Blue ) == "Blue" for: "Blue" == "Blue"
 # Epsilon only applies to Approx's value
 ok {test-number} - 101.01 != Approx(100).epsilon(0.01) for: 101.01000000000000512 != Approx( 100.0 )
@@ -3573,10 +3573,6 @@ ok {test-number} - needs_adl1, RangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 }
 # Usage of RangeEquals range matcher
 ok {test-number} - needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } ) for: { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
 # Usage of RangeEquals range matcher
 ok {test-number} - array_a, RangeEquals( { 1, 2, 3 } ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
 # Usage of RangeEquals range matcher
 ok {test-number} - array_a, RangeEquals( { 2, 4, 6 }, []( int l, int r ) { return l * 2 == r; } ) for: { 1, 2, 3 } elements are { 2, 4, 6 }
 # Usage of RangeEquals range matcher
 ok {test-number} - mocked1, !RangeEquals( arr ) for: { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
 # Usage of RangeEquals range matcher
 ok {test-number} - mocked1.m_derefed[0] for: true
@@ -3616,10 +3612,6 @@ ok {test-number} - vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough
 ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
 # Usage of UnorderedRangeEquals range matcher
 ok {test-number} - needs_adl1, UnorderedRangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
 # Usage of UnorderedRangeEquals range matcher
 ok {test-number} - array_a, UnorderedRangeEquals( { 10, 20, 1 } ) for: { 1, 10, 20 } unordered elements are { 10, 20, 1 }
 # Usage of UnorderedRangeEquals range matcher
 ok {test-number} - array_a, UnorderedRangeEquals( { 11, 21, 2 }, []( int l, int r ) { return std::abs( l - r ) <= 1; } ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
 # Usage of the SizeIs range matcher
 ok {test-number} - empty_vec, SizeIs(0) for: {  } has size == 0
 # Usage of the SizeIs range matcher
@@ -4556,5 +4548,5 @@ ok {test-number} - q3 == 23. for: 23.0 == 23.0
 ok {test-number} -
 # xmlentitycheck
 ok {test-number} -
-1..2281
+1..2277
--- a/tests/SelfTest/Baselines/teamcity.sw.approved.txt
+++ b/tests/SelfTest/Baselines/teamcity.sw.approved.txt
@@ -315,10 +315,10 @@
 ##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )|nwith expansion:|n  "this string contains |'abc|' as a substring" ends with: "Substring"|n']
 ##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) )|nwith expansion:|n  "this string contains |'abc|' as a substring" ends with: "this" (case insensitive)|n']
 ##teamcity[testFinished name='EndsWith string matcher' duration="{duration}"]
-##teamcity[testStarted name='Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM']
+##teamcity[testStarted name='Enums can quickly have stringification enabled using REGISTER_ENUM']
-##teamcity[testFinished name='Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM' duration="{duration}"]
+##teamcity[testFinished name='Enums can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
-##teamcity[testStarted name='Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM']
+##teamcity[testStarted name='Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM']
-##teamcity[testFinished name='Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM' duration="{duration}"]
+##teamcity[testFinished name='Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
 ##teamcity[testStarted name='Epsilon only applies to Approx|'s value']
 ##teamcity[testFinished name='Epsilon only applies to Approx|'s value' duration="{duration}"]
 ##teamcity[testStarted name='Equality checks that should fail']
--- a/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt
@@ -315,10 +315,10 @@
 ##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )|nwith expansion:|n  "this string contains |'abc|' as a substring" ends with: "Substring"|n']
 ##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) )|nwith expansion:|n  "this string contains |'abc|' as a substring" ends with: "this" (case insensitive)|n']
 ##teamcity[testFinished name='EndsWith string matcher' duration="{duration}"]
-##teamcity[testStarted name='Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM']
+##teamcity[testStarted name='Enums can quickly have stringification enabled using REGISTER_ENUM']
-##teamcity[testFinished name='Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM' duration="{duration}"]
+##teamcity[testFinished name='Enums can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
-##teamcity[testStarted name='Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM']
+##teamcity[testStarted name='Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM']
-##teamcity[testFinished name='Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM' duration="{duration}"]
+##teamcity[testFinished name='Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
 ##teamcity[testStarted name='Epsilon only applies to Approx|'s value']
 ##teamcity[testFinished name='Epsilon only applies to Approx|'s value' duration="{duration}"]
 ##teamcity[testStarted name='Equality checks that should fail']
--- a/tests/SelfTest/Baselines/xml.sw.approved.txt
+++ b/tests/SelfTest/Baselines/xml.sw.approved.txt
@@ -4493,7 +4493,7 @@ C
    </Expression>
    <OverallResult success="false" skips="0"/>
  </TestCase>
-  <TestCase name="Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
+  <TestCase name="Enums can quickly have stringification enabled using REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
    <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
      <Original>
        stringify( EnumClass3::Value1 ) == "Value1"
@@ -4538,7 +4538,7 @@ C
    </Expression>
    <OverallResult success="true" skips="0"/>
  </TestCase>
-  <TestCase name="Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
+  <TestCase name="Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
    <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
      <Original>
        stringify( Bikeshed::Colours::Red ) == "Red"
@@ -17383,25 +17383,6 @@ There is no extra whitespace here
      </Expression>
      <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
    </Section>
    <Section name="Compare against std::initializer_list" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
        <Original>
          array_a, RangeEquals( { 1, 2, 3 } )
        </Original>
        <Expanded>
          { 1, 2, 3 } elements are { 1, 2, 3 }
        </Expanded>
      </Expression>
      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
        <Original>
          array_a, RangeEquals( { 2, 4, 6 }, []( int l, int r ) { return l * 2 == r; } )
        </Original>
        <Expanded>
          { 1, 2, 3 } elements are { 2, 4, 6 }
        </Expanded>
      </Expression>
      <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
    </Section>
    <Section name="Check short-circuiting behaviour" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
      <Section name="Check short-circuits on failure" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17628,25 +17609,6 @@ There is no extra whitespace here
      </Expression>
      <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
    </Section>
    <Section name="Compare against std::initializer_list" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
        <Original>
          array_a, UnorderedRangeEquals( { 10, 20, 1 } )
        </Original>
        <Expanded>
          { 1, 10, 20 } unordered elements are { 10, 20, 1 }
        </Expanded>
      </Expression>
      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
        <Original>
          array_a, UnorderedRangeEquals( { 11, 21, 2 }, []( int l, int r ) { return std::abs( l - r ) &lt;= 1; } )
        </Original>
        <Expanded>
          { 1, 10, 20 } unordered elements are { 11, 21, 2 }
        </Expanded>
      </Expression>
      <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
    </Section>
    <OverallResult success="true" skips="0"/>
  </TestCase>
  <TestCase name="Usage of the SizeIs range matcher" tags="[matchers][size][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -21971,6 +21933,6 @@ Approx( -1.95996398454005449 )
    </Section>
    <OverallResult success="true" skips="0"/>
  </TestCase>
-  <OverallResults successes="2087" failures="147" expectedFailures="35" skips="12"/>
+  <OverallResults successes="2083" failures="147" expectedFailures="35" skips="12"/>
  <OverallResultsCases successes="313" failures="86" expectedFailures="14" skips="6"/>
 </Catch2TestRun>
--- a/tests/SelfTest/Baselines/xml.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/xml.sw.multi.approved.txt
@@ -4493,7 +4493,7 @@ C
    </Expression>
    <OverallResult success="false" skips="0"/>
  </TestCase>
-  <TestCase name="Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
+  <TestCase name="Enums can quickly have stringification enabled using REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
    <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
      <Original>
        stringify( EnumClass3::Value1 ) == "Value1"
@@ -4538,7 +4538,7 @@ C
    </Expression>
    <OverallResult success="true" skips="0"/>
  </TestCase>
-  <TestCase name="Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
+  <TestCase name="Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
    <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
      <Original>
        stringify( Bikeshed::Colours::Red ) == "Red"
@@ -17383,25 +17383,6 @@ There is no extra whitespace here
      </Expression>
      <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
    </Section>
    <Section name="Compare against std::initializer_list" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
        <Original>
          array_a, RangeEquals( { 1, 2, 3 } )
        </Original>
        <Expanded>
          { 1, 2, 3 } elements are { 1, 2, 3 }
        </Expanded>
      </Expression>
      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
        <Original>
          array_a, RangeEquals( { 2, 4, 6 }, []( int l, int r ) { return l * 2 == r; } )
        </Original>
        <Expanded>
          { 1, 2, 3 } elements are { 2, 4, 6 }
        </Expanded>
      </Expression>
      <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
    </Section>
    <Section name="Check short-circuiting behaviour" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
      <Section name="Check short-circuits on failure" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17628,25 +17609,6 @@ There is no extra whitespace here
      </Expression>
      <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
    </Section>
    <Section name="Compare against std::initializer_list" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
        <Original>
          array_a, UnorderedRangeEquals( { 10, 20, 1 } )
        </Original>
        <Expanded>
          { 1, 10, 20 } unordered elements are { 10, 20, 1 }
        </Expanded>
      </Expression>
      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
        <Original>
          array_a, UnorderedRangeEquals( { 11, 21, 2 }, []( int l, int r ) { return std::abs( l - r ) &lt;= 1; } )
        </Original>
        <Expanded>
          { 1, 10, 20 } unordered elements are { 11, 21, 2 }
        </Expanded>
      </Expression>
      <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
    </Section>
    <OverallResult success="true" skips="0"/>
  </TestCase>
  <TestCase name="Usage of the SizeIs range matcher" tags="[matchers][size][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -21970,6 +21932,6 @@ Approx( -1.95996398454005449 )
    </Section>
    <OverallResult success="true" skips="0"/>
  </TestCase>
-  <OverallResults successes="2087" failures="147" expectedFailures="35" skips="12"/>
+  <OverallResults successes="2083" failures="147" expectedFailures="35" skips="12"/>
  <OverallResultsCases successes="313" failures="86" expectedFailures="14" skips="6"/>
 </Catch2TestRun>
--- a/tests/SelfTest/IntrospectiveTests/ToString.tests.cpp
+++ b/tests/SelfTest/IntrospectiveTests/ToString.tests.cpp
@@ -7,13 +7,10 @@
 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/internal/catch_enum_values_registry.hpp>
 #include <catch2/matchers/catch_matchers_string.hpp>
 #include <catch2/matchers/catch_matchers_vector.hpp>
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_template_test_macros.hpp>
 #include <chrono>
 enum class EnumClass3 { Value1, Value2, Value3, Value4 };
 struct UsesSentinel {
@@ -98,23 +95,3 @@ TEMPLATE_TEST_CASE( "Stringifying char arrays with statically known sizes",
    TestType no_null_terminator[3] = { 'a', 'b', 'c' };
    CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s );
 }
 TEST_CASE( "#2944 - Stringifying dates before 1970 should not crash", "[.approvals]" ) {
    using Catch::Matchers::Equals;
    using Days = std::chrono::duration<int32_t, std::ratio<86400>>;
    using SysDays = std::chrono::time_point<std::chrono::system_clock, Days>;
    Catch::StringMaker<std::chrono::system_clock::time_point> sm;
    // Check simple date first
    const SysDays post1970{ Days{ 1 } };
    auto converted_post = sm.convert( post1970 );
    REQUIRE( converted_post == "1970-01-02T00:00:00Z" );
    const SysDays pre1970{ Days{ -1 } };
    auto converted_pre = sm.convert( pre1970 );
    REQUIRE_THAT(
        converted_pre,
        Equals( "1969-12-31T00:00:00Z" ) ||
            Equals( "gmtime from provided timepoint has failed. This "
                    "happens e.g. with pre-1970 dates using Microsoft libc" ) );
 }
--- a/tests/SelfTest/UsageTests/Compilation.tests.cpp
+++ b/tests/SelfTest/UsageTests/Compilation.tests.cpp
@@ -8,7 +8,6 @@
 #include <helpers/type_with_lit_0_comparisons.hpp>
 #include <array>
 #include <type_traits>
 // Setup for #1403 -- look for global overloads of operator << for classes
@@ -35,7 +34,6 @@ static std::ostream& operator<<(std::ostream& out, foo::helper_1403 const&) {
 ///////////////////////////////
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/generators/catch_generators_range.hpp>
 #include <catch2/matchers/catch_matchers_string.hpp>
 #include <cstring>
@@ -469,57 +467,3 @@ TEST_CASE( "Comparing const std::weak_ordering instances must compile",
    REQUIRE( plain_ordering_1 == const_ordering_1 );
 }
 #endif
 // Reproduce issue with yaml-cpp iterators, where the `const_iterator`
 // for Node type has `const T` as the value_type. This is wrong for
 // multitude of reasons, but there might be other libraries in the wild
 // that share this issue, and the workaround needed to support
 // `from_range(iter, iter)` helper with those libraries is easy enough.
 class HasBadIterator {
    std::array<int, 10> m_arr{};
 public:
    class iterator {
        const int* m_ptr = nullptr;
    public:
        iterator( const int* ptr ): m_ptr( ptr ) {}
        using difference_type = std::ptrdiff_t;
        using value_type = const int;
        using pointer = const int*;
        using reference = const int&;
        using iterator_category = std::input_iterator_tag;
        iterator& operator++() {
            ++m_ptr;
            return *this;
        }
        iterator operator++( int ) {
            auto ret( *this );
            ++( *this );
            return ret;
        }
        friend bool operator==( iterator lhs, iterator rhs ) {
            return lhs.m_ptr == rhs.m_ptr;
        }
        friend bool operator!=( iterator lhs, iterator rhs ) {
            return !( lhs == rhs );
        }
        int operator*() const { return *m_ptr; }
    };
    iterator cbegin() const { return { m_arr.data() }; }
    iterator cend() const { return { m_arr.data() + m_arr.size() }; }
 };
 TEST_CASE("from_range(iter, iter) supports const_iterators", "[generators][from-range][approvals]") {
    using namespace Catch::Generators;
    HasBadIterator data;
    auto gen = from_range(data.cbegin(), data.cend());
    (void)gen;
 }
--- a/tests/SelfTest/UsageTests/EnumToString.tests.cpp
+++ b/tests/SelfTest/UsageTests/EnumToString.tests.cpp
@@ -79,7 +79,7 @@ enum class EnumClass3 { Value1, Value2, Value3, Value4 };
 CATCH_REGISTER_ENUM( EnumClass3, EnumClass3::Value1, EnumClass3::Value2, EnumClass3::Value3 )
-TEST_CASE( "Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM" ) {
+TEST_CASE( "Enums can quickly have stringification enabled using REGISTER_ENUM" ) {
    using Catch::Detail::stringify;
    REQUIRE( stringify( EnumClass3::Value1 ) == "Value1" );
    REQUIRE( stringify( EnumClass3::Value2 ) == "Value2" );
@@ -101,7 +101,7 @@ CATCH_REGISTER_ENUM( Bikeshed::Colours,
                     Bikeshed::Colours::Green,
                     Bikeshed::Colours::Blue )
-TEST_CASE( "Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM" ) {
+TEST_CASE( "Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" ) {
    using Catch::Detail::stringify;
    REQUIRE( stringify( Bikeshed::Colours::Red ) == "Red" );
    REQUIRE( stringify( Bikeshed::Colours::Blue ) == "Blue" );
--- a/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
+++ b/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
@@ -727,15 +727,6 @@ TEST_CASE( "Usage of RangeEquals range matcher", "[matchers][templated][quantifi
                      } ) );
    }
    SECTION( "Compare against std::initializer_list" ) {
        const std::array<int, 3> array_a{ { 1, 2, 3 } };
        REQUIRE_THAT( array_a, RangeEquals( { 1, 2, 3 } ) );
        REQUIRE_THAT( array_a, RangeEquals( { 2, 4, 6 }, []( int l, int r ) {
                          return l * 2 == r;
                      } ) );
    }
    SECTION("Check short-circuiting behaviour") {
        with_mocked_iterator_access<int> const mocked1{ 1, 2, 3, 4 };
@@ -829,16 +820,6 @@ TEST_CASE( "Usage of UnorderedRangeEquals range matcher",
        REQUIRE_THAT( needs_adl1, UnorderedRangeEquals( needs_adl2 ) );
    }
    SECTION( "Compare against std::initializer_list" ) {
        const std::array<int, 3> array_a{ { 1, 10, 20 } };
        REQUIRE_THAT( array_a, UnorderedRangeEquals( { 10, 20, 1 } ) );
        REQUIRE_THAT( array_a,
                      UnorderedRangeEquals( { 11, 21, 2 }, []( int l, int r ) {
                          return std::abs( l - r ) <= 1;
                      } ) );
    }
 }
 /**
--- a/tests/SelfTest/UsageTests/Tricky.tests.cpp
+++ b/tests/SelfTest/UsageTests/Tricky.tests.cpp
@@ -308,10 +308,15 @@ TEST_CASE( "X/level/0/b", "[Tricky][fizz]" ){ SUCCEED(""); }
 TEST_CASE( "X/level/1/a", "[Tricky]" )      { SUCCEED(""); }
 TEST_CASE( "X/level/1/b", "[Tricky]" )      { SUCCEED(""); }
 #include <chrono>
 #include <thread>
 TEST_CASE( "has printf" ) {
    // This can cause problems as, currently, stdout itself is not redirected - only the cout (and cerr) buffer
    printf( "loose text artifact\n" );
    fflush( stdout );
    std::this_thread::sleep_for( std::chrono::seconds( 1 ) );
 }
 namespace {
--- a/tests/TestScripts/DiscoverTests/CMakeLists.txt
+++ b/tests/TestScripts/DiscoverTests/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.10)
 project(discover-tests-test
  LANGUAGES CXX
@@ -19,11 +19,4 @@ if (CMAKE_VERSION GREATER_EQUAL 3.27)
            DL_PATHS "${CMAKE_CURRENT_LIST_DIR};${CMAKE_CURRENT_LIST_DIR}/.."
    )
 endif ()
-catch_discover_tests(
+catch_discover_tests(tests ${extra_args})
  tests
  ADD_TAGS_AS_LABELS
  DISCOVERY_MODE PRE_TEST
  ${extra_args}
 )
 # DISCOVERY_MODE <POST_BUILD|PRE_TEST>
--- a/tests/TestScripts/DiscoverTests/VerifyRegistration.py
+++ b/tests/TestScripts/DiscoverTests/VerifyRegistration.py
@@ -12,10 +12,6 @@ import subprocess
 import sys
 import re
 import json
 from collections import namedtuple
 from typing import List
 TestInfo = namedtuple('TestInfo', ['name', 'tags'])
 cmake_version_regex = re.compile('cmake version (\d+)\.(\d+)\.(\d+)')
@@ -65,7 +61,7 @@ def build_project(sources_dir, output_base_path, catch2_path):
-def get_test_names(build_path: str) -> List[TestInfo]:
+def get_test_names(build_path):
    # For now we assume that Windows builds are done using MSBuild under
    # Debug configuration. This means that we need to add "Debug" folder
    # to the path when constructing it. On Linux, we don't add anything.
@@ -73,23 +69,15 @@ def get_test_names(build_path: str) -> List[TestInfo]:
    full_path = os.path.join(build_path, config_path, 'tests')
-    cmd = [full_path, '--reporter', 'json', '--list-tests']
+    cmd = [full_path, '--reporter', 'xml', '--list-tests']
    result = subprocess.run(cmd,
                            capture_output = True,
                            check = True,
                            text = True)
-    test_listing = json.loads(result.stdout)
+    import xml.etree.ElementTree as ET
-
+    root = ET.fromstring(result.stdout)
-    assert test_listing['version'] == 1
+    return [tc.text for tc in root.findall('TestCase/Name')]
    tests = []
    for test in test_listing['listings']['tests']:
        test_name = test['name']
        tags = test['tags']
        tests.append(TestInfo(test_name, tags))
    return tests
 def get_ctest_listing(build_path):
    old_path = os.getcwd()
@@ -103,25 +91,20 @@ def get_ctest_listing(build_path):
    os.chdir(old_path)
    return result.stdout
-def extract_tests_from_ctest(ctest_output) -> List[TestInfo]:
+def extract_tests_from_ctest(ctest_output):
    ctest_response = json.loads(ctest_output)
    tests = ctest_response['tests']
-    test_infos = []
+    test_names = []
    for test in tests:
        test_command = test['command']
        # First part of the command is the binary, second is the filter.
        # If there are less, registration has failed. If there are more,
        # registration has changed and the script needs updating.
        assert len(test_command) == 2
        test_names.append(test_command[1])
        test_name = test_command[1]
        labels = []
        for prop in test['properties']:
            if prop['name'] == 'LABELS':
                labels = prop['value']
-        test_infos.append(TestInfo(test_name, labels))
+    return test_names
    return test_infos
 def check_DL_PATHS(ctest_output):
    ctest_response = json.loads(ctest_output)
@@ -132,14 +115,10 @@ def check_DL_PATHS(ctest_output):
            if property['name'] == 'ENVIRONMENT_MODIFICATION':
                assert len(property['value']) == 2, f"The test provides 2 arguments to DL_PATHS, but instead found {len(property['value'])}"
-def escape_catch2_test_names(infos: List[TestInfo]):
+def escape_catch2_test_name(name):
-    escaped = []
+    for char in ('\\', ',', '[', ']'):
-    for info in infos:
+        name = name.replace(char, f"\\{char}")
-      name = info.name
+    return name
      for char in ('\\', ',', '[', ']'):
          name = name.replace(char, f"\\{char}")
      escaped.append(TestInfo(name, info.tags))
    return escaped
 if __name__ == '__main__':
    if len(sys.argv) != 3:
@@ -151,7 +130,7 @@ if __name__ == '__main__':
    build_path = build_project(sources_dir, output_base_path, catch2_path)
-    catch_test_names = escape_catch2_test_names(get_test_names(build_path))
+    catch_test_names = [escape_catch2_test_name(name) for name in get_test_names(build_path)]
    ctest_output = get_ctest_listing(build_path)
    ctest_test_names = extract_tests_from_ctest(ctest_output)
@@ -168,7 +147,6 @@ if __name__ == '__main__':
    if mismatched:
        print(f"Found {mismatched} mismatched tests catch test names and ctest test commands!")
        exit(1)
    print(f"{len(catch_test_names)} tests matched")
    cmake_version = get_cmake_version()
    if cmake_version >= (3, 27):
--- a/tests/TestScripts/DiscoverTests/register-tests.cpp
+++ b/tests/TestScripts/DiscoverTests/register-tests.cpp
@@ -14,10 +14,3 @@ TEST_CASE( "Let's have a test case with a long name. Longer. No, even longer. "
           "Really looooooooooooong. Even longer than that. Multiple lines "
           "worth of test name. Yep, like this." ) {}
 TEST_CASE( "And now a test case with weird tags.", "[tl;dr][tl;dw][foo,bar]" ) {}
 // Also check that we handle tests on class, which have name in output as 'class-name', not 'name'.
 class TestCaseFixture {
 public:
    int m_a;
 };
 TEST_CASE_METHOD(TestCaseFixture, "A test case as method", "[tagstagstags]") {}
--- a/tests/TestScripts/testBazelReporter.py
+++ b/tests/TestScripts/testBazelReporter.py
@@ -52,7 +52,7 @@ try:
    )
    stdout = ret.stdout
 except subprocess.SubprocessError as ex:
-    if ex.returncode == 42:
+    if ex.returncode == 1:
        # The test cases are allowed to fail.
        test_passing = False
        stdout = ex.stdout
--- a/tools/misc/CMakeLists.txt
+++ b/tools/misc/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.0)
 project(CatchCoverageHelper)
Author	SHA1	Message	Date
Martin Hořeňovský	432695291a	Flush AND sleep	2024-09-15 20:46:24 +02:00
Martin Hořeňovský	e63f3cc817	Refactor pipe-based redirect to not always create new thread and pipe	2024-09-15 20:22:40 +02:00
Martin Hořeňovský	986ee2c793	WIP: rebase pipe redirect onto current redirect interface	2024-09-13 19:17:39 +02:00
`@@ -1,4 +1,4 @@`
	`name: Arm Mac builds`	`name: M1 Mac builds`

	`on: [push, pull_request]`	`on: [push, pull_request]`
`@@ -1,4 +1,4 @@`
	`cmake_minimum_required( VERSION 3.16 )`	`cmake_minimum_required( VERSION 3.10 )`

	`project( Catch2Examples LANGUAGES CXX )`	`project( Catch2Examples LANGUAGES CXX )`
`@@ -1,2 +1 @@`
	`option('tests', type: 'boolean', value: true, description: 'Build the unit tests')`	`option('tests', type: 'boolean', value: true, description: 'Build the unit tests')`
	`option('install', type: 'boolean', value: true, description: 'Install the library')`
`@@ -1,4 +1,4 @@`
	`cmake_minimum_required(VERSION 3.16)`	`cmake_minimum_required(VERSION 3.0)`

	`project(CatchCoverageHelper)`	`project(CatchCoverageHelper)`