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,
-    # 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
+    runs-on: macos-12
    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
-  set_property(DIRECTORY
-    APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
-  )
+  if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
+    # Add discovered tests to directory TEST_INCLUDE_FILES
+    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
-    OUTPUT_VARIABLE listing_output
+    COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
+    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
-  string(JSON version GET "${listing_output}" "version")
-  if (NOT version STREQUAL "1")
-    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")
-
+  # Parse output
+  foreach(line ${output})
+    set(test "${line}")
    # 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}")
-    foreach(char \\ , [ ] ;)
-      string(REPLACE ${char} "\\${char}" escaped_name "${escaped_name}")
+    set(test_name "${test}")
+    foreach(char \\ , [ ])
+      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}")
-      set(output_dir_arg "--out ${output_dir}/${output_prefix}${escaped_name_clean}${output_suffix}")
+      string(REGEX REPLACE "[^A-Za-z0-9_]" "_" test_name_clean "${test_name}")
+      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
-//  Generated: 2025-04-08 12:33:19.863332
+//  Catch v3.7.0
+//  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;
-        static constexpr int UnspecifiedErrorExitCode = 1;
-        static constexpr int AllTestsSkippedExitCode = 4;
-        static constexpr int NoTestsRunExitCode = 2;
-        static constexpr int UnmatchedTestSpecExitCode = 3;
-        static constexpr int InvalidTestSpecExitCode = 5;
-
+        const int MaxExitCode = 255;

        IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
@@ -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 UnmatchedTestSpecExitCode;
+                return 3;
            }

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

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

-            if ( totals.assertions.failed ) { return TestFailureExitCode; }
-            return 0;
-
+            // Note that on unices only the lower 8 bits are usually used, clamping
+            // the return value to 255 prevents false negative when some multiple
+            // of 256 tests has failed
+            return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed));
        }
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
        catch( std::exception& ex ) {
            Catch::cerr() << ex.what() << '\n' << std::flush;
-            return UnspecifiedErrorExitCode;
+            return MaxExitCode;
        }
 #endif
    }
@@ -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 {
-                Big,
-                Little
-            };
+            enum Arch { 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) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, CATCH_MOVE(message), m_reaction );
+    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef message) {
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
    }

    auto AssertionHandler::allowThrows() const -> bool {
@@ -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 {
-    Left,
-    Right
-};
+enum class Justification { 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
-//  Generated: 2025-04-08 12:33:19.851017
+//  Catch v3.7.0
+//  Generated: 2024-08-14 12:04:53.220567
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -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 )
-#    define CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P
-#endif
+#  if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
+#  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 {
-            return m_resultCapture;
-        }
-        constexpr IConfig const* getConfig() const { return m_config; }
-        constexpr void setResultCapture( IResultCapture* resultCapture ) {
-            m_resultCapture = resultCapture;
-        }
-        constexpr void setConfig( IConfig const* config ) { m_config = config; }
-
+        IResultCapture* getResultCapture() const { return m_resultCapture; }
+        IConfig const* getConfig() const { return m_config; }
+        void setResultCapture( IResultCapture* resultCapture );
+        void setConfig( IConfig const* config );
    };

    Context& getCurrentMutableContext();
@@ -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 ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    constexpr bool isJustInfo( int flags ) { return flags == ResultWas::Info; }
+    bool isOk( ResultWas::OfType resultType );
+    bool isJustInfo( int flags );


    // ResultDisposition::Flags enum
@@ -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 rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) |
-                                                      static_cast<int>( rhs ) );
-    }
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );

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

 } // end namespace Catch

@@ -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);
-            if ( err ) {
-                return "gmtime from provided timepoint has failed. This "
-                       "happens e.g. with pre-1970 dates using Microsoft libc";
-            }
+            gmtime_s(&timeInfo, &converted);
 #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;
-        constexpr ITransientExpression& operator=( ITransientExpression const& ) = default;
+        ITransientExpression() = default;
+        ITransientExpression(ITransientExpression const&) = default;
+        ITransientExpression& operator=(ITransientExpression const&) = default;

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

    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
@@ -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:
-        m_testAsMethod( testAsMethod ) {}
+    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : 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:
-        m_testAsMethod( testAsMethod ) {}
+    TestInvokerFixture( void ( C::*testAsMethod )() const) noexcept : 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 {
-            return *m_info;
-        }
+        TestCaseInfo const& getTestCaseInfo() const;
    };

    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_PATCH 1
+#define CATCH_VERSION_MINOR 7
+#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); }
-    constexpr result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
+    result_type a() const { return transposeBack(m_a); }
+    result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
 };

 } // end namespace Catch
@@ -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,
-                                                    ForwardIter last ) {
+        std::ptrdiff_t sentinel_distance( ForwardIter first,
+                                          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,
-                                             const Sentinel1 end_1,
-                                             ForwardIter2 first_2,
-                                             const Sentinel2 end_2,
-                                             Comparator cmp ) {
+        bool check_element_counts( ForwardIter1 first_1,
+                                   const Sentinel1 end_1,
+                                   ForwardIter2 first_2,
+                                   const Sentinel2 end_2,
+                                   Comparator cmp ) {
            auto cursor = first_1;
            while ( cursor != end_1 ) {
                if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
@@ -9865,11 +9826,11 @@ namespace Catch {
                  typename ForwardIter2,
                  typename Sentinel2,
                  typename Comparator>
-        constexpr bool is_permutation( ForwardIter1 first_1,
-                                       const Sentinel1 end_1,
-                                       ForwardIter2 first_2,
-                                       const Sentinel2 end_2,
-                                       Comparator cmp ) {
+        bool is_permutation( ForwardIter1 first_1,
+                             const Sentinel1 end_1,
+                             ForwardIter2 first_2,
+                             const Sentinel2 end_2,
+                             Comparator cmp ) {
            // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
            // TODO: Comparator has to be "both sides", e.g. a == b => b == a
            // This skips shared prefix of the two ranges
@@ -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 ) {
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) |
-                                           static_cast<std::uint8_t>( rhs ) );
-    }
-
-    constexpr XmlFormatting operator&( XmlFormatting lhs, XmlFormatting rhs ) {
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) &
-                                           static_cast<std::uint8_t>( rhs ) );
-    }
-
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);

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

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

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

@@ -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>
-    makeMatchExpr( ArgT&& arg, MatcherT const& matcher ) {
+    auto makeMatchExpr( ArgT && arg, MatcherT const& matcher ) -> MatchExpr<ArgT, MatcherT> {
        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
-         * (defaulting to `std::equal_to`)
+         * Uses `std::equal_to` to do the comparison
         */
-        template <typename RangeLike,
-                  typename Equality = decltype( std::equal_to<>{} )>
-        constexpr
+        template <typename RangeLike>
+        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>
        RangeEqualsMatcher<RangeLike, Equality>
-        RangeEquals( RangeLike&& range,
-                     Equality&& predicate = std::equal_to<>{} ) {
+        RangeEquals( RangeLike&& range, Equality&& predicate ) {
            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
-         * (defaulting to `std::equal_to`)
+         * Uses `std::equal_to` to do the comparison
         */
-        template <typename T,
-                  typename Equality = decltype( std::equal_to<>{} )>
-        constexpr
-        RangeEqualsMatcher<std::initializer_list<T>, Equality>
-        RangeEquals( std::initializer_list<T> range,
-                     Equality&& predicate = std::equal_to<>{} ) {
-            return { range, CATCH_FORWARD( predicate ) };
+        template <typename RangeLike>
+        std::enable_if_t<
+            !Detail::is_matcher<RangeLike>::value,
+            UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
+        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
-         * (defaulting to `std::equal_to`)
+         * Uses to provided predicate `predicate` to do the comparisons
         */
-        template <typename RangeLike,
-                  typename Equality = decltype( std::equal_to<>{} )>
-        constexpr
+        template <typename RangeLike, typename Equality>
        UnorderedRangeEqualsMatcher<RangeLike, Equality>
-        UnorderedRangeEquals( RangeLike&& range,
-                              Equality&& predicate = std::equal_to<>{} ) {
+        UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
            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;
-        static constexpr int UnspecifiedErrorExitCode = 1;
-        static constexpr int AllTestsSkippedExitCode = 4;
-        static constexpr int NoTestsRunExitCode = 2;
-        static constexpr int UnmatchedTestSpecExitCode = 3;
-        static constexpr int InvalidTestSpecExitCode = 5;
-
+        const int MaxExitCode = 255;

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

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

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

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

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

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

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

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


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

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

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

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

-            if ( totals.assertions.failed ) { return TestFailureExitCode; }
-            return 0;
-
+            // Note that on unices only the lower 8 bits are usually used, clamping
+            // the return value to 255 prevents false negative when some multiple
+            // of 256 tests has failed
+            return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed));
        }
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
        catch( std::exception& ex ) {
            Catch::cerr() << ex.what() << '\n' << std::flush;
-            return UnspecifiedErrorExitCode;
+            return MaxExitCode;
        }
 #endif
    }
--- a/src/catch2/catch_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 {
-                Big,
-                Little
-            };
+            enum Arch { 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);
-            if ( err ) {
-                return "gmtime from provided timepoint has failed. This "
-                       "happens e.g. with pre-1970 dates using Microsoft libc";
-            }
+            gmtime_s(&timeInfo, &converted);
 #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_PATCH 1
+#define CATCH_VERSION_MINOR 7
+#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 )
-#    define CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P
-#endif
+#  if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
+#  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 ) |
-                                           static_cast<std::uint8_t>( rhs ) );
+        return static_cast<XmlFormatting>( static_cast<uint8_t>( lhs ) |
+                                           static_cast<uint8_t>( rhs ) );
    }

    constexpr XmlFormatting operator&( XmlFormatting lhs, XmlFormatting rhs ) {
-        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) &
-                                           static_cast<std::uint8_t>( rhs ) );
+        return static_cast<XmlFormatting>( static_cast<uint8_t>( lhs ) &
+                                           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
-         * (defaulting to `std::equal_to`)
+         * Uses `std::equal_to` to do the comparison
         */
-        template <typename RangeLike,
-                  typename Equality = decltype( std::equal_to<>{} )>
+        template <typename RangeLike>
+        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,
-                     Equality&& predicate = std::equal_to<>{} ) {
+        RangeEquals( RangeLike&& range, Equality&& predicate ) {
            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
-         * (defaulting to `std::equal_to`)
+         * Uses `std::equal_to` to do the comparison
         */
-        template <typename T,
-                  typename Equality = decltype( std::equal_to<>{} )>
+        template <typename RangeLike>
        constexpr
-        RangeEqualsMatcher<std::initializer_list<T>, Equality>
-        RangeEquals( std::initializer_list<T> range,
-                     Equality&& predicate = std::equal_to<>{} ) {
-            return { range, CATCH_FORWARD( predicate ) };
+        std::enable_if_t<
+            !Detail::is_matcher<RangeLike>::value,
+            UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
+        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
-         * (defaulting to `std::equal_to`)
+         * Uses to provided predicate `predicate` to do the comparisons
         */
-        template <typename RangeLike,
-                  typename Equality = decltype( std::equal_to<>{} )>
+        template <typename RangeLike, typename Equality>
        constexpr
        UnorderedRangeEqualsMatcher<RangeLike, Equality>
-        UnorderedRangeEquals( RangeLike&& range,
-                              Equality&& predicate = std::equal_to<>{} ) {
+        UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
            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))
-  endif
+  install_headers(file, subdir: join_paths(include_subdir, folder))
 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(
-    catch2,
-    filebase: 'catch2',
-    description: 'A modern, C++-native, test framework for C++14 and above',
-    url: 'https://github.com/catchorg/Catch2',
-  )
-endif
+pkg.generate(
+  catch2,
+  filebase: 'catch2',
+  description: 'A modern, C++-native, test framework for C++14 and above',
+  url: 'https://github.com/catchorg/Catch2',
+)

 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(
-    catch2_with_main,
-    filebase: 'catch2-with-main',
-    description: 'A modern, C++-native, test framework for C++14 and above (links in default main)',
-    requires: 'catch2 = ' + meson.project_version(),
-  )
-endif
+pkg.generate(
+  catch2_with_main,
+  filebase: 'catch2-with-main',
+  description: 'A modern, C++-native, test framework for C++14 and above (links in default main)',
+  requires: 'catch2 = ' + meson.project_version(),
+)
--- 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 {
-    Left,
-    Right
-};
+enum class Justification { 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 in namespaces 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 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 in namespaces 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 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 in namespaces 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 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 in namespaces 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 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 in namespaces 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 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 in namespaces 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 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[testFinished name='Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM' duration="{duration}"]
-##teamcity[testStarted name='Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM']
-##teamcity[testFinished name='Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM' duration="{duration}"]
+##teamcity[testStarted name='Enums can quickly have stringification enabled using REGISTER_ENUM']
+##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 REGISTER_ENUM']
+##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[testFinished name='Enums can quickly have stringification enabled using CATCH_REGISTER_ENUM' duration="{duration}"]
-##teamcity[testStarted name='Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM']
-##teamcity[testFinished name='Enums in namespaces can quickly have stringification enabled using CATCH_REGISTER_ENUM' duration="{duration}"]
+##teamcity[testStarted name='Enums can quickly have stringification enabled using REGISTER_ENUM']
+##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 REGISTER_ENUM']
+##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(
-  tests
-  ADD_TAGS_AS_LABELS
-  DISCOVERY_MODE PRE_TEST
-  ${extra_args}
-)
-
-# DISCOVERY_MODE <POST_BUILD|PRE_TEST>
+catch_discover_tests(tests ${extra_args})
--- 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)
-
-    assert test_listing['version'] == 1
-
-    tests = []
-    for test in test_listing['listings']['tests']:
-        test_name = test['name']
-        tags = test['tags']
-        tests.append(TestInfo(test_name, tags))
-
-    return tests
+    import xml.etree.ElementTree as ET
+    root = ET.fromstring(result.stdout)
+    return [tc.text for tc in root.findall('TestCase/Name')]

 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_infos
+    return test_names

 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]):
-    escaped = []
-    for info in infos:
-      name = info.name
-      for char in ('\\', ',', '[', ']'):
-          name = name.replace(char, f"\\{char}")
-      escaped.append(TestInfo(name, info.tags))
-    return escaped
+def escape_catch2_test_name(name):
+    for char in ('\\', ',', '[', ']'):
+        name = name.replace(char, f"\\{char}")
+    return name

 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