WIP: devirtualize RunContext

Devirtualize RegistryHub
Unify ITestCaseRegistry and TestRegistry
2023-03-21 11:32:44 +01:00 · 2023-03-21 11:30:22 +01:00 · 2023-03-21 11:30:19 +01:00 · 2023-03-21 11:30:17 +01:00 · 2023-03-21 11:30:12 +01:00 · 2023-03-21 11:30:08 +01:00
447 changed files with 14997 additions and 12577 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -1,25 +1,45 @@
 ---
-AccessModifierOffset: '-4'
-AlignEscapedNewlines: Left
-AllowAllConstructorInitializersOnNextLine: 'true'
-BinPackArguments: 'false'
-BinPackParameters: 'false'
-BreakConstructorInitializers: AfterColon
-ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
-DerivePointerAlignment: 'false'
-FixNamespaceComments: 'true'
-IncludeBlocks: Regroup
-IndentCaseLabels: 'false'
-IndentPPDirectives: AfterHash
-IndentWidth: '4'
 Language: Cpp
+Standard: c++14
+
+# Note that we cannot use IncludeIsMainRegex functionality, because it
+# does not support includes in angle brackets (<>)
+SortIncludes: true
+IncludeBlocks: Regroup
+IncludeCategories:
+  - Regex: <catch2/.*\.hpp>
+    Priority: 1
+  - Regex: <.*/.*\.hpp>
+    Priority: 2
+  - Regex: <.*>
+    Priority: 3
+
+AllowShortBlocksOnASingleLine: Always
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLambdasOnASingleLine: Inline
+
+AccessModifierOffset: "-4"
+AlignEscapedNewlines: Left
+AllowAllConstructorInitializersOnNextLine: "true"
+BinPackArguments: "false"
+BinPackParameters: "false"
+BreakConstructorInitializers: AfterColon
+ConstructorInitializerAllOnOneLineOrOnePerLine: "true"
+DerivePointerAlignment: "false"
+FixNamespaceComments: "true"
+IndentCaseLabels: "false"
+IndentPPDirectives: AfterHash
+IndentWidth: "4"
 NamespaceIndentation: All
 PointerAlignment: Left
-SpaceBeforeCtorInitializerColon: 'false'
-SpaceInEmptyParentheses: 'false'
-SpacesInParentheses: 'true'
-Standard: Cpp11
-TabWidth: '4'
+SpaceBeforeCtorInitializerColon: "false"
+SpaceInEmptyParentheses: "false"
+SpacesInParentheses: "true"
+TabWidth: "4"
 UseTab: Never
-
-...
+AlwaysBreakTemplateDeclarations: Yes
+SpaceAfterTemplateKeyword: true
+SortUsingDeclarations: true
+ReflowComments: true
--- a/.github/workflows/linux-bazel-builds.yml
+++ b/.github/workflows/linux-bazel-builds.yml
@@ -0,0 +1,24 @@
+name: Bazel build
+
+on: [push, pull_request]
+
+jobs:
+  build_and_test_ubuntu:
+    name: Linux Ubuntu 22.04 Bazel build <GCC 11.2.0>
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        compilation_mode: [fastbuild, dbg, opt]
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Mount bazel cache
+      uses: actions/cache@v3
+      with:
+        path: "/home/runner/.cache/bazel"
+        key: bazel-ubuntu22-gcc11
+
+    - name: Build Catch2
+      run: |
+        bazelisk build --compilation_mode=${{matrix.compilation_mode}} //...
--- a/.github/workflows/linux-meson-builds.yml
+++ b/.github/workflows/linux-meson-builds.yml
@@ -1,4 +1,4 @@
-name: Linux builds (basic) using meson build system
+name: Linux builds (meson)

 on: [push, pull_request]

--- a/.github/workflows/linux-other-builds.yml
+++ b/.github/workflows/linux-other-builds.yml
@@ -86,6 +86,7 @@ jobs:
        cmake -Bbuild -H$GITHUB_WORKSPACE \
              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
+              -DCMAKE_CXX_STANDARD_REQUIRED=ON \
              -DCMAKE_CXX_EXTENSIONS=OFF \
              -DCATCH_DEVELOPMENT_BUILD=ON \
              ${{matrix.cmake_configurations}} \
--- a/.github/workflows/linux-simple-builds.yml
+++ b/.github/workflows/linux-simple-builds.yml
@@ -65,6 +65,22 @@ jobs:
            build_type: Release
            std: 17
            other_pkgs: clang-10
+          - cxx: clang++-10
+            build_type: Debug
+            std: 20
+            other_pkgs: clang-10
+          - cxx: clang++-10
+            build_type: Release
+            std: 20
+            other_pkgs: clang-10
+          - cxx: g++-10
+            build_type: Debug
+            std: 20
+            other_pkgs: g++-10
+          - cxx: g++-10
+            build_type: Release
+            std: 20
+            other_pkgs: g++-10

    steps:
    - uses: actions/checkout@v2
@@ -89,6 +105,7 @@ jobs:
        cmake -Bbuild -H$GITHUB_WORKSPACE \
              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
+              -DCMAKE_CXX_STANDARD_REQUIRED=ON \
              -DCMAKE_CXX_EXTENSIONS=OFF \
              -DCATCH_DEVELOPMENT_BUILD=ON \
              -G Ninja
--- a/.github/workflows/mac-builds.yml
+++ b/.github/workflows/mac-builds.yml
@@ -33,8 +33,11 @@ jobs:
      #       This is important
      run: |
        cmake -Bbuild -H$GITHUB_WORKSPACE \
-              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DCMAKE_CXX_STANDARD=${{matrix.std}} \
-              -DCATCH_DEVELOPMENT_BUILD=ON -DCATCH_BUILD_EXAMPLES=${{matrix.examples}} \
+              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
+              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
+              -DCMAKE_CXX_STANDARD_REQUIRED=ON \
+              -DCATCH_DEVELOPMENT_BUILD=ON \
+              -DCATCH_BUILD_EXAMPLES=${{matrix.examples}} \
              -DCATCH_BUILD_EXTRA_TESTS=${{matrix.examples}}

    - name: Build tests + lib
--- a/.github/workflows/windows-simple-builds.yml
+++ b/.github/workflows/windows-simple-builds.yml
@@ -0,0 +1,37 @@
+name: Windows builds (basic)
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    name: ${{matrix.os}}, ${{matrix.std}}, ${{matrix.build_type}}, ${{matrix.platform}}
+    runs-on: ${{matrix.os}}
+    strategy:
+      matrix:
+        os: [windows-2019, windows-2022]
+        platform: [Win32, x64]
+        build_type: [Debug, Release]
+        std: [14, 17]
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Configure build
+        working-directory: ${{runner.workspace}}
+        run: |
+          cmake -S $Env:GITHUB_WORKSPACE               `
+                -B ${{runner.workspace}}/build         `
+                -DCMAKE_CXX_STANDARD=${{matrix.std}}   `
+                -A ${{matrix.platform}}                `
+                --preset all-tests
+
+      - name: Build tests
+        working-directory: ${{runner.workspace}}
+        run: cmake --build build --config ${{matrix.build_type}} --parallel %NUMBER_OF_PROCESSORS%
+        shell: cmd
+
+      - name: Run tests
+        working-directory: ${{runner.workspace}}/build
+        env:
+            CTEST_OUTPUT_ON_FAILURE: 1
+        run: ctest -C ${{matrix.build_type}} -j %NUMBER_OF_PROCESSORS%
+        shell: cmd
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -28,6 +28,7 @@ expand_template(
        "#cmakedefine CATCH_CONFIG_EXPERIMENTAL_REDIRECT": "",
        "#cmakedefine CATCH_CONFIG_FALLBACK_STRINGIFIER @CATCH_CONFIG_FALLBACK_STRINGIFIER@": "",
        "#cmakedefine CATCH_CONFIG_FAST_COMPILE": "",
+        "#cmakedefine CATCH_CONFIG_GETENV": "",
        "#cmakedefine CATCH_CONFIG_GLOBAL_NEXTAFTER": "",
        "#cmakedefine CATCH_CONFIG_NO_ANDROID_LOGWRITE": "",
        "#cmakedefine CATCH_CONFIG_NO_COLOUR_WIN32": "",
@@ -38,6 +39,7 @@ expand_template(
        "#cmakedefine CATCH_CONFIG_NO_CPP17_STRING_VIEW": "",
        "#cmakedefine CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS": "",
        "#cmakedefine CATCH_CONFIG_NO_CPP17_VARIANT": "",
+        "#cmakedefine CATCH_CONFIG_NO_GETENV": "",
        "#cmakedefine CATCH_CONFIG_NO_GLOBAL_NEXTAFTER": "",
        "#cmakedefine CATCH_CONFIG_NO_POSIX_SIGNALS": "",
        "#cmakedefine CATCH_CONFIG_NO_USE_ASYNC": "",
--- a/CMake/CatchConfigOptions.cmake
+++ b/CMake/CatchConfigOptions.cmake
@@ -1,7 +1,7 @@

 #              Copyright Catch2 Authors
 # Distributed under the Boost Software License, Version 1.0.
-#   (See accompanying file LICENSE_1_0.txt or copy at
+#   (See accompanying file LICENSE.txt or copy at
 #        https://www.boost.org/LICENSE_1_0.txt)

 # SPDX-License-Identifier: BSL-1.0
@@ -40,6 +40,7 @@ set(_OverridableOptions
  "USE_ASYNC"
  "WCHAR"
  "WINDOWS_SEH"
+  "GETENV"
 )

 foreach(OptionName ${_OverridableOptions})
--- a/CMake/CatchMiscFunctions.cmake
+++ b/CMake/CatchMiscFunctions.cmake
@@ -1,7 +1,7 @@

 #              Copyright Catch2 Authors
 # Distributed under the Boost Software License, Version 1.0.
-#   (See accompanying file LICENSE_1_0.txt or copy at
+#   (See accompanying file LICENSE.txt or copy at
 #        https://www.boost.org/LICENSE_1_0.txt)

 # SPDX-License-Identifier: BSL-1.0
@@ -13,7 +13,7 @@ function(add_cxx_flag_if_supported_to_targets flagname targets)

    if (HAVE_FLAG_${flag_identifier})
        foreach(target ${targets})
-            target_compile_options(${target} PUBLIC ${flagname})
+            target_compile_options(${target} PRIVATE ${flagname})
        endforeach()
    endif()
 endfunction()
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -31,7 +31,7 @@ if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 endif()

 project(Catch2
-  VERSION 3.1.1 # CML version placeholder, don't delete
+  VERSION 3.3.2 # CML version placeholder, don't delete
  LANGUAGES CXX
  # HOMEPAGE_URL is not supported until CMake version 3.12, which
  # we do not target yet.
@@ -148,6 +148,8 @@ if (NOT_SUBPROJECT)
            "extras/ParseAndAddCatchTests.cmake"
            "extras/Catch.cmake"
            "extras/CatchAddTests.cmake"
+            "extras/CatchShardTests.cmake"
+            "extras/CatchShardTestsImpl.cmake"
          DESTINATION
            ${CATCH_CMAKE_CONFIG_DESTINATION}
        )
--- a/2
+++ b/2
@@ -1319,7 +1319,7 @@ CHM_FILE               =
 HHC_LOCATION           =

 # The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the master .chm file (NO).
+# (YES) or that it should be included in the main .chm file (NO).
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.

--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 <a id="top"></a>
-![Catch2 logo](data/artwork/catch2-logo-small.png)
+![Catch2 logo](data/artwork/catch2-logo-small-with-background.png)

 [![Github Releases](https://img.shields.io/github/release/catchorg/catch2.svg)](https://github.com/catchorg/catch2/releases)
 [![Linux build status](https://github.com/catchorg/Catch2/actions/workflows/linux-simple-builds.yml/badge.svg)](https://github.com/catchorg/Catch2/actions/workflows/linux-simple-builds.yml)
@@ -11,31 +11,82 @@
 [![Join the chat in Discord: https://discord.gg/4CWS9zD](https://img.shields.io/badge/Discord-Chat!-brightgreen.svg)](https://discord.gg/4CWS9zD)


-## What's the Catch2?
+## What is Catch2?

 Catch2 is mainly a unit testing framework for C++, but it also
 provides basic micro-benchmarking features, and simple BDD macros.

 Catch2's main advantage is that using it is both simple and natural.
-Tests autoregister themselves and do not have to be named with valid
-identifiers, assertions look like normal C++ code, and sections provide
-a nice way to share set-up and tear-down code in tests.
+Test names do not have to be valid identifiers, assertions look like
+normal C++ boolean expressions, and sections provide a nice and local way
+to share set-up and tear-down code in tests.
+
+**Example unit test**
+```cpp
+#include <catch2/catch_test_macros.hpp>
+
+#include <cstdint>
+
+uint32_t factorial( uint32_t number ) {
+    return number <= 1 ? number : factorial(number-1) * number;
+}
+
+TEST_CASE( "Factorials are computed", "[factorial]" ) {
+    REQUIRE( factorial( 1) == 1 );
+    REQUIRE( factorial( 2) == 2 );
+    REQUIRE( factorial( 3) == 6 );
+    REQUIRE( factorial(10) == 3'628'800 );
+}
+```
+
+**Example microbenchmark**
+```cpp
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/benchmark/catch_benchmark.hpp>
+
+#include <cstdint>
+
+uint64_t fibonacci(uint64_t number) {
+    return number < 2 ? number : fibonacci(number - 1) + fibonacci(number - 2);
+}
+
+TEST_CASE("Benchmark Fibonacci", "[!benchmark]") {
+    REQUIRE(fibonacci(5) == 5);
+
+    REQUIRE(fibonacci(20) == 6'765);
+    BENCHMARK("fibonacci 20") {
+        return fibonacci(20);
+    };
+
+    REQUIRE(fibonacci(25) == 75'025);
+    BENCHMARK("fibonacci 25") {
+        return fibonacci(25);
+    };
+}
+```
+
+_Note that benchmarks are not run by default, so you need to run it explicitly
+with the `[!benchmark]` tag._


-## Catch2 v3 is being developed!
+## Catch2 v3 has been released!

-You are on the `devel` branch, where the next major version, v3, of
-Catch2 is being developed. As it is a significant rework, you will
-find that parts of this documentation are likely still stuck on v2.
+You are on the `devel` branch, where the v3 version is being developed.
+v3 brings a bunch of significant changes, the big one being that Catch2
+is no longer a single-header library. Catch2 now behaves as a normal
+library, with multiple headers and separately compiled implementation.

-For stable (and documentation-matching) version of Catch2, [go to the
-`v2.x` branch](https://github.com/catchorg/Catch2/tree/v2.x).
+The documentation is slowly being updated to take these changes into
+account, but this work is currently still ongoing.

 For migrating from the v2 releases to v3, you should look at [our
 documentation](docs/migrate-v2-to-v3.md#top). It provides a simple
 guidelines on getting started, and collects most common migration
 problems.

+For the previous major version of Catch2 [look into the `v2.x` branch
+here on GitHub](https://github.com/catchorg/Catch2/tree/v2.x).
+

 ## How to use it
 This documentation comprises these three parts:
--- a/WORKSPACE.bazel
+++ b/WORKSPACE.bazel
@@ -4,12 +4,13 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

 http_archive(
    name = "bazel_skylib",
+    sha256 = "b8a1527901774180afc798aeb28c4634bdccf19c4d98e7bdd1ce79d1fe9aaad7",
    urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.3.0/bazel-skylib-1.3.0.tar.gz",
-        "https://github.com/bazelbuild/bazel-skylib/releases/download/1.3.0/bazel-skylib-1.3.0.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.4.1/bazel-skylib-1.4.1.tar.gz",
+        "https://github.com/bazelbuild/bazel-skylib/releases/download/1.4.1/bazel-skylib-1.4.1.tar.gz",
    ],
-    sha256 = "74d544d96f4a5bb630d465ca8bbcfe231e3594e5aae57e1edbf17a6eb3ca2506",
 )

 load("@bazel_skylib//:workspace.bzl", "bazel_skylib_workspace")
+
 bazel_skylib_workspace()
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -51,18 +51,6 @@ test_script:
 # build explicitly.
 environment:
  matrix:
-    - FLAVOR: VS 2019 x64 Debug Surrogates Configure Tests
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      surrogates: 1
-      configure_tests: 1
-      platform: x64
-      configuration: Debug
-    
-    - FLAVOR: VS 2019 x64 Release
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      platform: x64
-      configuration: Release
-
    - FLAVOR: VS 2019 x64 Debug Coverage Examples
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      examples: 1
@@ -77,11 +65,6 @@ environment:
      platform: x64
      configuration: Debug

-    - FLAVOR: VS 2019 Win32 Debug
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      platform: Win32
-      configuration: Debug
-
    - FLAVOR: VS 2019 x64 Debug Latest Strict
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      additional_flags: "/permissive- /std:c++latest"
@@ -92,38 +75,9 @@ environment:
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      platform: x64
      configuration: Debug
-    
-    - FLAVOR: VS 2017 x64 Release
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      platform: x64
-      configuration: Release

    - FLAVOR: VS 2017 x64 Release Coverage
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      coverage: 1
      platform: x64
-      configuration: Debug
-
-    - FLAVOR: VS 2017 Win32 Debug
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      platform: Win32
-      configuration: Debug
-
-    - FLAVOR: VS 2017 Win32 Debug Examples
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      examples: 1
-      platform: Win32
-      configuration: Debug
-
-    - FLAVOR: VS 2017 Win32 Debug WMain
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      wmain: 1
-      additional_flags: "/D_UNICODE /DUNICODE"
-      platform: Win32
-      configuration: Debug
-
-    - FLAVOR: VS 2017 x64 Debug Latest Strict
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      additional_flags: "/permissive- /std:c++latest"
-      platform: x64
-      configuration: Debug
+      configuration: Debug
--- a/data/artwork/catch2-logo-small-with-background.png
+++ b/data/artwork/catch2-logo-small-with-background.png
--- a/docs/Readme.md
+++ b/docs/Readme.md
@@ -11,6 +11,7 @@ Once you're up and running consider the following reference material.
 * [Logging macros](logging.md#top)
 * [Test cases and sections](test-cases-and-sections.md#top)
 * [Test fixtures](test-fixtures.md#top)
+* [Explicitly skipping, passing, and failing tests at runtime](skipping-passing-failing.md#top)
 * [Reporters (output customization)](reporters.md#top)
 * [Event Listeners](event-listeners.md#top)
 * [Data Generators (value parameterized tests)](generators.md#top)
@@ -29,7 +30,7 @@ Once you're up and running consider the following reference material.
 * [Frequently Asked Questions (FAQ)](faq.md#top)
 * [Best practices and other tips](usage-tips.md#top)
 * [CMake integration](cmake-integration.md#top)
-* [CI and other miscellaneous pieces](ci-and-misc.md#top)
+* [Tooling integration (CI, test runners, other)](ci-and-misc.md#top)
 * [Known limitations](limitations.md#top)

 **Other:**
--- a/docs/ci-and-misc.md
+++ b/docs/ci-and-misc.md
@@ -1,8 +1,15 @@
 <a id="top"></a>
-# CI and other odd pieces
+# Tooling integration (CI, test runners and so on)
+
+**Contents**<br>
+[Continuous Integration systems](#continuous-integration-systems)<br>
+[Bazel test runner integration](#bazel-test-runner-integration)<br>
+[Low-level tools](#low-level-tools)<br>
+[CMake](#cmake)<br>
+
+This page talks about Catch2's integration with other related tooling,
+like Continuous Integration and 3rd party test runners.

-This page talks about how Catch integrates with Continuous Integration
-Build Systems may refer to low-level tools, like CMake, or larger systems that run on servers, like Jenkins or TeamCity. This page will talk about both.

 ## Continuous Integration systems

@@ -51,6 +58,26 @@ Because of the incremental nature of Catch's test suites and ability to run spec
 [SonarQube Generic Test Data](https://docs.sonarqube.org/latest/analysis/generic-test/) XML format for tests metrics.


+## Bazel test runner integration
+
+Catch2 understands some of the environment variables Bazel uses to control
+test execution. Specifically it understands
+
+ * JUnit output path via `XML_OUTPUT_FILE`
+ * Test filtering via `TESTBRIDGE_TEST_ONLY`
+ * Test sharding via `TEST_SHARD_INDEX`, `TEST_TOTAL_SHARDS`, and `TEST_SHARD_STATUS_FILE`
+
+> Support for `XML_OUTPUT_FILE` was [introduced](https://github.com/catchorg/Catch2/pull/2399) in Catch2 3.0.1
+
+> Support for `TESTBRIDGE_TEST_ONLY` and sharding was introduced in Catch2 3.2.0
+
+This integration is enabled via either a [compile time configuration
+option](configuration.md#bazel-support), or via `BAZEL_TEST` environment
+variable set to "1".
+
+> Support for `BAZEL_TEST` was [introduced](https://github.com/catchorg/Catch2/pull/2459) in Catch2 3.1.0
+
+
 ## Low-level tools

 ### CodeCoverage module (GCOV, LCOV...)
--- a/docs/cmake-integration.md
+++ b/docs/cmake-integration.md
@@ -90,12 +90,12 @@ cmake_minimum_required(VERSION 3.5)
 project(baz LANGUAGES CXX VERSION 0.0.1)

 find_package(Catch2 REQUIRED)
-add_executable(foo test.cpp)
-target_link_libraries(foo PRIVATE Catch2::Catch2)
+add_executable(tests test.cpp)
+target_link_libraries(tests PRIVATE Catch2::Catch2)

 include(CTest)
 include(Catch)
-catch_discover_tests(foo)
+catch_discover_tests(tests)
 ```

 When using `FetchContent`, `include(Catch)` will fail unless
@@ -108,7 +108,7 @@ directory.
 list(APPEND CMAKE_MODULE_PATH ${catch2_SOURCE_DIR}/extras)
 include(CTest)
 include(Catch)
-catch_discover_tests()
+catch_discover_tests(tests)
 ```

 #### Customization
@@ -222,12 +222,12 @@ cmake_minimum_required(VERSION 3.5)
 project(baz LANGUAGES CXX VERSION 0.0.1)

 find_package(Catch2 REQUIRED)
-add_executable(foo test.cpp)
-target_link_libraries(foo PRIVATE Catch2::Catch2)
+add_executable(tests test.cpp)
+target_link_libraries(tests PRIVATE Catch2::Catch2)

 include(CTest)
 include(ParseAndAddCatchTests)
-ParseAndAddCatchTests(foo)
+ParseAndAddCatchTests(tests)
 ```


--- a/docs/command-line.md
+++ b/docs/command-line.md
@@ -148,7 +148,7 @@ validity, and throw an error if they are wrong._
 > Support for passing arguments to reporters through the `-r`, `--reporter` flag was introduced in Catch2 3.0.1

 There are multiple built-in reporters, you can see what they do by using the
-[`--list-reporter`](command-line.md#listing-available-tests-tags-or-reporters)
+[`--list-reporters`](command-line.md#listing-available-tests-tags-or-reporters)
 flag. If you need a reporter providing custom format outside of the already
 provided ones, look at the ["write your own reporter" part of the reporter
 documentation](reporters.md#writing-your-own-reporter).
@@ -507,10 +507,13 @@ start of the first section.</br>
 ## Filenames as tags
 <pre>-#, --filenames-as-tags</pre>

-When this option is used then every test is given an additional tag which is formed of the unqualified
-filename it is found in, with any extension stripped, prefixed with the `#` character.
+This option adds an extra tag to all test cases. The tag is `#` followed
+by the unqualified filename the test case is defined in, with the _last_
+extension stripped out.
+
+For example, tests within the file `tests\SelfTest\UsageTests\BDD.tests.cpp`
+will be given the `[#BDD.tests]` tag.

-So, for example,  tests within the file `~\Dev\MyProject\Ferrets.cpp` would be tagged `[#Ferrets]`.

 <a id="colour-mode"></a>
 ## Override output colouring
@@ -561,10 +564,10 @@ processes, as is done with the [Bazel test sharding](https://docs.bazel.build/ve

 > Introduced in Catch2 3.0.1.

-By default, Catch2 test binaries return non-0 exit code if no tests were
-run, e.g. if the binary was compiled with no tests, or the provided test
-spec matched no tests. This flag overrides that, so a test run with no
-tests still returns 0.
+By default, Catch2 test binaries return non-0 exit code if no tests were run,
+e.g. if the binary was compiled with no tests, the provided test spec matched no
+tests, or all tests [were skipped at runtime](skipping-passing-failing.md#top). This flag
+overrides that, so a test run with no tests still returns 0.

 ## Output verbosity
 ```
--- a/docs/comparing-floating-point-numbers.md
+++ b/docs/comparing-floating-point-numbers.md
@@ -16,7 +16,7 @@ this blog post](https://codingnest.com/the-little-things-comparing-floating-poin
 ## Floating point matchers

 ```
-#include <catch2/matchers/catch_matchers_floating.hpp
+#include <catch2/matchers/catch_matchers_floating_point.hpp>
 ```

 [Matchers](matchers.md#top) are the preferred way of comparing floating
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -98,13 +98,19 @@ is equivalent with the out-of-the-box experience.


 ## Bazel support
-When `CATCH_CONFIG_BAZEL_SUPPORT` is defined or when `BAZEL_TEST=1` (which is set by the Bazel inside of a test environment),
-Catch2 will register a `JUnit` reporter writing to a path pointed by `XML_OUTPUT_FILE` provided by Bazel.
+
+Compiling Catch2 with `CATCH_CONFIG_BAZEL_SUPPORT` force-enables Catch2's
+support for Bazel's environment variables (normally Catch2 looks for
+`BAZEL_TEST=1` env var first).
+
+This can be useful if you are using older versions of Bazel, that do not
+yet have `BAZEL_TEST` env var support.

 > `CATCH_CONFIG_BAZEL_SUPPORT` was [introduced](https://github.com/catchorg/Catch2/pull/2399) in Catch2 3.0.1.

 > `CATCH_CONFIG_BAZEL_SUPPORT` was [deprecated](https://github.com/catchorg/Catch2/pull/2459) in Catch2 3.1.0.

+
 ## C++11 toggles

    CATCH_CONFIG_CPP11_TO_STRING // Use `std::to_string`
@@ -149,13 +155,20 @@ by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.
    CATCH_CONFIG_USE_ASYNC                  // Force parallel statistical processing of samples during benchmarking
    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_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
+
 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`).

+`CATCH_CONFIG_GETENV` is on by default, except when Catch2 is compiled for
+platforms that lacks working `std::getenv` (currently Windows UWP and
+Playstation).
+
 `CATCH_CONFIG_WINDOWS_CRTDBG` is off by default. If enabled, Windows's
 CRT is used to check for memory leaks, and displays them after the tests
 finish running. This option only works when linking against the default
--- a/docs/contributing.md
+++ b/docs/contributing.md
@@ -55,6 +55,15 @@ tests from `SelfTest` through a specific reporter and then compare the
 generated output with a known good output ("Baseline"). By default, new
 tests should be placed here.

+To configure a Catch2 build with just the basic tests, use the `basic-tests`
+preset, like so:
+
+```
+# Assuming you are in Catch2's root folder
+
+cmake -B basic-test-build -S . -DCMAKE_BUILD_TYPE=Debug --preset basic-tests
+```
+
 However, not all tests can be written as plain unit tests. For example,
 checking that Catch2 orders tests randomly when asked to, and that this
 random ordering is subset-invariant, is better done as an integration
@@ -76,21 +85,23 @@ configuration and require separate compilation.
 Finally, CMake config tests test that you set Catch2's compile-time
 configuration options through CMake, using CMake options of the same name.

-None of these tests are enabled by default. To enable them, add
+These test categories can be enabled one by one, by passing
 `-DCATCH_BUILD_EXAMPLES=ON`, `-DCATCH_BUILD_EXTRA_TESTS=ON`, and
-`-DCATCH_ENABLE_CONFIGURE_TESTS=ON` when configuration the CMake build.
+`-DCATCH_ENABLE_CONFIGURE_TESTS=ON` when configuring the build.

-Bringing this all together, the steps below should configure, build,
-and run all tests in the `Debug` compilation.
+Catch2 also provides a preset that promises to enable _all_ test types,
+`all-tests`.
+
+The snippet below will build & run all tests, in `Debug` compilation mode.

 <!-- snippet: catch2-build-and-test -->
 <a id='snippet-catch2-build-and-test'></a>
 ```sh
-# 1. Regenerate the amalgamated distribution
+# 1. Regenerate the amalgamated distribution (some tests are built against it)
 ./tools/scripts/generateAmalgamatedFiles.py

 # 2. Configure the full test build
-cmake -Bdebug-build -H. -DCMAKE_BUILD_TYPE=Debug -DCATCH_DEVELOPMENT_BUILD=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_BUILD_EXTRA_TESTS=ON
+cmake -B debug-build -S . -DCMAKE_BUILD_TYPE=Debug --preset all-tests

 # 3. Run the actual build
 cmake --build debug-build
@@ -291,7 +302,7 @@ Specifically, every source file should start with the licence header:

    //              Copyright Catch2 Authors
    // Distributed under the Boost Software License, Version 1.0.
-    //   (See accompanying file LICENSE_1_0.txt or copy at
+    //   (See accompanying file LICENSE.txt or copy at
    //        https://www.boost.org/LICENSE_1_0.txt)

    // SPDX-License-Identifier: BSL-1.0
@@ -303,6 +314,20 @@ be `CATCH_MATCHERS_FOO_HPP_INCLUDED`, for `catch_generators_bar.hpp`, the includ
 guard should be `CATCH_GENERATORS_BAR_HPP_INCLUDED`, and so on.


+### Adding new `CATCH_CONFIG` option
+
+When adding new `CATCH_CONFIG` option, there are multiple places to edit:
+  * `CMake/CatchConfigOptions.cmake` - this is used to generate the
+    configuration options in CMake, so that CMake frontends know about them.
+  * `docs/configuration.md` - this is where the options are documented
+  * `src/catch2/catch_user_config.hpp.in` - this is template for generating
+    `catch_user_config.hpp` which contains the materialized configuration
+  * `BUILD.bazel` - Bazel does not have configuration support like CMake,
+    and all expansions need to be done manually
+  * other files as needed, e.g. `catch2/internal/catch_config_foo.hpp`
+    for the logic that guards the configuration
+
+
 ## CoC

 This project has a [CoC](../CODE_OF_CONDUCT.md). Please adhere to it
--- a/docs/deprecations.md
+++ b/docs/deprecations.md
@@ -26,6 +26,15 @@ to accurately probe the environment for this information so the flag
 where it will export `BAZEL_TEST=1` for purposes like the above. Catch2
 will now instead inspect the environment instead of relying on build configuration.

+### `IEventLister::skipTest( TestCaseInfo const& testInfo )`
+
+This event (including implementations in derived classes such as `ReporterBase`)
+is deprecated and will be removed in the next major release. It is currently
+invoked for all test cases that are not going to be executed due to the test run
+being aborted (when using `--abort` or `--abortx`). It is however
+**NOT** invoked for test cases that are [explicitly skipped using the `SKIP`
+macro](skipping-passing-failing.md#top).
+
 ---

 [Home](Readme.md#top)
--- a/docs/faq.md
+++ b/docs/faq.md
@@ -9,6 +9,8 @@
 [What is Catch2's API stability policy?](#what-is-catch2s-api-stability-policy)<br>
 [Does Catch2 support running tests in parallel?](#does-catch2-support-running-tests-in-parallel)<br>
 [Can I compile Catch2 into a dynamic library?](#can-i-compile-catch2-into-a-dynamic-library)<br>
+[What repeatability guarantees does Catch2 provide?](#what-repeatability-guarantees-does-catch2-provide)<br>
+

 ## How do I run global setup/teardown only if tests will be run?

@@ -69,6 +71,24 @@ library on platforms that default to public visibility, or with tooling
 support to force export Catch2's API.


+## What repeatability guarantees does Catch2 provide?
+
+There are two places where it is meaningful to talk about Catch2's
+repeatability guarantees without taking into account user-provided
+code. First one is in the test case shuffling, and the second one is
+the output from random generators.
+
+Test case shuffling is repeatable across different platforms since v2.12.0,
+and it is also generally repeatable across versions, but we might break
+it from time to time. E.g. we broke repeatability with previous versions
+in v2.13.4 so that test cases with similar names are shuffled better.
+
+Random generators currently rely on platform's stdlib, specifically
+the distributions from `<random>`. We thus provide no extra guarantee
+above what your platform does. **Important: `<random>`'s distributions
+are not specified to be repeatable across different platforms.**
+
+
 ---

 [Home](Readme.md#top)
--- a/docs/generators.md
+++ b/docs/generators.md
@@ -205,13 +205,17 @@ struct IGenerator : GeneratorUntypedBase {
    // Precondition:
    // The generator is either freshly constructed or the last call to next() returned true
    virtual T const& get() const = 0;
+
+    // Returns user-friendly string showing the current generator element
+    // Does not have to be overridden, IGenerator provides default implementation
+    virtual std::string stringifyImpl() const;
 };
 ```

 However, to be able to use your custom generator inside `GENERATE`, it
 will need to be wrapped inside a `GeneratorWrapper<T>`.
 `GeneratorWrapper<T>` is a value wrapper around a
-`std::unique_ptr<IGenerator<T>>`.
+`Catch::Detail::unique_ptr<IGenerator<T>>`.

 For full example of implementing your own generator, look into Catch2's
 examples, specifically
--- a/docs/limitations.md
+++ b/docs/limitations.md
@@ -88,8 +88,8 @@ because only one thread passes the `REQUIRE` macro and this is not
    REQUIRE(cnt == 16);
 ```

-Because C++11 provides the necessary tools to do this, we are planning
-to remove this limitation in the future.
+We currently do not plan to support thread-safe assertions.
+

 ### Process isolation in a test
 Catch does not support running tests in isolated (forked) processes. While this might in the future, the fact that Windows does not support forking and only allows full-on process creation and the desire to keep code as similar as possible across platforms, mean that this is likely to take significant development time, that is not currently available.
@@ -155,7 +155,7 @@ with expansion:


 ### Clang/G++ -- skipping leaf sections after an exception
-Some versions of `libc++` and `libstdc++` (or their runtimes) have a bug with `std::uncaught_exception()` getting stuck returning `true` after rethrow, even if there are no active exceptions. One such case is this snippet, which skipped the sections "a" and "b", when compiled against `libcxxrt` from master
+Some versions of `libc++` and `libstdc++` (or their runtimes) have a bug with `std::uncaught_exception()` getting stuck returning `true` after rethrow, even if there are no active exceptions. One such case is this snippet, which skipped the sections "a" and "b", when compiled against `libcxxrt` from the master branch
 ```cpp
 #include <catch2/catch_test_macros.hpp>

--- a/docs/matchers.md
+++ b/docs/matchers.md
@@ -141,18 +141,27 @@ are a permutation of the ones in `some_vec`.

 ### Floating point matchers

-Catch2 provides 3 matchers that target floating point numbers. These
+Catch2 provides 4 matchers that target floating point numbers. These
 are:

 * `WithinAbs(double target, double margin)`,
 * `WithinULP(FloatingPoint target, uint64_t maxUlpDiff)`, and
 * `WithinRel(FloatingPoint target, FloatingPoint eps)`.
+* `IsNaN()`

 > `WithinRel` matcher was introduced in Catch2 2.10.0

-For more details, read [the docs on comparing floating point
+> `IsNaN` matcher was introduced in Catch2 3.3.2.
+
+The first three serve to compare two floating pointe numbers. For more
+details about how they work, read [the docs on comparing floating point
 numbers](comparing-floating-point-numbers.md#floating-point-matchers).

+`IsNaN` then does exactly what it says on the tin. It matches the input
+if it is a NaN (Not a Number). The advantage of using it over just plain
+`REQUIRE(std::isnan(x))`, is that if the check fails, with `REQUIRE` you
+won't see the value of `x`, but with `REQUIRE_THAT(x, IsNaN())`, you will.
+

 ### Miscellaneous matchers

@@ -190,13 +199,23 @@ properties. The macro is `REQUIRE_THROWS_MATCHES(expr, ExceptionType, Matcher)`.
 > `REQUIRE_THROWS_MATCHES` macro lives in `catch2/matchers/catch_matchers.hpp`


-Catch2 currently provides only one matcher for exceptions,
-`Message(std::string message)`. `Message` checks that the exception's
+Catch2 currently provides two matchers for exceptions.
+These are:
+* `Message(std::string message)`.
+* `MessageMatches(Matcher matcher)`.
+
+> `MessageMatches` was [introduced](https://github.com/catchorg/Catch2/pull/2570) in Catch2 3.3.0
+
+`Message` checks that the exception's
 message, as returned from `what` is exactly equal to `message`.

+`MessageMatches` applies the provided matcher on the exception's
+message, as returned from `what`. This is useful in conjunctions with the `std::string` matchers (e.g. `StartsWith`)
+
 Example use:
 ```cpp
 REQUIRE_THROWS_MATCHES(throwsDerivedException(),  DerivedException,  Message("DerivedException::what"));
+REQUIRE_THROWS_MATCHES(throwsDerivedException(),  DerivedException,  MessageMatches(StartsWith("DerivedException")));
 ```

 Note that `DerivedException` in the example above has to derive from
@@ -218,11 +237,19 @@ definitions to handle generic range-like types. These are:
 * `Contains(T&& target_element, Comparator = std::equal_to<>{})`
 * `Contains(Matcher element_matcher)`
 * `AllMatch(Matcher element_matcher)`
-* `NoneMatch(Matcher element_matcher)`
 * `AnyMatch(Matcher element_matcher)`
-* `AllTrue()`
-* `NoneTrue()`
-* `AnyTrue()`
+* `NoneMatch(Matcher element_matcher)`
+* `AllTrue()`, `AnyTrue()`, `NoneTrue()`
+* `RangeEquals(TargetRangeLike&&, Comparator = std::equal_to<>{})`
+* `UnorderedRangeEquals(TargetRangeLike&&, Comparator = std::equal_to<>{})`
+
+> `IsEmpty`, `SizeIs`, `Contains` were introduced in Catch2 3.0.1
+
+> `All/Any/NoneMatch` were introduced in Catch2 3.0.1
+
+> `All/Any/NoneTrue` were introduced in Catch2 3.1.0
+
+> `RangeEquals` and `UnorderedRangeEquals` matchers were [introduced](https://github.com/catchorg/Catch2/pull/2377) in Catch2 3.3.0

 `IsEmpty` should be self-explanatory. It successfully matches objects
 that are empty according to either `std::empty`, or ADL-found `empty`
@@ -249,6 +276,25 @@ all, none, or any of the contained elements are `true`, respectively.
 It works for ranges of `bool`s and ranges of elements (explicitly)
 convertible to `bool`.

+`RangeEquals` compares the range that the matcher is constructed with
+(the "target range") against the range to be tested, element-wise. The
+match succeeds if all elements from the two ranges compare equal (using
+`operator==` by default). The ranges do not need to be the same type,
+and the element types do not need to be the same, as long as they are
+comparable. (e.g. you may compare `std::vector<int>` to `std::array<char>`).
+
+`UnorderedRangeEquals` is similar to `RangeEquals`, but the order
+does not matter. For example "1, 2, 3" would match "3, 2, 1", but not
+"1, 1, 2, 3" As with `RangeEquals`, `UnorderedRangeEquals` compares
+the individual elements using using `operator==` by default.
+
+Both `RangeEquals` and `UnorderedRangeEquals` optionally accept a
+predicate which can be used to compare the containers element-wise.
+
+To check a container elementwise against a given matcher, use
+`AllMatch`.
+
+
 ## Writing custom matchers (old style)

 The old style of writing matchers has been introduced back in Catch
--- a/docs/opensource-users.md
+++ b/docs/opensource-users.md
@@ -110,6 +110,12 @@ A header-only TOML parser and serializer for modern C++.
 ### [Trompeloeil](https://github.com/rollbear/trompeloeil)
 A thread-safe header-only mocking framework for C++14.

+### [wxWidgets](https://www.wxwidgets.org/)
+Cross-Platform C++ GUI Library.
+
+### [xmlwrapp](https://github.com/vslavik/xmlwrapp)
+C++ XML parsing library using libxml2.
+
 ## Applications & Tools

 ### [App Mesh](https://github.com/laoshanxi/app-mesh)
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -2,6 +2,11 @@

 # Release notes
 **Contents**<br>
+[3.3.2](#332)<br>
+[3.3.1](#331)<br>
+[3.3.0](#330)<br>
+[3.2.1](#321)<br>
+[3.2.0](#320)<br>
 [3.1.1](#311)<br>
 [3.1.0](#310)<br>
 [3.0.1](#301)<br>
@@ -52,6 +57,110 @@



+## 3.3.2
+
+### Improvements
+* Further reduced allocations
+  * The compact, console, TAP and XML reporters perform less allocations in various cases
+  * Removed 1 allocation per entered `SECTION`/`TEST_CASE`.
+  * Removed 2 allocations per test case exit, if stdout/stderr is captured
+* Improved performance
+  * Section tracking is 10%-25% faster than in v3.3.0
+  * Assertion handling is 5%-10% faster than in v3.3.0
+  * Test case registration is 1%-2% faster than in v3.3.0
+  * Tiny speedup for registering listeners
+  * Tiny speedup for `CAPTURE`, `TEST_CASE_METHOD`, `METHOD_AS_TEST_CASE`, and `TEMPLATE_LIST_TEST_*` macros.
+* `Contains`, `RangeEquals` and `UnorderedRangeEquals` matchers now support ranges with iterator + sentinel pair
+* Added `IsNaN` matcher
+  * Unlike `REQUIRE(isnan(x))`, `REQUIRE_THAT(x, IsNaN())` shows you the value of `x`.
+* Suppressed `declared_but_not_referenced` warning for NVHPC (#2637)
+
+### Fixes
+* Fixed performance regression in section tracking introduced in v3.3.1
+  * Extreme cases would cause the tracking to run about 4x slower than in 3.3.0
+
+
+## 3.3.1
+
+### Improvements
+* Reduced allocations and improved performance
+  * The exact improvements are dependent on your usage of Catch2.
+  * For example running Catch2's SelfTest binary performs 8k less allocations.
+  * The main improvement comes from smarter handling of `SECTION`s, especially sibling `SECTION`s
+
+
+## 3.3.0
+
+### Improvements
+
+* Added `MessageMatches` exception matcher (#2570)
+* Added `RangeEquals` and `UnorderedRangeEquals` generic range matchers (#2377)
+* Added `SKIP` macro for skipping tests from within the test body (#2360)
+  * All built-in reporters have been extended to handle it properly, whether your custom reporter needs changes depends on how it was written
+  * `skipTest` reporter event **is unrelated** to this, and has been deprecated since it has practically no uses
+* Restored support for PPC Macs in the break-into-debugger functionality (#2619)
+* Made our warning suppression compatible with CUDA toolkit pre 11.5 (#2626)
+* Cleaned out some static analysis complaints
+
+
+### Fixes
+
+* Fixed macro redefinition warning when NVCC was reporting as MSVC (#2603)
+* Fixed throws in generator constructor causing the whole binary to abort (#2615)
+  * Now it just fails the test
+* Fixed missing transitive include with libstdc++13 (#2611)
+
+
+### Miscellaneous
+
+* Improved support for dynamic library build with non-MSVC compilers on Windows (#2630)
+* When used as a subproject, Catch2 keeps its generated header in a separate directory from the main project (#2604)
+
+
+
+## 3.2.1
+
+### Improvements
+* Fix the reworked decomposer to work with older (pre 9) GCC versions (#2571)
+  * **This required more significant changes to properly support C++20, there might be bugs.**
+
+
+## 3.2.0
+
+### Improvements
+* Catch2 now compiles on PlayStation (#2562)
+* Added `CATCH_CONFIG_GETENV` compile-time toggle (#2562)
+  * This toggle guards whether Catch2 calls `std::getenv` when reading env variables
+* Added support for more Bazel test environment variables
+  * `TESTBRIDGE_TEST_ONLY` is now supported (#2490)
+  * Sharding variables, `TEST_SHARD_INDEX`, `TEST_TOTAL_SHARDS`, `TEST_SHARD_STATUS_FILE`, are now all supported (#2491)
+* Bunch of small tweaks and improvements in reporters
+  * The TAP and SonarQube reporters output the used test filters
+  * The XML reporter now also reports the version of its output format
+  * The compact reporter now uses the same summary output as the console reporter (#878, #2554)
+* Added support for asserting on types that can only be compared with literal 0 (#2555)
+  * A canonical example is C++20's `std::*_ordering` types, which cannot be compared with an `int` variable, only `0`
+  * The support extends to any type with this property, not just the ones in stdlib
+  * This change imposes 2-3% slowdown on compiling files that are heavy on `REQUIRE` and friends
+  * **This required significant rewrite of decomposition, there might be bugs**
+* Simplified internals of matcher related macros
+  * This provides about ~2% speed up compiling files that are heavy on `REQUIRE_THAT` and friends
+
+
+### Fixes
+* Cleaned out some warnings and static analysis issues
+  * Suppressed `-Wcomma` warning rarely occuring in templated test cases (#2543)
+  * Constified implementation details in `INFO` (#2564)
+  * Made `MatcherGenericBase` copy constructor const (#2566)
+* Fixed serialization of test filters so the output roundtrips
+  * This means that e.g. `./tests/SelfTest "aaa bbb", [approx]` outputs `Filters: "aaa bbb",[approx]`
+
+
+### Miscellaneous
+* Catch2's build no longer leaks `-ffile-prefix-map` setting  to dependees (#2533)
+
+
+
 ## 3.1.1

 ### Improvements
@@ -449,7 +558,7 @@ v3 releases.
 ### Improvements
 * `std::result_of` is not used if `std::invoke_result` is available (#1934)
 * JUnit reporter writes out `status` attribute for tests (#1899)
-* Suppresed clang-tidy's `hicpp-vararg` warning (#1921)
+* Suppressed clang-tidy's `hicpp-vararg` warning (#1921)
  * Catch2 was already suppressing the `cppcoreguidelines-pro-type-vararg` alias of the warning


--- a/docs/skipping-passing-failing.md
+++ b/docs/skipping-passing-failing.md
@@ -0,0 +1,129 @@
+<a id="top"></a>
+# Explicitly skipping, passing, and failing tests at runtime
+
+## Skipping Test Cases at Runtime
+
+> [Introduced](https://github.com/catchorg/Catch2/pull/2360) in Catch2 3.3.0.
+
+In some situations it may not be possible to meaningfully execute a test case,
+for example when the system under test is missing certain hardware capabilities.
+If the required conditions can only be determined at runtime, it often
+doesn't make sense to consider such a test case as either passed or failed,
+because it simply can not run at all.
+
+To properly express such scenarios, Catch2 provides a way to explicitly
+_skip_ test cases, using the `SKIP` macro:
+
+```
+SKIP( [streamable expression] )
+```
+
+Example usage:
+
+```c++
+TEST_CASE("copy files between drives") {
+    if(getNumberOfHardDrives() < 2) {
+        SKIP("at least two hard drives required");
+    }
+    // ...
+}
+```
+
+This test case is then reported as _skipped_ instead of _passed_ or _failed_.
+
+The `SKIP` macro behaves similarly to an explicit [`FAIL`](#passing-and-failing-test-cases),
+in that it is the last expression that will be executed:
+
+```c++
+TEST_CASE("my test") {
+    printf("foo");
+    SKIP();
+    printf("bar"); // not printed
+}
+```
+
+However a failed assertion _before_ a `SKIP` still causes the entire
+test case to fail:
+
+```c++
+TEST_CASE("failing test") {
+    CHECK(1 == 2);
+    SKIP();
+}
+```
+
+### Interaction with Sections and Generators
+
+Sections, nested sections as well as specific outputs from [generators](generators.md#top)
+can all be individually skipped, with the rest executing as usual:
+
+```c++
+TEST_CASE("complex test case") {
+  int value = GENERATE(2, 4, 6);
+  SECTION("a") {
+    SECTION("a1") { CHECK(value < 8); }
+    SECTION("a2") {
+      if (value == 4) {
+        SKIP();
+      }
+      CHECK(value % 2 == 0);
+    }
+  }
+}
+```
+
+This test case will report 5 passing assertions; one for each of the three
+values in section `a1`, and then two in section `a2`, from values 2 and 4.
+
+Note that as soon as one section is skipped, the entire test case will
+be reported as _skipped_ (unless there is a failing assertion, in which
+case the test is handled as _failed_ instead).
+
+Note that if all test cases in a run are skipped, Catch2 returns a non-zero
+exit code, same as it does if no test cases have run. This behaviour can
+be overridden using the [--allow-running-no-tests](command-line.md#no-tests-override)
+flag.
+
+
+## Passing and failing test cases
+
+Test cases can also be explicitly passed or failed, without the use of
+assertions, and with a specific message. This can be useful to handle
+complex preconditions/postconditions and give useful error messages
+when they fail.
+
+* `SUCCEED( [streamable expression] )`
+
+`SUCCEED` is morally equivalent with `INFO( [streamable expression] ); REQUIRE( true );`.
+Note that it does not stop further test execution, so it cannot be used
+to guard failing assertions from being executed.
+
+_In practice, `SUCCEED` is usually used as a test placeholder, to avoid
+[failing a test case due to missing assertions](command-line.md#warnings)._
+
+```cpp
+TEST_CASE( "SUCCEED showcase" ) {
+    int I = 1;
+    SUCCEED( "I is " << I );
+    // ... execution continues here ...
+}
+```
+
+* `FAIL( [streamable expression] )`
+
+`FAIL` is morally equivalent with `INFO( [streamable expression] ); REQUIRE( false );`.
+
+_In practice, `FAIL` is usually used to stop executing test that is currently
+known to be broken, but has to be fixed later._
+
+```cpp
+TEST_CASE( "FAIL showcase" ) {
+    FAIL( "This test case causes segfault, which breaks CI." );
+    // ... this will not be executed ...
+}
+```
+
+
+---
+
+[Home](Readme.md#top)
--- a/docs/test-cases-and-sections.md
+++ b/docs/test-cases-and-sections.md
@@ -25,7 +25,8 @@ _section description_ can be used to provide long form description
 of a section while keeping the _section name_ short for use with the
 [`-c` command line parameter](command-line.md#specify-the-section-to-run).

-**Test names must be unique within the Catch executable.**
+**The combination of test names and tags must be unique within the Catch2
+executable.**

 For examples see the [Tutorial](tutorial.md#top)

@@ -68,7 +69,8 @@ All tag names beginning with non-alphanumeric characters are reserved by Catch.

 * `[!nonportable]` - Indicates that behaviour may vary between platforms or compilers.

-* `[#<filename>]` - running with `-#` or `--filenames-as-tags` causes Catch to add the filename, prefixed with `#` (and with any extension stripped), as a tag to all contained tests, e.g. tests in testfile.cpp would all be tagged `[#testfile]`.
+* `[#<filename>]` - these tags are added to test cases when you run Catch2
+                    with [`-#` or `--filenames-as-tags`](command-line.md#filenames-as-tags).

 * `[@<alias>]` - tag aliases all begin with `@` (see below).

@@ -167,7 +169,11 @@ Other than the additional prefixes and the formatting in the console reporter th

 In addition to `TEST_CASE`s, Catch2 also supports test cases parametrised
 by types, in the form of `TEMPLATE_TEST_CASE`,
-`TEMPLATE_PRODUCT_TEST_CASE` and `TEMPLATE_LIST_TEST_CASE`.
+`TEMPLATE_PRODUCT_TEST_CASE` and `TEMPLATE_LIST_TEST_CASE`. These macros
+are defined in the `catch_template_test_macros.hpp` header, so compiling
+the code examples below also requires
+`#include <catch2/catch_template_test_macros.hpp>`.
+

 * **TEMPLATE_TEST_CASE(** _test name_ , _tags_,  _type1_, _type2_, ..., _typen_ **)**

@@ -289,7 +295,9 @@ TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside std
 In addition to [type parametrised test cases](#type-parametrised-test-cases) Catch2 also supports
 signature base parametrised test cases, in form of `TEMPLATE_TEST_CASE_SIG` and `TEMPLATE_PRODUCT_TEST_CASE_SIG`.
 These test cases have similar syntax like [type parametrised test cases](#type-parametrised-test-cases), with one
-additional positional argument which specifies the signature.
+additional positional argument which specifies the signature. These macros are defined in the
+`catch_template_test_macros.hpp` header, so compiling the code examples below also requires
+`#include <catch2/catch_template_test_macros.hpp>`.

 ### Signature
 Signature has some strict rules for these tests cases to work properly:
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -54,8 +54,6 @@ set(ALL_EXAMPLE_TARGETS

 foreach( name ${ALL_EXAMPLE_TARGETS} )
    target_link_libraries( ${name} Catch2 Catch2WithMain )
-    set_property(TARGET ${name} PROPERTY CXX_STANDARD 14)
-    set_property(TARGET ${name} PROPERTY CXX_EXTENSIONS OFF)
 endforeach()


--- a/extras/CatchShardTests.cmake
+++ b/extras/CatchShardTests.cmake
@@ -1,7 +1,7 @@

 #              Copyright Catch2 Authors
 # Distributed under the Boost Software License, Version 1.0.
-#   (See accompanying file LICENSE_1_0.txt or copy at
+#   (See accompanying file LICENSE.txt or copy at
 #        https://www.boost.org/LICENSE_1_0.txt)

 # SPDX-License-Identifier: BSL-1.0
@@ -46,7 +46,7 @@ function(catch_add_sharded_tests TARGET)
    APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
  )

-  set(shard_impl_script_file "${CMAKE_CURRENT_LIST_DIR}/CatchShardTestsImpl.cmake")
+  set(shard_impl_script_file "${_CATCH_DISCOVER_SHARD_TESTS_IMPL_SCRIPT}")

  add_custom_command(
    TARGET ${TARGET} POST_BUILD
@@ -64,3 +64,11 @@ function(catch_add_sharded_tests TARGET)


 endfunction()
+
+
+###############################################################################
+
+set(_CATCH_DISCOVER_SHARD_TESTS_IMPL_SCRIPT
+    ${CMAKE_CURRENT_LIST_DIR}/CatchShardTestsImpl.cmake
+  CACHE INTERNAL "Catch2 full path to CatchShardTestsImpl.cmake helper file"
+)
--- a/extras/CatchShardTestsImpl.cmake
+++ b/extras/CatchShardTestsImpl.cmake
@@ -1,7 +1,7 @@

 #              Copyright Catch2 Authors
 # Distributed under the Boost Software License, Version 1.0.
-#   (See accompanying file LICENSE_1_0.txt or copy at
+#   (See accompanying file LICENSE.txt or copy at
 #        https://www.boost.org/LICENSE_1_0.txt)

 # SPDX-License-Identifier: BSL-1.0
--- a/extras/catch_amalgamated.cpp
+++ b/extras/catch_amalgamated.cpp
--- a/extras/catch_amalgamated.hpp
+++ b/extras/catch_amalgamated.hpp
--- a/meson.build
+++ b/meson.build
@@ -1,6 +1,6 @@
 #              Copyright Catch2 Authors
 # Distributed under the Boost Software License, Version 1.0.
-#   (See accompanying file LICENSE_1_0.txt or copy at
+#   (See accompanying file LICENSE.txt or copy at
 #        https://www.boost.org/LICENSE_1_0.txt)

 # SPDX-License-Identifier: BSL-1.0
@@ -8,9 +8,9 @@
 project(
  'catch2',
  'cpp',
-  version: '3.1.1', # CML version placeholder, don't delete
+  version: '3.3.2', # CML version placeholder, don't delete
  license: 'BSL-1.0',
-  meson_version: '>=0.49.0',
+  meson_version: '>=0.50.0',
 )

 subdir('src/catch2')
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -7,293 +7,330 @@ include(CatchMiscFunctions)
 set(Catch2_GUID_CMAKE "8d538cbe-01bf-4a2e-a98a-6c368fdf13d7" CACHE INTERNAL "Project GUID")
 set(Catch2WithMain_GUID_CMAKE "8bd3552a-2cfb-4a59-ab15-2031b97ada1e" CACHE INTERNAL "Project GUID")

-# Please keep these ordered alphabetically
 set(BENCHMARK_HEADERS
-    ${SOURCES_DIR}/benchmark/catch_benchmark.hpp
-    ${SOURCES_DIR}/benchmark/catch_benchmark_all.hpp
-    ${SOURCES_DIR}/benchmark/catch_chronometer.hpp
-    ${SOURCES_DIR}/benchmark/catch_clock.hpp
-    ${SOURCES_DIR}/benchmark/catch_constructor.hpp
-    ${SOURCES_DIR}/benchmark/catch_environment.hpp
-    ${SOURCES_DIR}/benchmark/catch_estimate.hpp
-    ${SOURCES_DIR}/benchmark/catch_execution_plan.hpp
-    ${SOURCES_DIR}/benchmark/catch_optimizer.hpp
-    ${SOURCES_DIR}/benchmark/catch_outlier_classification.hpp
-    ${SOURCES_DIR}/benchmark/catch_sample_analysis.hpp
-    ${SOURCES_DIR}/benchmark/detail/catch_analyse.hpp
-    ${SOURCES_DIR}/benchmark/detail/catch_benchmark_function.hpp
-    ${SOURCES_DIR}/benchmark/detail/catch_complete_invoke.hpp
-    ${SOURCES_DIR}/benchmark/detail/catch_estimate_clock.hpp
-    ${SOURCES_DIR}/benchmark/detail/catch_measure.hpp
-    ${SOURCES_DIR}/benchmark/detail/catch_repeat.hpp
-    ${SOURCES_DIR}/benchmark/detail/catch_run_for_at_least.hpp
-    ${SOURCES_DIR}/benchmark/detail/catch_stats.hpp
-    ${SOURCES_DIR}/benchmark/detail/catch_timing.hpp
+  ${SOURCES_DIR}/benchmark/catch_benchmark.hpp
+  ${SOURCES_DIR}/benchmark/catch_benchmark_all.hpp
+  ${SOURCES_DIR}/benchmark/catch_chronometer.hpp
+  ${SOURCES_DIR}/benchmark/catch_clock.hpp
+  ${SOURCES_DIR}/benchmark/catch_constructor.hpp
+  ${SOURCES_DIR}/benchmark/catch_environment.hpp
+  ${SOURCES_DIR}/benchmark/catch_estimate.hpp
+  ${SOURCES_DIR}/benchmark/catch_execution_plan.hpp
+  ${SOURCES_DIR}/benchmark/catch_optimizer.hpp
+  ${SOURCES_DIR}/benchmark/catch_outlier_classification.hpp
+  ${SOURCES_DIR}/benchmark/catch_sample_analysis.hpp
+  ${SOURCES_DIR}/benchmark/detail/catch_analyse.hpp
+  ${SOURCES_DIR}/benchmark/detail/catch_benchmark_function.hpp
+  ${SOURCES_DIR}/benchmark/detail/catch_complete_invoke.hpp
+  ${SOURCES_DIR}/benchmark/detail/catch_estimate_clock.hpp
+  ${SOURCES_DIR}/benchmark/detail/catch_measure.hpp
+  ${SOURCES_DIR}/benchmark/detail/catch_repeat.hpp
+  ${SOURCES_DIR}/benchmark/detail/catch_run_for_at_least.hpp
+  ${SOURCES_DIR}/benchmark/detail/catch_stats.hpp
+  ${SOURCES_DIR}/benchmark/detail/catch_timing.hpp
 )
 set(BENCHMARK_SOURCES
-    ${SOURCES_DIR}/benchmark/catch_chronometer.cpp
-    ${SOURCES_DIR}/benchmark/detail/catch_benchmark_function.cpp
-    ${SOURCES_DIR}/benchmark/detail/catch_run_for_at_least.cpp
-    ${SOURCES_DIR}/benchmark/detail/catch_stats.cpp
+  ${SOURCES_DIR}/benchmark/catch_chronometer.cpp
+  ${SOURCES_DIR}/benchmark/detail/catch_benchmark_function.cpp
+  ${SOURCES_DIR}/benchmark/detail/catch_run_for_at_least.cpp
+  ${SOURCES_DIR}/benchmark/detail/catch_stats.cpp
 )
+set(BENCHMARK_FILES ${BENCHMARK_HEADERS} ${BENCHMARK_SOURCES})

-SOURCE_GROUP("benchmark" FILES ${BENCHMARK_HEADERS} ${BENCHMARK_SOURCES})

-set(INTERNAL_HEADERS
-   "${CMAKE_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
-   "${SOURCES_DIR}/catch_user_config.hpp.in"
-    ${SOURCES_DIR}/catch_all.hpp
-    ${SOURCES_DIR}/matchers/catch_matchers_all.hpp
-    ${SOURCES_DIR}/generators/catch_generators_all.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_all.hpp
-    ${SOURCES_DIR}/matchers/internal/catch_matchers_impl.hpp
-    ${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.hpp
-    ${SOURCES_DIR}/internal/catch_console_width.hpp
-    ${SOURCES_DIR}/internal/catch_container_nonmembers.hpp
-    ${SOURCES_DIR}/internal/catch_noncopyable.hpp
-    ${SOURCES_DIR}/catch_approx.hpp
-    ${SOURCES_DIR}/internal/catch_assertion_handler.hpp
-    ${SOURCES_DIR}/catch_assertion_info.hpp
-    ${SOURCES_DIR}/catch_assertion_result.hpp
-    ${SOURCES_DIR}/internal/catch_test_macro_impl.hpp
-    ${SOURCES_DIR}/internal/catch_test_failure_exception.hpp
-    ${SOURCES_DIR}/internal/catch_case_sensitive.hpp
-    ${SOURCES_DIR}/internal/catch_clara.hpp
-    ${SOURCES_DIR}/internal/catch_commandline.hpp
-    ${SOURCES_DIR}/internal/catch_source_line_info.hpp
-    ${SOURCES_DIR}/internal/catch_compiler_capabilities.hpp
-    ${SOURCES_DIR}/catch_config.hpp
-    ${SOURCES_DIR}/internal/catch_config_android_logwrite.hpp
-    ${SOURCES_DIR}/internal/catch_config_counter.hpp
-    ${SOURCES_DIR}/internal/catch_config_uncaught_exceptions.hpp
-    ${SOURCES_DIR}/internal/catch_config_wchar.hpp
-    ${SOURCES_DIR}/internal/catch_console_colour.hpp
-    ${SOURCES_DIR}/internal/catch_context.hpp
-    ${SOURCES_DIR}/internal/catch_debug_console.hpp
-    ${SOURCES_DIR}/internal/catch_debugger.hpp
-    ${SOURCES_DIR}/internal/catch_decomposer.hpp
-    ${SOURCES_DIR}/internal/catch_enforce.hpp
-    ${SOURCES_DIR}/internal/catch_enum_values_registry.hpp
-    ${SOURCES_DIR}/internal/catch_errno_guard.hpp
-    ${SOURCES_DIR}/internal/catch_exception_translator_registry.hpp
-    ${SOURCES_DIR}/internal/catch_fatal_condition_handler.hpp
-    ${SOURCES_DIR}/internal/catch_floating_point_helpers.hpp
-    ${SOURCES_DIR}/internal/catch_istream.hpp
-    ${SOURCES_DIR}/internal/catch_unique_name.hpp
-    ${SOURCES_DIR}/internal/catch_sharding.hpp
-    ${SOURCES_DIR}/generators/catch_generator_exception.hpp
-    ${SOURCES_DIR}/generators/catch_generators.hpp
-    ${SOURCES_DIR}/generators/catch_generators_adapters.hpp
-    ${SOURCES_DIR}/generators/catch_generators_random.hpp
-    ${SOURCES_DIR}/generators/catch_generators_range.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_capture.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_config.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_enum_values_registry.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_exception.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_generatortracker.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_registry_hub.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_reporter.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_registry.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_tag_alias_registry.hpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_testcase.hpp
-    ${SOURCES_DIR}/internal/catch_lazy_expr.hpp
-    ${SOURCES_DIR}/internal/catch_leak_detector.hpp
-    ${SOURCES_DIR}/internal/catch_list.hpp
-    ${SOURCES_DIR}/matchers/catch_matchers.hpp
-    ${SOURCES_DIR}/matchers/catch_matchers_container_properties.hpp
-    ${SOURCES_DIR}/matchers/catch_matchers_contains.hpp
-    ${SOURCES_DIR}/matchers/catch_matchers_exception.hpp
-    ${SOURCES_DIR}/matchers/catch_matchers_floating_point.hpp
-    ${SOURCES_DIR}/matchers/catch_matchers_predicate.hpp
-    ${SOURCES_DIR}/matchers/catch_matchers_quantifiers.hpp
-    ${SOURCES_DIR}/matchers/catch_matchers_string.hpp
-    ${SOURCES_DIR}/matchers/catch_matchers_templated.hpp
-    ${SOURCES_DIR}/matchers/catch_matchers_vector.hpp
-    ${SOURCES_DIR}/catch_message.hpp
-    ${SOURCES_DIR}/internal/catch_message_info.hpp
-    ${SOURCES_DIR}/internal/catch_meta.hpp
-    ${SOURCES_DIR}/internal/catch_move_and_forward.hpp
-    ${SOURCES_DIR}/internal/catch_optional.hpp
-    ${SOURCES_DIR}/internal/catch_output_redirect.hpp
-    ${SOURCES_DIR}/internal/catch_platform.hpp
-    ${SOURCES_DIR}/internal/catch_polyfills.hpp
-    ${SOURCES_DIR}/internal/catch_preprocessor.hpp
-    ${SOURCES_DIR}/internal/catch_preprocessor_remove_parens.hpp
-    ${SOURCES_DIR}/internal/catch_random_number_generator.hpp
-    ${SOURCES_DIR}/internal/catch_random_seed_generation.hpp
-    ${SOURCES_DIR}/internal/catch_reporter_registry.hpp
-    ${SOURCES_DIR}/internal/catch_reporter_spec_parser.hpp
-    ${SOURCES_DIR}/internal/catch_result_type.hpp
-    ${SOURCES_DIR}/internal/catch_run_context.hpp
-    ${SOURCES_DIR}/internal/catch_section.hpp
-    ${SOURCES_DIR}/internal/catch_stdstreams.hpp
-    ${SOURCES_DIR}/catch_section_info.hpp
-    ${SOURCES_DIR}/catch_session.hpp
-    ${SOURCES_DIR}/internal/catch_singletons.hpp
-    ${SOURCES_DIR}/internal/catch_startup_exception_registry.hpp
-    ${SOURCES_DIR}/internal/catch_reusable_string_stream.hpp
-    ${SOURCES_DIR}/internal/catch_stream_end_stop.hpp
-    ${SOURCES_DIR}/internal/catch_string_manip.hpp
-    ${SOURCES_DIR}/internal/catch_stringref.hpp
-    ${SOURCES_DIR}/catch_tag_alias.hpp
-    ${SOURCES_DIR}/catch_get_random_seed.hpp
-    ${SOURCES_DIR}/catch_tag_alias_autoregistrar.hpp
-    ${SOURCES_DIR}/internal/catch_tag_alias_registry.hpp
-    ${SOURCES_DIR}/catch_test_case_info.hpp
-    ${SOURCES_DIR}/internal/catch_test_case_registry_impl.hpp
-    ${SOURCES_DIR}/internal/catch_test_case_tracker.hpp
-    ${SOURCES_DIR}/catch_template_test_macros.hpp
-    ${SOURCES_DIR}/catch_test_macros.hpp
-    ${SOURCES_DIR}/internal/catch_template_test_registry.hpp
-    ${SOURCES_DIR}/internal/catch_test_registry.hpp
-    ${SOURCES_DIR}/catch_test_spec.hpp
-    ${SOURCES_DIR}/internal/catch_test_spec_parser.hpp
-    ${SOURCES_DIR}/internal/catch_textflow.hpp
-    ${SOURCES_DIR}/catch_timer.hpp
-    ${SOURCES_DIR}/internal/catch_to_string.hpp
-    ${SOURCES_DIR}/catch_tostring.hpp
-    ${SOURCES_DIR}/catch_totals.hpp
-    ${SOURCES_DIR}/catch_translate_exception.hpp
-    ${SOURCES_DIR}/internal/catch_uncaught_exceptions.hpp
-    ${SOURCES_DIR}/internal/catch_unique_ptr.hpp
-    ${SOURCES_DIR}/internal/catch_void_type.hpp
-    ${SOURCES_DIR}/catch_version.hpp
-    ${SOURCES_DIR}/catch_version_macros.hpp
-    ${SOURCES_DIR}/internal/catch_wildcard_pattern.hpp
-    ${SOURCES_DIR}/internal/catch_windows_h_proxy.hpp
-    ${SOURCES_DIR}/internal/catch_xmlwriter.hpp
-    ${SOURCES_DIR}/internal/catch_test_case_info_hasher.hpp
+set(IMPL_HEADERS
+ "${PROJECT_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
+  ${SOURCES_DIR}/catch_user_config.hpp.in
+  ${SOURCES_DIR}/catch_all.hpp
+  ${SOURCES_DIR}/catch_approx.hpp
+  ${SOURCES_DIR}/catch_assertion_info.hpp
+  ${SOURCES_DIR}/catch_assertion_result.hpp
+  ${SOURCES_DIR}/catch_config.hpp
+  ${SOURCES_DIR}/catch_get_random_seed.hpp
+  ${SOURCES_DIR}/catch_message.hpp
+  ${SOURCES_DIR}/catch_section_info.hpp
+  ${SOURCES_DIR}/catch_session.hpp
+  ${SOURCES_DIR}/catch_tag_alias.hpp
+  ${SOURCES_DIR}/catch_tag_alias_autoregistrar.hpp
+  ${SOURCES_DIR}/catch_template_test_macros.hpp
+  ${SOURCES_DIR}/catch_test_case_info.hpp
+  ${SOURCES_DIR}/catch_test_macros.hpp
+  ${SOURCES_DIR}/catch_test_run_info.hpp
+  ${SOURCES_DIR}/catch_test_spec.hpp
+  ${SOURCES_DIR}/catch_timer.hpp
+  ${SOURCES_DIR}/catch_tostring.hpp
+  ${SOURCES_DIR}/catch_totals.hpp
+  ${SOURCES_DIR}/catch_translate_exception.hpp
+  ${SOURCES_DIR}/catch_version.hpp
+  ${SOURCES_DIR}/catch_version_macros.hpp
+  ${SOURCES_DIR}/internal/catch_assertion_handler.hpp
+  ${SOURCES_DIR}/internal/catch_benchmark_stats_fwd.hpp
+  ${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.hpp
+  ${SOURCES_DIR}/internal/catch_case_sensitive.hpp
+  ${SOURCES_DIR}/internal/catch_clara.hpp
+  ${SOURCES_DIR}/internal/catch_commandline.hpp
+  ${SOURCES_DIR}/internal/catch_compare_traits.hpp
+  ${SOURCES_DIR}/internal/catch_compiler_capabilities.hpp
+  ${SOURCES_DIR}/internal/catch_config_android_logwrite.hpp
+  ${SOURCES_DIR}/internal/catch_config_counter.hpp
+  ${SOURCES_DIR}/internal/catch_config_uncaught_exceptions.hpp
+  ${SOURCES_DIR}/internal/catch_config_wchar.hpp
+  ${SOURCES_DIR}/internal/catch_console_colour.hpp
+  ${SOURCES_DIR}/internal/catch_console_width.hpp
+  ${SOURCES_DIR}/internal/catch_container_nonmembers.hpp
+  ${SOURCES_DIR}/internal/catch_context.hpp
+  ${SOURCES_DIR}/internal/catch_debug_console.hpp
+  ${SOURCES_DIR}/internal/catch_debugger.hpp
+  ${SOURCES_DIR}/internal/catch_decomposer.hpp
+  ${SOURCES_DIR}/internal/catch_enforce.hpp
+  ${SOURCES_DIR}/internal/catch_enum_values_registry.hpp
+  ${SOURCES_DIR}/internal/catch_errno_guard.hpp
+  ${SOURCES_DIR}/internal/catch_exception_translator_registry.hpp
+  ${SOURCES_DIR}/internal/catch_fatal_condition_handler.hpp
+  ${SOURCES_DIR}/internal/catch_floating_point_helpers.hpp
+  ${SOURCES_DIR}/internal/catch_getenv.hpp
+  ${SOURCES_DIR}/internal/catch_istream.hpp
+  ${SOURCES_DIR}/internal/catch_is_permutation.hpp
+  ${SOURCES_DIR}/internal/catch_lazy_expr.hpp
+  ${SOURCES_DIR}/internal/catch_leak_detector.hpp
+  ${SOURCES_DIR}/internal/catch_list.hpp
+  ${SOURCES_DIR}/internal/catch_logical_traits.hpp
+  ${SOURCES_DIR}/internal/catch_message_info.hpp
+  ${SOURCES_DIR}/internal/catch_meta.hpp
+  ${SOURCES_DIR}/internal/catch_move_and_forward.hpp
+  ${SOURCES_DIR}/internal/catch_noncopyable.hpp
+  ${SOURCES_DIR}/internal/catch_optional.hpp
+  ${SOURCES_DIR}/internal/catch_output_redirect.hpp
+  ${SOURCES_DIR}/internal/catch_parse_numbers.hpp
+  ${SOURCES_DIR}/internal/catch_platform.hpp
+  ${SOURCES_DIR}/internal/catch_polyfills.hpp
+  ${SOURCES_DIR}/internal/catch_preprocessor.hpp
+  ${SOURCES_DIR}/internal/catch_preprocessor_remove_parens.hpp
+  ${SOURCES_DIR}/internal/catch_random_number_generator.hpp
+  ${SOURCES_DIR}/internal/catch_random_seed_generation.hpp
+  ${SOURCES_DIR}/internal/catch_registry_hub.hpp
+  ${SOURCES_DIR}/internal/catch_reporter_registry.hpp
+  ${SOURCES_DIR}/internal/catch_reporter_spec_parser.hpp
+  ${SOURCES_DIR}/internal/catch_result_type.hpp
+  ${SOURCES_DIR}/internal/catch_reusable_string_stream.hpp
+  ${SOURCES_DIR}/internal/catch_run_context.hpp
+  ${SOURCES_DIR}/internal/catch_section.hpp
+  ${SOURCES_DIR}/internal/catch_sharding.hpp
+  ${SOURCES_DIR}/internal/catch_singletons.hpp
+  ${SOURCES_DIR}/internal/catch_source_line_info.hpp
+  ${SOURCES_DIR}/internal/catch_startup_exception_registry.hpp
+  ${SOURCES_DIR}/internal/catch_stdstreams.hpp
+  ${SOURCES_DIR}/internal/catch_stream_end_stop.hpp
+  ${SOURCES_DIR}/internal/catch_string_manip.hpp
+  ${SOURCES_DIR}/internal/catch_stringref.hpp
+  ${SOURCES_DIR}/internal/catch_tag_alias_registry.hpp
+  ${SOURCES_DIR}/internal/catch_template_test_registry.hpp
+  ${SOURCES_DIR}/internal/catch_test_case_info_hasher.hpp
+  ${SOURCES_DIR}/internal/catch_test_case_registry_impl.hpp
+  ${SOURCES_DIR}/internal/catch_test_case_tracker.hpp
+  ${SOURCES_DIR}/internal/catch_test_failure_exception.hpp
+  ${SOURCES_DIR}/internal/catch_test_macro_impl.hpp
+  ${SOURCES_DIR}/internal/catch_test_registry.hpp
+  ${SOURCES_DIR}/internal/catch_test_spec_parser.hpp
+  ${SOURCES_DIR}/internal/catch_textflow.hpp
+  ${SOURCES_DIR}/internal/catch_to_string.hpp
+  ${SOURCES_DIR}/internal/catch_uncaught_exceptions.hpp
+  ${SOURCES_DIR}/internal/catch_unique_name.hpp
+  ${SOURCES_DIR}/internal/catch_unique_ptr.hpp
+  ${SOURCES_DIR}/internal/catch_void_type.hpp
+  ${SOURCES_DIR}/internal/catch_wildcard_pattern.hpp
+  ${SOURCES_DIR}/internal/catch_windows_h_proxy.hpp
+  ${SOURCES_DIR}/internal/catch_xmlwriter.hpp
 )
 set(IMPL_SOURCES
-    ${SOURCES_DIR}/catch_approx.cpp
-    ${SOURCES_DIR}/internal/catch_assertion_handler.cpp
-    ${SOURCES_DIR}/catch_assertion_result.cpp
-    ${SOURCES_DIR}/internal/catch_clara.cpp
-    ${SOURCES_DIR}/internal/catch_commandline.cpp
-    ${SOURCES_DIR}/internal/catch_source_line_info.cpp
-    ${SOURCES_DIR}/catch_config.cpp
-    ${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.cpp
-    ${SOURCES_DIR}/internal/catch_console_colour.cpp
-    ${SOURCES_DIR}/internal/catch_context.cpp
-    ${SOURCES_DIR}/internal/catch_debug_console.cpp
-    ${SOURCES_DIR}/internal/catch_debugger.cpp
-    ${SOURCES_DIR}/internal/catch_enforce.cpp
-    ${SOURCES_DIR}/internal/catch_enum_values_registry.cpp
-    ${SOURCES_DIR}/internal/catch_exception_translator_registry.cpp
-    ${SOURCES_DIR}/internal/catch_fatal_condition_handler.cpp
-    ${SOURCES_DIR}/internal/catch_floating_point_helpers.cpp
-    ${SOURCES_DIR}/internal/catch_istream.cpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_generatortracker.cpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_reporter.cpp
-    ${SOURCES_DIR}/internal/catch_list.cpp
-    ${SOURCES_DIR}/matchers/catch_matchers_floating_point.cpp
-    ${SOURCES_DIR}/matchers/catch_matchers_quantifiers.cpp
-    ${SOURCES_DIR}/matchers/catch_matchers_string.cpp
-    ${SOURCES_DIR}/matchers/catch_matchers_templated.cpp
-    ${SOURCES_DIR}/catch_message.cpp
-    ${SOURCES_DIR}/internal/catch_output_redirect.cpp
-    ${SOURCES_DIR}/catch_registry_hub.cpp
-    ${SOURCES_DIR}/internal/catch_random_number_generator.cpp
-    ${SOURCES_DIR}/internal/catch_random_seed_generation.cpp
-    ${SOURCES_DIR}/internal/catch_reporter_registry.cpp
-    ${SOURCES_DIR}/internal/catch_reporter_spec_parser.cpp
-    ${SOURCES_DIR}/internal/catch_result_type.cpp
-    ${SOURCES_DIR}/internal/catch_run_context.cpp
-    ${SOURCES_DIR}/internal/catch_section.cpp
-    ${SOURCES_DIR}/internal/catch_stdstreams.cpp
-    ${SOURCES_DIR}/catch_session.cpp
-    ${SOURCES_DIR}/internal/catch_singletons.cpp
-    ${SOURCES_DIR}/internal/catch_reusable_string_stream.cpp
-    ${SOURCES_DIR}/internal/catch_stringref.cpp
-    ${SOURCES_DIR}/internal/catch_string_manip.cpp
-    ${SOURCES_DIR}/internal/catch_tag_alias_registry.cpp
-    ${SOURCES_DIR}/catch_test_case_info.cpp
-    ${SOURCES_DIR}/internal/catch_test_case_registry_impl.cpp
-    ${SOURCES_DIR}/internal/catch_test_case_tracker.cpp
-    ${SOURCES_DIR}/internal/catch_test_registry.cpp
-    ${SOURCES_DIR}/internal/catch_textflow.cpp
-    ${SOURCES_DIR}/catch_test_spec.cpp
-    ${SOURCES_DIR}/internal/catch_test_spec_parser.cpp
-    ${SOURCES_DIR}/catch_timer.cpp
-    ${SOURCES_DIR}/catch_tostring.cpp
-    ${SOURCES_DIR}/catch_totals.cpp
-    ${SOURCES_DIR}/catch_version.cpp
-    ${SOURCES_DIR}/internal/catch_wildcard_pattern.cpp
-    ${SOURCES_DIR}/internal/catch_xmlwriter.cpp
-    ${SOURCES_DIR}/internal/catch_test_case_info_hasher.cpp
-    ${SOURCES_DIR}/generators/catch_generators_random.cpp
-    ${SOURCES_DIR}/generators/catch_generator_exception.cpp
-    ${SOURCES_DIR}/generators/catch_generators.cpp
-    ${SOURCES_DIR}/matchers/catch_matchers.cpp
-    ${SOURCES_DIR}/matchers/catch_matchers_container_properties.cpp
-    ${SOURCES_DIR}/matchers/catch_matchers_exception.cpp
-    ${SOURCES_DIR}/matchers/catch_matchers_predicate.cpp
-    ${SOURCES_DIR}/matchers/internal/catch_matchers_impl.cpp
-    ${SOURCES_DIR}/catch_tag_alias_autoregistrar.cpp
-    ${SOURCES_DIR}/catch_get_random_seed.cpp
-    ${SOURCES_DIR}/internal/catch_decomposer.cpp
-    ${SOURCES_DIR}/internal/catch_errno_guard.cpp
-    ${SOURCES_DIR}/internal/catch_lazy_expr.cpp
-    ${SOURCES_DIR}/internal/catch_leak_detector.cpp
-    ${SOURCES_DIR}/internal/catch_message_info.cpp
-    ${SOURCES_DIR}/internal/catch_polyfills.cpp
-    ${SOURCES_DIR}/internal/catch_startup_exception_registry.cpp
-    ${SOURCES_DIR}/internal/catch_uncaught_exceptions.cpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_capture.cpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_config.cpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_exception.cpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_registry_hub.cpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.cpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_registry.cpp
-    ${SOURCES_DIR}/interfaces/catch_interfaces_testcase.cpp
+  ${SOURCES_DIR}/catch_approx.cpp
+  ${SOURCES_DIR}/catch_assertion_result.cpp
+  ${SOURCES_DIR}/catch_config.cpp
+  ${SOURCES_DIR}/catch_get_random_seed.cpp
+  ${SOURCES_DIR}/catch_message.cpp
+  ${SOURCES_DIR}/catch_session.cpp
+  ${SOURCES_DIR}/catch_tag_alias_autoregistrar.cpp
+  ${SOURCES_DIR}/catch_test_case_info.cpp
+  ${SOURCES_DIR}/catch_test_spec.cpp
+  ${SOURCES_DIR}/catch_timer.cpp
+  ${SOURCES_DIR}/catch_tostring.cpp
+  ${SOURCES_DIR}/catch_totals.cpp
+  ${SOURCES_DIR}/catch_translate_exception.cpp
+  ${SOURCES_DIR}/catch_version.cpp
+  ${SOURCES_DIR}/internal/catch_assertion_handler.cpp
+  ${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.cpp
+  ${SOURCES_DIR}/internal/catch_clara.cpp
+  ${SOURCES_DIR}/internal/catch_commandline.cpp
+  ${SOURCES_DIR}/internal/catch_console_colour.cpp
+  ${SOURCES_DIR}/internal/catch_context.cpp
+  ${SOURCES_DIR}/internal/catch_debug_console.cpp
+  ${SOURCES_DIR}/internal/catch_debugger.cpp
+  ${SOURCES_DIR}/internal/catch_decomposer.cpp
+  ${SOURCES_DIR}/internal/catch_enforce.cpp
+  ${SOURCES_DIR}/internal/catch_enum_values_registry.cpp
+  ${SOURCES_DIR}/internal/catch_errno_guard.cpp
+  ${SOURCES_DIR}/internal/catch_exception_translator_registry.cpp
+  ${SOURCES_DIR}/internal/catch_fatal_condition_handler.cpp
+  ${SOURCES_DIR}/internal/catch_floating_point_helpers.cpp
+  ${SOURCES_DIR}/internal/catch_getenv.cpp
+  ${SOURCES_DIR}/internal/catch_istream.cpp
+  ${SOURCES_DIR}/internal/catch_lazy_expr.cpp
+  ${SOURCES_DIR}/internal/catch_leak_detector.cpp
+  ${SOURCES_DIR}/internal/catch_list.cpp
+  ${SOURCES_DIR}/internal/catch_message_info.cpp
+  ${SOURCES_DIR}/internal/catch_output_redirect.cpp
+  ${SOURCES_DIR}/internal/catch_parse_numbers.cpp
+  ${SOURCES_DIR}/internal/catch_polyfills.cpp
+  ${SOURCES_DIR}/internal/catch_random_number_generator.cpp
+  ${SOURCES_DIR}/internal/catch_random_seed_generation.cpp
+  ${SOURCES_DIR}/internal/catch_registry_hub.cpp
+  ${SOURCES_DIR}/internal/catch_reporter_registry.cpp
+  ${SOURCES_DIR}/internal/catch_reporter_spec_parser.cpp
+  ${SOURCES_DIR}/internal/catch_result_type.cpp
+  ${SOURCES_DIR}/internal/catch_reusable_string_stream.cpp
+  ${SOURCES_DIR}/internal/catch_run_context.cpp
+  ${SOURCES_DIR}/internal/catch_section.cpp
+  ${SOURCES_DIR}/internal/catch_singletons.cpp
+  ${SOURCES_DIR}/internal/catch_source_line_info.cpp
+  ${SOURCES_DIR}/internal/catch_startup_exception_registry.cpp
+  ${SOURCES_DIR}/internal/catch_stdstreams.cpp
+  ${SOURCES_DIR}/internal/catch_string_manip.cpp
+  ${SOURCES_DIR}/internal/catch_stringref.cpp
+  ${SOURCES_DIR}/internal/catch_tag_alias_registry.cpp
+  ${SOURCES_DIR}/internal/catch_test_case_info_hasher.cpp
+  ${SOURCES_DIR}/internal/catch_test_case_registry_impl.cpp
+  ${SOURCES_DIR}/internal/catch_test_case_tracker.cpp
+  ${SOURCES_DIR}/internal/catch_test_failure_exception.cpp
+  ${SOURCES_DIR}/internal/catch_test_registry.cpp
+  ${SOURCES_DIR}/internal/catch_test_spec_parser.cpp
+  ${SOURCES_DIR}/internal/catch_textflow.cpp
+  ${SOURCES_DIR}/internal/catch_uncaught_exceptions.cpp
+  ${SOURCES_DIR}/internal/catch_wildcard_pattern.cpp
+  ${SOURCES_DIR}/internal/catch_xmlwriter.cpp
 )
-set(INTERNAL_FILES ${IMPL_SOURCES} ${INTERNAL_HEADERS})
+set(INTERNAL_FILES ${IMPL_SOURCES} ${IMPL_HEADERS})
+
+set(INTERFACE_HEADERS
+  ${SOURCES_DIR}/interfaces/catch_interfaces_all.hpp
+  ${SOURCES_DIR}/interfaces/catch_interfaces_config.hpp
+  ${SOURCES_DIR}/interfaces/catch_interfaces_exception.hpp
+  ${SOURCES_DIR}/interfaces/catch_interfaces_generatortracker.hpp
+  ${SOURCES_DIR}/interfaces/catch_interfaces_reporter.hpp
+  ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.hpp
+  ${SOURCES_DIR}/interfaces/catch_interfaces_testcase.hpp
+)
+set(INTERFACE_SOURCES
+  ${SOURCES_DIR}/interfaces/catch_interfaces_config.cpp
+  ${SOURCES_DIR}/interfaces/catch_interfaces_exception.cpp
+  ${SOURCES_DIR}/interfaces/catch_interfaces_generatortracker.cpp
+  ${SOURCES_DIR}/interfaces/catch_interfaces_reporter.cpp
+  ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.cpp
+  ${SOURCES_DIR}/interfaces/catch_interfaces_testcase.cpp
+)
+set(INTERFACE_FILES ${INTERFACE_HEADERS} ${INTERFACE_SOURCES})
+
+set(GENERATOR_HEADERS
+  ${SOURCES_DIR}/generators/catch_generator_exception.hpp
+  ${SOURCES_DIR}/generators/catch_generators.hpp
+  ${SOURCES_DIR}/generators/catch_generators_adapters.hpp
+  ${SOURCES_DIR}/generators/catch_generators_all.hpp
+  ${SOURCES_DIR}/generators/catch_generators_random.hpp
+  ${SOURCES_DIR}/generators/catch_generators_range.hpp
+)
+set(GENERATOR_SOURCES
+  ${SOURCES_DIR}/generators/catch_generator_exception.cpp
+  ${SOURCES_DIR}/generators/catch_generators.cpp
+  ${SOURCES_DIR}/generators/catch_generators_random.cpp
+)
+set(GENERATOR_FILES ${GENERATOR_HEADERS} ${GENERATOR_SOURCES})
+
+set(MATCHER_HEADERS
+  ${SOURCES_DIR}/matchers/catch_matchers.hpp
+  ${SOURCES_DIR}/matchers/catch_matchers_all.hpp
+  ${SOURCES_DIR}/matchers/catch_matchers_container_properties.hpp
+  ${SOURCES_DIR}/matchers/catch_matchers_contains.hpp
+  ${SOURCES_DIR}/matchers/catch_matchers_range_equals.hpp
+  ${SOURCES_DIR}/matchers/catch_matchers_exception.hpp
+  ${SOURCES_DIR}/matchers/catch_matchers_floating_point.hpp
+  ${SOURCES_DIR}/matchers/catch_matchers_predicate.hpp
+  ${SOURCES_DIR}/matchers/catch_matchers_quantifiers.hpp
+  ${SOURCES_DIR}/matchers/catch_matchers_string.hpp
+  ${SOURCES_DIR}/matchers/catch_matchers_templated.hpp
+  ${SOURCES_DIR}/matchers/catch_matchers_vector.hpp
+  ${SOURCES_DIR}/matchers/internal/catch_matchers_impl.hpp
+)
+set(MATCHER_SOURCES
+  ${SOURCES_DIR}/matchers/catch_matchers.cpp
+  ${SOURCES_DIR}/matchers/catch_matchers_container_properties.cpp
+  ${SOURCES_DIR}/matchers/catch_matchers_exception.cpp
+  ${SOURCES_DIR}/matchers/catch_matchers_floating_point.cpp
+  ${SOURCES_DIR}/matchers/catch_matchers_predicate.cpp
+  ${SOURCES_DIR}/matchers/catch_matchers_quantifiers.cpp
+  ${SOURCES_DIR}/matchers/catch_matchers_string.cpp
+  ${SOURCES_DIR}/matchers/catch_matchers_templated.cpp
+  ${SOURCES_DIR}/matchers/internal/catch_matchers_impl.cpp
+)
+set(MATCHER_FILES ${MATCHER_HEADERS} ${MATCHER_SOURCES})

-# Please keep these ordered alphabetically
 set(REPORTER_HEADERS
-    ${SOURCES_DIR}/reporters/catch_reporters_all.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_automake.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_common_base.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_compact.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_console.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_event_listener.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_helpers.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_junit.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_multi.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_registrars.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_sonarqube.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_streaming_base.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_tap.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_teamcity.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_xml.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_automake.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_common_base.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_compact.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_console.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_event_listener.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_helpers.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_junit.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_multi.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_registrars.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_sonarqube.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_streaming_base.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_tap.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_teamcity.hpp
+  ${SOURCES_DIR}/reporters/catch_reporter_xml.hpp
+  ${SOURCES_DIR}/reporters/catch_reporters_all.hpp
 )
 set(REPORTER_SOURCES
-    ${SOURCES_DIR}/reporters/catch_reporter_automake.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_common_base.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_compact.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_console.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_event_listener.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_helpers.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_junit.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_multi.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_registrars.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_sonarqube.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_streaming_base.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_tap.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_teamcity.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_xml.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_automake.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_common_base.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_compact.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_console.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_event_listener.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_helpers.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_junit.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_multi.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_registrars.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_sonarqube.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_streaming_base.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_tap.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_teamcity.cpp
+  ${SOURCES_DIR}/reporters/catch_reporter_xml.cpp
 )
 set(REPORTER_FILES ${REPORTER_HEADERS} ${REPORTER_SOURCES})

-add_library(Catch2
+set(ALL_FILES
+  ${BENCHMARK_FILES}
+  ${GENERATOR_FILES}
  ${REPORTER_FILES}
+  ${INTERFACE_FILES}
  ${INTERNAL_FILES}
-  ${BENCHMARK_HEADERS}
-  ${BENCHMARK_SOURCES}
+  ${MATCHER_FILES}
 )
+
+set(FILTERED_FILES ${ALL_FILES})
+list(REMOVE_ITEM FILTERED_FILES "${PROJECT_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp")
+source_group(
+  TREE ${SOURCES_DIR}
+  PREFIX sources
+  FILES ${FILTERED_FILES}
+)
+source_group("generated headers"
+  FILES
+    "${PROJECT_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
+)
+
+add_library(Catch2 ${ALL_FILES})
 add_build_reproducibility_settings(Catch2)
 add_library(Catch2::Catch2 ALIAS Catch2)

@@ -301,7 +338,7 @@ if (ANDROID)
    target_link_libraries(Catch2 INTERFACE log)
 endif()

-set_target_properties(Catch2 PROPERTIES 
+set_target_properties(Catch2 PROPERTIES
                          DEBUG_POSTFIX "d"
                                VERSION ${PROJECT_VERSION}
                              SOVERSION ${PROJECT_VERSION})
@@ -333,13 +370,13 @@ target_compile_features(Catch2

 configure_file(
  "${SOURCES_DIR}/catch_user_config.hpp.in"
-  "${CMAKE_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
+  "${PROJECT_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
 )

 target_include_directories(Catch2
  PUBLIC
    $<BUILD_INTERFACE:${SOURCES_DIR}/..>
-    $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/generated-includes>
+    $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/generated-includes>
    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )

@@ -366,7 +403,7 @@ if (NOT_SUBPROJECT)
        Catch2WithMain
      EXPORT
        Catch2Targets
-      LIBRARY DESTINATION 
+      LIBRARY DESTINATION
        ${CMAKE_INSTALL_LIBDIR}
      ARCHIVE DESTINATION
        ${CMAKE_INSTALL_LIBDIR}
@@ -387,7 +424,7 @@ if (NOT_SUBPROJECT)
    install(
      DIRECTORY
        "${SOURCES_DIR}"
-        "${CMAKE_BINARY_DIR}/generated-includes/catch2" # Also install the generated header
+        "${PROJECT_BINARY_DIR}/generated-includes/catch2" # Also install the generated header
      DESTINATION
        "${CMAKE_INSTALL_INCLUDEDIR}"
      FILES_MATCHING
@@ -401,17 +438,14 @@ endif()
 if (CATCH_BUILD_EXAMPLES OR CATCH_BUILD_EXTRA_TESTS)
    add_library(Catch2_buildall_interface INTERFACE)
    target_sources(Catch2_buildall_interface INTERFACE
-      ${REPORTER_FILES}
-      ${INTERNAL_FILES}
-      ${BENCHMARK_HEADERS}
-      ${BENCHMARK_SOURCES}
+      ${ALL_FILES}
      # Also include main entry point
      ${SOURCES_DIR}/internal/catch_main.cpp
    )
    target_include_directories(Catch2_buildall_interface
      INTERFACE
        $<BUILD_INTERFACE:${SOURCES_DIR}/..>
-        $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/generated-includes>
+        $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/generated-includes>
        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
    )
    target_compile_definitions(Catch2_buildall_interface
@@ -451,12 +485,10 @@ set(CATCH_WARNING_TARGETS ${CATCH_WARNING_TARGETS} PARENT_SCOPE)
 # so we want to check & warn users if they do this. However, we won't abort
 # the configuration step so that we don't have to also provide an override.
 if (BUILD_SHARED_LIBS)
-    if (MSVC)
-        set_target_properties(Catch2 Catch2WithMain
-          PROPERTIES
-            WINDOWS_EXPORT_ALL_SYMBOLS ON
-        )
-    endif()
+    set_target_properties(Catch2 Catch2WithMain
+      PROPERTIES
+        WINDOWS_EXPORT_ALL_SYMBOLS ON
+    )

    get_target_property(_VisPreset Catch2 CXX_VISIBILITY_PRESET)
    if (NOT MSVC AND _VisPreset STREQUAL "hidden")
--- a/src/catch2/benchmark/catch_benchmark.hpp
+++ b/src/catch2/benchmark/catch_benchmark.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -11,9 +11,11 @@
 #define CATCH_BENCHMARK_HPP_INCLUDED

 #include <catch2/interfaces/catch_interfaces_config.hpp>
+#include <catch2/interfaces/catch_interfaces_reporter.hpp>
 #include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_context.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter.hpp>
+#include <catch2/internal/catch_run_context.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 #include <catch2/internal/catch_unique_name.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 #include <catch2/benchmark/catch_chronometer.hpp>
@@ -26,6 +28,7 @@
 #include <catch2/benchmark/detail/catch_benchmark_function.hpp>
 #include <catch2/benchmark/detail/catch_run_for_at_least.hpp>

+
 #include <algorithm>
 #include <functional>
 #include <string>
@@ -64,7 +67,7 @@ namespace Catch {
                    });

                    BenchmarkInfo info {
-                        name,
+                        CATCH_MOVE(name),
                        plan.estimated_duration.count(),
                        plan.iterations_per_sample,
                        cfg->benchmarkSamples(),
@@ -80,7 +83,7 @@ namespace Catch {
                    });

                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
-                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    BenchmarkStats<FloatDuration<Clock>> stats{ CATCH_MOVE(info), CATCH_MOVE(analysis.samples), analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
                    getResultCapture().benchmarkEnded(stats);
                } CATCH_CATCH_ANON (TestFailureException) {
                    getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr);
--- a/src/catch2/benchmark/catch_benchmark_all.hpp
+++ b/src/catch2/benchmark/catch_benchmark_all.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/catch_chronometer.cpp
+++ b/src/catch2/benchmark/catch_chronometer.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/catch_chronometer.hpp
+++ b/src/catch2/benchmark/catch_chronometer.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/catch_clock.hpp
+++ b/src/catch2/benchmark/catch_clock.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/catch_constructor.hpp
+++ b/src/catch2/benchmark/catch_constructor.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/catch_environment.hpp
+++ b/src/catch2/benchmark/catch_environment.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/catch_estimate.hpp
+++ b/src/catch2/benchmark/catch_estimate.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/catch_execution_plan.hpp
+++ b/src/catch2/benchmark/catch_execution_plan.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/catch_optimizer.hpp
+++ b/src/catch2/benchmark/catch_optimizer.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -10,7 +10,7 @@
 #ifndef CATCH_OPTIMIZER_HPP_INCLUDED
 #define CATCH_OPTIMIZER_HPP_INCLUDED

-#if defined(_MSC_VER)
+#if defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
 #   include <atomic> // atomic_thread_fence
 #endif

@@ -32,16 +32,23 @@ namespace Catch {
        namespace Detail {
            inline void optimizer_barrier() { keep_memory(); }
        } // namespace Detail
-#elif defined(_MSC_VER)
+#elif defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)

+#if defined(_MSVC_VER)
 #pragma optimize("", off)
+#elif defined(__IAR_SYSTEMS_ICC__)
+// For IAR the pragma only affects the following function
+#pragma optimize=disable
+#endif
        template <typename T>
        inline void keep_memory(T* p) {
            // thanks @milleniumbug
            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
        }
        // TODO equivalent keep_memory()
+#if defined(_MSVC_VER)
 #pragma optimize("", on)
+#endif

        namespace Detail {
            inline void optimizer_barrier() {
--- a/src/catch2/benchmark/catch_outlier_classification.hpp
+++ b/src/catch2/benchmark/catch_outlier_classification.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/catch_sample_analysis.hpp
+++ b/src/catch2/benchmark/catch_sample_analysis.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/detail/catch_analyse.hpp
+++ b/src/catch2/benchmark/detail/catch_analyse.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/detail/catch_benchmark_function.cpp
+++ b/src/catch2/benchmark/detail/catch_benchmark_function.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/detail/catch_benchmark_function.hpp
+++ b/src/catch2/benchmark/detail/catch_benchmark_function.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/detail/catch_complete_invoke.hpp
+++ b/src/catch2/benchmark/detail/catch_complete_invoke.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -12,8 +12,6 @@

 #include <catch2/internal/catch_test_failure_exception.hpp>
 #include <catch2/internal/catch_meta.hpp>
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>

 #include <type_traits>
--- a/src/catch2/benchmark/detail/catch_estimate_clock.hpp
+++ b/src/catch2/benchmark/detail/catch_estimate_clock.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/detail/catch_measure.hpp
+++ b/src/catch2/benchmark/detail/catch_measure.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/detail/catch_repeat.hpp
+++ b/src/catch2/benchmark/detail/catch_repeat.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/detail/catch_run_for_at_least.cpp
+++ b/src/catch2/benchmark/detail/catch_run_for_at_least.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/detail/catch_run_for_at_least.hpp
+++ b/src/catch2/benchmark/detail/catch_run_for_at_least.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/detail/catch_stats.cpp
+++ b/src/catch2/benchmark/detail/catch_stats.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/detail/catch_stats.hpp
+++ b/src/catch2/benchmark/detail/catch_stats.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/benchmark/detail/catch_timing.hpp
+++ b/src/catch2/benchmark/detail/catch_timing.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_all.hpp
+++ b/src/catch2/catch_all.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -36,6 +36,7 @@
 #include <catch2/catch_template_test_macros.hpp>
 #include <catch2/catch_test_case_info.hpp>
 #include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_test_run_info.hpp>
 #include <catch2/catch_test_spec.hpp>
 #include <catch2/catch_timer.hpp>
 #include <catch2/catch_tostring.hpp>
@@ -46,10 +47,12 @@
 #include <catch2/generators/catch_generators_all.hpp>
 #include <catch2/interfaces/catch_interfaces_all.hpp>
 #include <catch2/internal/catch_assertion_handler.hpp>
+#include <catch2/internal/catch_benchmark_stats_fwd.hpp>
 #include <catch2/internal/catch_case_insensitive_comparisons.hpp>
 #include <catch2/internal/catch_case_sensitive.hpp>
 #include <catch2/internal/catch_clara.hpp>
 #include <catch2/internal/catch_commandline.hpp>
+#include <catch2/internal/catch_compare_traits.hpp>
 #include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_config_android_logwrite.hpp>
 #include <catch2/internal/catch_config_counter.hpp>
@@ -68,22 +71,27 @@
 #include <catch2/internal/catch_exception_translator_registry.hpp>
 #include <catch2/internal/catch_fatal_condition_handler.hpp>
 #include <catch2/internal/catch_floating_point_helpers.hpp>
+#include <catch2/internal/catch_getenv.hpp>
+#include <catch2/internal/catch_is_permutation.hpp>
 #include <catch2/internal/catch_istream.hpp>
 #include <catch2/internal/catch_lazy_expr.hpp>
 #include <catch2/internal/catch_leak_detector.hpp>
 #include <catch2/internal/catch_list.hpp>
+#include <catch2/internal/catch_logical_traits.hpp>
 #include <catch2/internal/catch_message_info.hpp>
 #include <catch2/internal/catch_meta.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 #include <catch2/internal/catch_noncopyable.hpp>
 #include <catch2/internal/catch_optional.hpp>
 #include <catch2/internal/catch_output_redirect.hpp>
+#include <catch2/internal/catch_parse_numbers.hpp>
 #include <catch2/internal/catch_platform.hpp>
 #include <catch2/internal/catch_polyfills.hpp>
 #include <catch2/internal/catch_preprocessor.hpp>
 #include <catch2/internal/catch_preprocessor_remove_parens.hpp>
 #include <catch2/internal/catch_random_number_generator.hpp>
 #include <catch2/internal/catch_random_seed_generation.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 #include <catch2/internal/catch_reporter_registry.hpp>
 #include <catch2/internal/catch_reporter_spec_parser.hpp>
 #include <catch2/internal/catch_result_type.hpp>
--- a/src/catch2/catch_approx.cpp
+++ b/src/catch2/catch_approx.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_approx.hpp
+++ b/src/catch2/catch_approx.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_assertion_info.hpp
+++ b/src/catch2/catch_assertion_info.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_assertion_result.cpp
+++ b/src/catch2/catch_assertion_result.cpp
@@ -1,12 +1,13 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/catch_assertion_result.hpp>
 #include <catch2/internal/catch_reusable_string_stream.hpp>
+#include <catch2/internal/catch_move_and_forward.hpp>

 namespace Catch {

@@ -26,9 +27,9 @@ namespace Catch {
        return reconstructedExpression;
    }

-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data )
    :   m_info( info ),
-        m_resultData( data )
+        m_resultData( CATCH_MOVE(data) )
    {}

    // Result was a success
@@ -67,16 +68,15 @@ namespace Catch {
    }

    std::string AssertionResult::getExpressionInMacro() const {
-        std::string expr;
-        if( m_info.macroName.empty() )
-            expr = static_cast<std::string>(m_info.capturedExpression);
-        else {
-            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
-            expr += m_info.macroName;
-            expr += "( ";
-            expr += m_info.capturedExpression;
-            expr += " )";
+        if ( m_info.macroName.empty() ) {
+            return static_cast<std::string>( m_info.capturedExpression );
        }
+        std::string expr;
+        expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+        expr += m_info.macroName;
+        expr += "( ";
+        expr += m_info.capturedExpression;
+        expr += " )";
        return expr;
    }

--- a/src/catch2/catch_assertion_result.hpp
+++ b/src/catch2/catch_assertion_result.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -35,7 +35,7 @@ namespace Catch {
    class AssertionResult {
    public:
        AssertionResult() = delete;
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+        AssertionResult( AssertionInfo const& info, AssertionResultData&& data );

        bool isOk() const;
        bool succeeded() const;
--- a/src/catch2/catch_config.cpp
+++ b/src/catch2/catch_config.cpp
@@ -1,46 +1,89 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/catch_config.hpp>
 #include <catch2/catch_user_config.hpp>
 #include <catch2/internal/catch_enforce.hpp>
-#include <catch2/internal/catch_platform.hpp>
+#include <catch2/internal/catch_parse_numbers.hpp>
+#include <catch2/internal/catch_stdstreams.hpp>
 #include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_string_manip.hpp>
 #include <catch2/internal/catch_test_spec_parser.hpp>
-#include <catch2/interfaces/catch_interfaces_tag_alias_registry.hpp>
+#include <catch2/internal/catch_tag_alias_registry.hpp>
+#include <catch2/internal/catch_getenv.hpp>

-namespace {
-    bool provideBazelReporterOutput() {
-#if defined(CATCH_CONFIG_BAZEL_SUPPORT)
-        return true;
-#elif defined(CATCH_PLATFORM_WINDOWS_UWP)
-        // UWP does not support environment variables
-        return false;
-#else
-
-#    if defined( _MSC_VER )
-        // On Windows getenv throws a warning as there is no input validation,
-        // since the switch is hardcoded, this should not be an issue.
-#        pragma warning( push )
-#        pragma warning( disable : 4996 )
-#    endif
-
-        return std::getenv( "BAZEL_TEST" ) != nullptr;
-
-#    if defined( _MSC_VER )
-#        pragma warning( pop )
-#    endif
-#endif
-    }
-}
+#include <fstream>

 namespace Catch {

+    namespace {
+        static bool enableBazelEnvSupport() {
+#if defined( CATCH_CONFIG_BAZEL_SUPPORT )
+            return true;
+#else
+            return Detail::getEnv( "BAZEL_TEST" ) != nullptr;
+#endif
+        }
+
+        struct bazelShardingOptions {
+            unsigned int shardIndex, shardCount;
+            std::string shardFilePath;
+        };
+
+        static Optional<bazelShardingOptions> readBazelShardingOptions() {
+            const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" );
+            const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" );
+            const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );
+
+
+            const bool has_all =
+                bazelShardIndex && bazelShardTotal && bazelShardInfoFile;
+            if ( !has_all ) {
+                // We provide nice warning message if the input is
+                // misconfigured.
+                auto warn = []( const char* env_var ) {
+                    Catch::cerr()
+                        << "Warning: Bazel shard configuration is missing '"
+                        << env_var << "'. Shard configuration is skipped.\n";
+                };
+                if ( !bazelShardIndex ) {
+                    warn( "TEST_SHARD_INDEX" );
+                }
+                if ( !bazelShardTotal ) {
+                    warn( "TEST_TOTAL_SHARDS" );
+                }
+                if ( !bazelShardInfoFile ) {
+                    warn( "TEST_SHARD_STATUS_FILE" );
+                }
+                return {};
+            }
+
+            auto shardIndex = parseUInt( bazelShardIndex );
+            if ( !shardIndex ) {
+                Catch::cerr()
+                    << "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex
+                    << "') as unsigned int.\n";
+                return {};
+            }
+            auto shardTotal = parseUInt( bazelShardTotal );
+            if ( !shardTotal ) {
+                Catch::cerr()
+                    << "Warning: could not parse 'TEST_TOTAL_SHARD' ('"
+                    << bazelShardTotal << "') as unsigned int.\n";
+                return {};
+            }
+
+            return bazelShardingOptions{
+                *shardIndex, *shardTotal, bazelShardInfoFile };
+
+        }
+    } // end namespace
+
+
    bool operator==( ProcessedReporterSpec const& lhs,
                     ProcessedReporterSpec const& rhs ) {
        return lhs.name == rhs.name &&
@@ -62,17 +105,6 @@ namespace Catch {
            elem = trim(elem);
        }

-
-        TestSpecParser parser(ITagAliasRegistry::get());
-        if (!m_data.testsOrTags.empty()) {
-            m_hasTestFilters = true;
-            for (auto const& testOrTags : m_data.testsOrTags) {
-                parser.parse(testOrTags);
-            }
-        }
-        m_testSpec = parser.testSpec();
-
-
        // Insert the default reporter if user hasn't asked for a specfic one
        if ( m_data.reporterSpecifications.empty() ) {
            m_data.reporterSpecifications.push_back( {
@@ -85,29 +117,21 @@ namespace Catch {
            } );
        }

-#if !defined(CATCH_PLATFORM_WINDOWS_UWP)
-    if(provideBazelReporterOutput()){
-            // Register a JUnit reporter for Bazel. Bazel sets an environment
-            // variable with the path to XML output. If this file is written to
-            // during test, Bazel will not generate a default XML output.
-            // This allows the XML output file to contain higher level of detail
-            // than what is possible otherwise.
-#    if defined( _MSC_VER )
-            // On Windows getenv throws a warning as there is no input validation,
-            // since the key is hardcoded, this should not be an issue.
-#           pragma warning( push )
-#           pragma warning( disable : 4996 )
-#    endif
-            const auto bazelOutputFilePtr = std::getenv( "XML_OUTPUT_FILE" );
-#    if defined( _MSC_VER )
-#        pragma warning( pop )
-#    endif
-            if ( bazelOutputFilePtr != nullptr ) {
-                m_data.reporterSpecifications.push_back(
-                    { "junit", std::string( bazelOutputFilePtr ), {}, {} } );
+        if ( enableBazelEnvSupport() ) {
+            readBazelEnvVars();
+        }
+
+        // Bazel support can modify the test specs, so parsing has to happen
+        // after reading Bazel env vars.
+        TestSpecParser parser( TagAliasRegistry::get() );
+        if ( !m_data.testsOrTags.empty() ) {
+            m_hasTestFilters = true;
+            for ( auto const& testOrTags : m_data.testsOrTags ) {
+                parser.parse( testOrTags );
            }
-    }
-#endif
+        }
+        m_testSpec = parser.testSpec();
+

        // We now fixup the reporter specs to handle default output spec,
        // default colour spec, etc
@@ -187,4 +211,37 @@ namespace Catch {
    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }

+    void Config::readBazelEnvVars() {
+        // Register a JUnit reporter for Bazel. Bazel sets an environment
+        // variable with the path to XML output. If this file is written to
+        // during test, Bazel will not generate a default XML output.
+        // This allows the XML output file to contain higher level of detail
+        // than what is possible otherwise.
+        const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" );
+
+        if ( bazelOutputFile ) {
+            m_data.reporterSpecifications.push_back(
+                { "junit", std::string( bazelOutputFile ), {}, {} } );
+        }
+
+        const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" );
+        if ( bazelTestSpec ) {
+            // Presumably the test spec from environment should overwrite
+            // the one we got from CLI (if we got any)
+            m_data.testsOrTags.clear();
+            m_data.testsOrTags.push_back( bazelTestSpec );
+        }
+
+        const auto bazelShardOptions = readBazelShardingOptions();
+        if ( bazelShardOptions ) {
+            std::ofstream f( bazelShardOptions->shardFilePath,
+                             std::ios_base::out | std::ios_base::trunc );
+            if ( f.is_open() ) {
+                f << "";
+                m_data.shardIndex = bazelShardOptions->shardIndex;
+                m_data.shardCount = bazelShardOptions->shardCount;
+            }
+        }
+    }
+
 } // end namespace Catch
--- a/src/catch2/catch_config.hpp
+++ b/src/catch2/catch_config.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -140,6 +140,9 @@ namespace Catch {
        std::chrono::milliseconds benchmarkWarmupTime() const override;

    private:
+        // Reads Bazel env vars and applies them to the config
+        void readBazelEnvVars();
+
        ConfigData m_data;
        std::vector<ProcessedReporterSpec> m_processedReporterSpecs;
        TestSpec m_testSpec;
--- a/src/catch2/catch_get_random_seed.cpp
+++ b/src/catch2/catch_get_random_seed.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_get_random_seed.hpp
+++ b/src/catch2/catch_get_random_seed.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_message.cpp
+++ b/src/catch2/catch_message.cpp
@@ -1,15 +1,15 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/catch_message.hpp>
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
 #include <catch2/internal/catch_uncaught_exceptions.hpp>
 #include <catch2/internal/catch_enforce.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/internal/catch_run_context.hpp>

 #include <cassert>
 #include <stack>
@@ -19,8 +19,8 @@ namespace Catch {
    ////////////////////////////////////////////////////////////////////////////


-    ScopedMessage::ScopedMessage( MessageBuilder const& builder ):
-        m_info( builder.m_info ) {
+    ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
+        m_info( CATCH_MOVE(builder.m_info) ) {
        m_info.message = builder.m_stream.str();
        getResultCapture().pushScopedMessage( m_info );
    }
--- a/src/catch2/catch_message.hpp
+++ b/src/catch2/catch_message.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -12,7 +12,7 @@
 #include <catch2/internal/catch_reusable_string_stream.hpp>
 #include <catch2/internal/catch_stream_end_stop.hpp>
 #include <catch2/internal/catch_message_info.hpp>
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
+#include <catch2/internal/catch_run_context.hpp>
 #include <catch2/catch_tostring.hpp>

 #include <string>
@@ -39,11 +39,10 @@ namespace Catch {
                        ResultWas::OfType type ):
            m_info(macroName, lineInfo, type) {}

-
        template<typename T>
-        MessageBuilder& operator << ( T const& value ) {
+        MessageBuilder&& operator << ( T const& value ) && {
            m_stream << value;
-            return *this;
+            return CATCH_MOVE(*this);
        }

        MessageInfo m_info;
@@ -51,7 +50,7 @@ namespace Catch {

    class ScopedMessage {
    public:
-        explicit ScopedMessage( MessageBuilder const& builder );
+        explicit ScopedMessage( MessageBuilder&& builder );
        ScopedMessage( ScopedMessage& duplicate ) = delete;
        ScopedMessage( ScopedMessage&& old ) noexcept;
        ~ScopedMessage();
@@ -62,7 +61,7 @@ namespace Catch {

    class Capturer {
        std::vector<MessageInfo> m_messages;
-        IResultCapture& m_resultCapture = getResultCapture();
+        RunContext& m_resultCapture = getResultCapture();
        size_t m_captured = 0;
    public:
        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
@@ -98,12 +97,15 @@ namespace Catch {

 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
-    Catch::Capturer varName( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
+    Catch::Capturer varName( macroName##_catch_sr,        \
+                             CATCH_INTERNAL_LINEINFO,     \
+                             Catch::ResultWas::Info,      \
+                             #__VA_ARGS__##_catch_sr );   \
    varName.captureValues( 0, __VA_ARGS__ )

 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+    const Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )

 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
--- a/src/catch2/catch_registry_hub.cpp
+++ b/src/catch2/catch_registry_hub.cpp
@@ -1,104 +0,0 @@
-
-//              Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
-//        https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
-
-#include <catch2/internal/catch_context.hpp>
-#include <catch2/internal/catch_enforce.hpp>
-#include <catch2/internal/catch_test_case_registry_impl.hpp>
-#include <catch2/internal/catch_reporter_registry.hpp>
-#include <catch2/internal/catch_exception_translator_registry.hpp>
-#include <catch2/internal/catch_tag_alias_registry.hpp>
-#include <catch2/internal/catch_startup_exception_registry.hpp>
-#include <catch2/internal/catch_singletons.hpp>
-#include <catch2/internal/catch_enum_values_registry.hpp>
-#include <catch2/catch_test_case_info.hpp>
-#include <catch2/internal/catch_noncopyable.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
-#include <catch2/internal/catch_move_and_forward.hpp>
-
-namespace Catch {
-
-    namespace {
-
-        class RegistryHub : public IRegistryHub,
-                            public IMutableRegistryHub,
-                            private Detail::NonCopyable {
-
-        public: // IRegistryHub
-            RegistryHub() = default;
-            IReporterRegistry const& getReporterRegistry() const override {
-                return m_reporterRegistry;
-            }
-            ITestCaseRegistry const& getTestCaseRegistry() const override {
-                return m_testCaseRegistry;
-            }
-            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
-                return m_exceptionTranslatorRegistry;
-            }
-            ITagAliasRegistry const& getTagAliasRegistry() const override {
-                return m_tagAliasRegistry;
-            }
-            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
-                return m_exceptionRegistry;
-            }
-
-        public: // IMutableRegistryHub
-            void registerReporter( std::string const& name, IReporterFactoryPtr factory ) override {
-                m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) );
-            }
-            void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) override {
-                m_reporterRegistry.registerListener( CATCH_MOVE(factory) );
-            }
-            void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker ) override {
-                m_testCaseRegistry.registerTest( CATCH_MOVE(testInfo), CATCH_MOVE(invoker) );
-            }
-            void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) override {
-                m_exceptionTranslatorRegistry.registerTranslator( CATCH_MOVE(translator) );
-            }
-            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
-                m_tagAliasRegistry.add( alias, tag, lineInfo );
-            }
-            void registerStartupException() noexcept override {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-                m_exceptionRegistry.add(std::current_exception());
-#else
-                CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-#endif
-            }
-            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
-                return m_enumValuesRegistry;
-            }
-
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-            TagAliasRegistry m_tagAliasRegistry;
-            StartupExceptionRegistry m_exceptionRegistry;
-            Detail::EnumValuesRegistry m_enumValuesRegistry;
-        };
-    }
-
-    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
-
-    IRegistryHub const& getRegistryHub() {
-        return RegistryHubSingleton::get();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return RegistryHubSingleton::getMutable();
-    }
-    void cleanUp() {
-        cleanupSingletons();
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
-
-
-} // end namespace Catch
--- a/src/catch2/catch_section_info.hpp
+++ b/src/catch2/catch_section_info.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_session.cpp
+++ b/src/catch2/catch_session.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -19,11 +19,14 @@
 #include <catch2/internal/catch_textflow.hpp>
 #include <catch2/internal/catch_windows_h_proxy.hpp>
 #include <catch2/reporters/catch_reporter_multi.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter_registry.hpp>
+#include <catch2/internal/catch_reporter_registry.hpp>
 #include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 #include <catch2/internal/catch_stdstreams.hpp>
 #include <catch2/internal/catch_istream.hpp>
+#include <catch2/internal/catch_test_case_registry_impl.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
+#include <catch2/catch_test_case_info.hpp>

 #include <algorithm>
 #include <cassert>
@@ -341,6 +344,12 @@ namespace Catch {
                return 2;
            }

+            if ( totals.testCases.total() > 0 &&
+                 totals.testCases.total() == totals.testCases.skipped
+                && !m_config->zeroTestsCountAsSuccess() ) {
+                return 4;
+            }
+
            // 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
--- a/src/catch2/catch_session.hpp
+++ b/src/catch2/catch_session.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_tag_alias.hpp
+++ b/src/catch2/catch_tag_alias.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_tag_alias_autoregistrar.cpp
+++ b/src/catch2/catch_tag_alias_autoregistrar.cpp
@@ -1,14 +1,14 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0

 #include <catch2/catch_tag_alias_autoregistrar.hpp>
 #include <catch2/internal/catch_compiler_capabilities.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>

 namespace Catch {

--- a/src/catch2/catch_tag_alias_autoregistrar.hpp
+++ b/src/catch2/catch_tag_alias_autoregistrar.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_template_test_macros.hpp
+++ b/src/catch2/catch_template_test_macros.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_test_case_info.cpp
+++ b/src/catch2/catch_test_case_info.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_test_case_info.hpp
+++ b/src/catch2/catch_test_case_info.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -15,6 +15,7 @@
 #include <catch2/internal/catch_unique_ptr.hpp>


+#include <cstdint>
 #include <string>
 #include <vector>

--- a/src/catch2/catch_test_macros.hpp
+++ b/src/catch2/catch_test_macros.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -49,6 +49,7 @@
  #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
  #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
  #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define CATCH_SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )


  #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
@@ -102,6 +103,7 @@
  #define CATCH_FAIL( ... ) (void)(0)
  #define CATCH_FAIL_CHECK( ... ) (void)(0)
  #define CATCH_SUCCEED( ... ) (void)(0)
+  #define CATCH_SKIP( ... ) (void)(0)

  #define CATCH_STATIC_REQUIRE( ... )       (void)(0)
  #define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
@@ -146,6 +148,7 @@
  #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
  #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
  #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )


  #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
@@ -198,6 +201,7 @@
  #define FAIL( ... ) (void)(0)
  #define FAIL_CHECK( ... ) (void)(0)
  #define SUCCEED( ... ) (void)(0)
+  #define SKIP( ... ) (void)(0)

  #define STATIC_REQUIRE( ... )       (void)(0)
  #define STATIC_REQUIRE_FALSE( ... ) (void)(0)
--- a/src/catch2/catch_test_run_info.hpp
+++ b/src/catch2/catch_test_run_info.hpp
@@ -0,0 +1,23 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_TEST_RUN_INFO_HPP_INCLUDED
+#define CATCH_TEST_RUN_INFO_HPP_INCLUDED
+
+#include <catch2/internal/catch_stringref.hpp>
+
+namespace Catch {
+
+    struct TestRunInfo {
+        constexpr TestRunInfo(StringRef _name) : name(_name) {}
+        StringRef name;
+    };
+
+
+} // end namespace Catch
+
+#endif // CATCH_TEST_RUN_INFO_HPP_INCLUDED
--- a/src/catch2/catch_test_spec.cpp
+++ b/src/catch2/catch_test_spec.cpp
@@ -1,17 +1,20 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/catch_test_spec.hpp>
+#include <catch2/internal/catch_reusable_string_stream.hpp>
 #include <catch2/internal/catch_string_manip.hpp>
+#include <catch2/internal/catch_test_case_registry_impl.hpp>
 #include <catch2/catch_test_case_info.hpp>

 #include <algorithm>
 #include <string>
 #include <vector>
+#include <ostream>

 namespace Catch {

@@ -35,6 +38,10 @@ namespace Catch {
        return m_wildcardPattern.matches( testCase.name );
    }

+    void TestSpec::NamePattern::serializeTo( std::ostream& out ) const {
+        out << '"' << name() << '"';
+    }
+

    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
    : Pattern( filterString )
@@ -47,6 +54,10 @@ namespace Catch {
                          Tag( m_tag ) ) != end( testCase.tags );
    }

+    void TestSpec::TagPattern::serializeTo( std::ostream& out ) const {
+        out << name();
+    }
+
    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
        bool should_use = !testCase.isHidden();
        for (auto const& pattern : m_required) {
@@ -63,18 +74,31 @@ namespace Catch {
        return should_use;
    }

-    std::string TestSpec::Filter::name() const {
-        std::string name;
-        for (auto const& p : m_required) {
-            name += p->name();
+    void TestSpec::Filter::serializeTo( std::ostream& out ) const {
+        bool first = true;
+        for ( auto const& pattern : m_required ) {
+            if ( !first ) {
+                out << ' ';
+            }
+            out << *pattern;
+            first = false;
        }
-        for (auto const& p : m_forbidden) {
-            name += p->name();
+        for ( auto const& pattern : m_forbidden ) {
+            if ( !first ) {
+                out << ' ';
+            }
+            out << *pattern;
+            first = false;
        }
-        return name;
    }


+    std::string TestSpec::extractFilterName( Filter const& filter ) {
+        Catch::ReusableStringStream sstr;
+        sstr << filter;
+        return sstr.str();
+    }
+
    bool TestSpec::hasFilters() const {
        return !m_filters.empty();
    }
@@ -91,7 +115,7 @@ namespace Catch {
            for( auto const& test : testCases )
                if( isThrowSafe( test, config ) && filter.matches( test.getTestCaseInfo() ) )
                    currentMatches.emplace_back( &test );
-            return FilterMatch{ filter.name(), currentMatches };
+            return FilterMatch{ extractFilterName(filter), currentMatches };
        } );
        return matches;
    }
@@ -100,4 +124,15 @@ namespace Catch {
        return m_invalidSpecs;
    }

+    void TestSpec::serializeTo( std::ostream& out ) const {
+        bool first = true;
+        for ( auto const& filter : m_filters ) {
+            if ( !first ) {
+                out << ',';
+            }
+            out << filter;
+            first = false;
+        }
+    }
+
 }
--- a/src/catch2/catch_test_spec.hpp
+++ b/src/catch2/catch_test_spec.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -16,6 +16,7 @@
 #include <catch2/internal/catch_unique_ptr.hpp>
 #include <catch2/internal/catch_wildcard_pattern.hpp>

+#include <iosfwd>
 #include <string>
 #include <vector>

@@ -34,6 +35,14 @@ namespace Catch {
            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
            std::string const& name() const;
        private:
+            virtual void serializeTo( std::ostream& out ) const = 0;
+            // Writes string that would be reparsed into the pattern
+            friend std::ostream& operator<<(std::ostream& out,
+                                            Pattern const& pattern) {
+                pattern.serializeTo( out );
+                return out;
+            }
+
            std::string const m_name;
        };

@@ -42,6 +51,8 @@ namespace Catch {
            explicit NamePattern( std::string const& name, std::string const& filterString );
            bool matches( TestCaseInfo const& testCase ) const override;
        private:
+            void serializeTo( std::ostream& out ) const override;
+
            WildcardPattern m_wildcardPattern;
        };

@@ -50,6 +61,8 @@ namespace Catch {
            explicit TagPattern( std::string const& tag, std::string const& filterString );
            bool matches( TestCaseInfo const& testCase ) const override;
        private:
+            void serializeTo( std::ostream& out ) const override;
+
            std::string m_tag;
        };

@@ -57,10 +70,19 @@ namespace Catch {
            std::vector<Detail::unique_ptr<Pattern>> m_required;
            std::vector<Detail::unique_ptr<Pattern>> m_forbidden;

+            //! Serializes this filter into a string that would be parsed into
+            //! an equivalent filter
+            void serializeTo( std::ostream& out ) const;
+            friend std::ostream& operator<<(std::ostream& out, Filter const& f) {
+                f.serializeTo( out );
+                return out;
+            }
+
            bool matches( TestCaseInfo const& testCase ) const;
-            std::string name() const;
        };

+        static std::string extractFilterName( Filter const& filter );
+
    public:
        struct FilterMatch {
            std::string name;
@@ -77,7 +99,16 @@ namespace Catch {
    private:
        std::vector<Filter> m_filters;
        std::vector<std::string> m_invalidSpecs;
+
        friend class TestSpecParser;
+        //! Serializes this test spec into a string that would be parsed into
+        //! equivalent test spec
+        void serializeTo( std::ostream& out ) const;
+        friend std::ostream& operator<<(std::ostream& out,
+                                        TestSpec const& spec) {
+            spec.serializeTo( out );
+            return out;
+        }
    };
 }

--- a/src/catch2/catch_timer.cpp
+++ b/src/catch2/catch_timer.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_timer.hpp
+++ b/src/catch2/catch_timer.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_tostring.cpp
+++ b/src/catch2/catch_tostring.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/src/catch2/catch_tostring.hpp
+++ b/src/catch2/catch_tostring.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -16,9 +16,9 @@

 #include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_config_wchar.hpp>
+#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_reusable_string_stream.hpp>
 #include <catch2/internal/catch_void_type.hpp>
-#include <catch2/interfaces/catch_interfaces_enum_values_registry.hpp>

 #ifdef CATCH_CONFIG_CPP17_STRING_VIEW
 #include <string_view>
@@ -648,7 +648,7 @@ struct ratio_string<std::milli> {
    };
 }

-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>

 #define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
 namespace Catch { \
--- a/src/catch2/catch_totals.cpp
+++ b/src/catch2/catch_totals.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -14,6 +14,7 @@ namespace Catch {
        diff.passed = passed - other.passed;
        diff.failed = failed - other.failed;
        diff.failedButOk = failedButOk - other.failedButOk;
+        diff.skipped = skipped - other.skipped;
        return diff;
    }

@@ -21,14 +22,15 @@ namespace Catch {
        passed += other.passed;
        failed += other.failed;
        failedButOk += other.failedButOk;
+        skipped += other.skipped;
        return *this;
    }

    std::uint64_t Counts::total() const {
-        return passed + failed + failedButOk;
+        return passed + failed + failedButOk + skipped;
    }
    bool Counts::allPassed() const {
-        return failed == 0 && failedButOk == 0;
+        return failed == 0 && failedButOk == 0 && skipped == 0;
    }
    bool Counts::allOk() const {
        return failed == 0;
@@ -53,6 +55,8 @@ namespace Catch {
            ++diff.testCases.failed;
        else if( diff.assertions.failedButOk > 0 )
            ++diff.testCases.failedButOk;
+        else if ( diff.assertions.skipped > 0 )
+            ++ diff.testCases.skipped;
        else
            ++diff.testCases.passed;
        return diff;
--- a/src/catch2/catch_totals.hpp
+++ b/src/catch2/catch_totals.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -23,6 +23,7 @@ namespace Catch {
        std::uint64_t passed = 0;
        std::uint64_t failed = 0;
        std::uint64_t failedButOk = 0;
+        std::uint64_t skipped = 0;
    };

    struct Totals {
--- a/src/catch2/catch_translate_exception.cpp
+++ b/src/catch2/catch_translate_exception.cpp
@@ -0,0 +1,20 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/catch_translate_exception.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
+
+namespace Catch {
+    namespace Detail {
+        void registerTranslatorImpl(
+            Detail::unique_ptr<IExceptionTranslator>&& translator ) {
+            getMutableRegistryHub().registerTranslator(
+                CATCH_MOVE( translator ) );
+        }
+    } // namespace Detail
+} // namespace Catch
--- a/src/catch2/catch_translate_exception.hpp
+++ b/src/catch2/catch_translate_exception.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -15,6 +15,10 @@
 #include <exception>

 namespace Catch {
+    namespace Detail {
+        void registerTranslatorImpl(
+            Detail::unique_ptr<IExceptionTranslator>&& translator );
+    }

    class ExceptionTranslatorRegistrar {
        template<typename T>
@@ -48,9 +52,8 @@ namespace Catch {
    public:
        template<typename T>
        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T const& ) ) {
-            getMutableRegistryHub().registerTranslator(
-                Detail::make_unique<ExceptionTranslator<T>>(translateFunction)
-            );
+            Detail::registerTranslatorImpl( Detail::make_unique<ExceptionTranslator<T>>(
+                translateFunction ) );
        }
    };

--- a/src/catch2/catch_user_config.hpp.in
+++ b/src/catch2/catch_user_config.hpp.in
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -130,6 +130,16 @@



+#cmakedefine CATCH_CONFIG_GETENV
+#cmakedefine CATCH_CONFIG_NO_GETENV
+
+#if defined( CATCH_CONFIG_GETENV ) && \
+    defined( CATCH_CONFIG_NO_GETENV )
+#    error Cannot force GETENV to both ON and OFF
+#endif
+
+
+
 #cmakedefine CATCH_CONFIG_USE_ASYNC
 #cmakedefine CATCH_CONFIG_NO_USE_ASYNC

--- a/src/catch2/catch_version.cpp
+++ b/src/catch2/catch_version.cpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
@@ -36,7 +36,7 @@ namespace Catch {
    }

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

--- a/src/catch2/catch_version.hpp
+++ b/src/catch2/catch_version.hpp
@@ -1,7 +1,7 @@

 //              Copyright Catch2 Authors
 // Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE_1_0.txt or copy at
+//   (See accompanying file LICENSE.txt or copy at
 //        https://www.boost.org/LICENSE_1_0.txt)

 // SPDX-License-Identifier: BSL-1.0
--- a/Show More
+++ b/Show More